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.
43976 lines
1.4 MiB
43976 lines
1.4 MiB
this["wp"] = this["wp"] || {}; this["wp"]["components"] = |
|
/******/ (function(modules) { // webpackBootstrap |
|
/******/ // The module cache |
|
/******/ var installedModules = {}; |
|
/******/ |
|
/******/ // The require function |
|
/******/ function __webpack_require__(moduleId) { |
|
/******/ |
|
/******/ // Check if module is in cache |
|
/******/ if(installedModules[moduleId]) { |
|
/******/ return installedModules[moduleId].exports; |
|
/******/ } |
|
/******/ // Create a new module (and put it into the cache) |
|
/******/ var module = installedModules[moduleId] = { |
|
/******/ i: moduleId, |
|
/******/ l: false, |
|
/******/ exports: {} |
|
/******/ }; |
|
/******/ |
|
/******/ // Execute the module function |
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); |
|
/******/ |
|
/******/ // Flag the module as loaded |
|
/******/ module.l = true; |
|
/******/ |
|
/******/ // Return the exports of the module |
|
/******/ return module.exports; |
|
/******/ } |
|
/******/ |
|
/******/ |
|
/******/ // expose the modules object (__webpack_modules__) |
|
/******/ __webpack_require__.m = modules; |
|
/******/ |
|
/******/ // expose the module cache |
|
/******/ __webpack_require__.c = installedModules; |
|
/******/ |
|
/******/ // define getter function for harmony exports |
|
/******/ __webpack_require__.d = function(exports, name, getter) { |
|
/******/ if(!__webpack_require__.o(exports, name)) { |
|
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); |
|
/******/ } |
|
/******/ }; |
|
/******/ |
|
/******/ // define __esModule on exports |
|
/******/ __webpack_require__.r = function(exports) { |
|
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { |
|
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); |
|
/******/ } |
|
/******/ Object.defineProperty(exports, '__esModule', { value: true }); |
|
/******/ }; |
|
/******/ |
|
/******/ // create a fake namespace object |
|
/******/ // mode & 1: value is a module id, require it |
|
/******/ // mode & 2: merge all properties of value into the ns |
|
/******/ // mode & 4: return value when already ns object |
|
/******/ // mode & 8|1: behave like require |
|
/******/ __webpack_require__.t = function(value, mode) { |
|
/******/ if(mode & 1) value = __webpack_require__(value); |
|
/******/ if(mode & 8) return value; |
|
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; |
|
/******/ var ns = Object.create(null); |
|
/******/ __webpack_require__.r(ns); |
|
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); |
|
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); |
|
/******/ return ns; |
|
/******/ }; |
|
/******/ |
|
/******/ // getDefaultExport function for compatibility with non-harmony modules |
|
/******/ __webpack_require__.n = function(module) { |
|
/******/ var getter = module && module.__esModule ? |
|
/******/ function getDefault() { return module['default']; } : |
|
/******/ function getModuleExports() { return module; }; |
|
/******/ __webpack_require__.d(getter, 'a', getter); |
|
/******/ return getter; |
|
/******/ }; |
|
/******/ |
|
/******/ // Object.prototype.hasOwnProperty.call |
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; |
|
/******/ |
|
/******/ // __webpack_public_path__ |
|
/******/ __webpack_require__.p = ""; |
|
/******/ |
|
/******/ |
|
/******/ // Load entry module and return exports |
|
/******/ return __webpack_require__(__webpack_require__.s = 344); |
|
/******/ }) |
|
/************************************************************************/ |
|
/******/ ([ |
|
/* 0 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["element"]; }()); |
|
|
|
/***/ }), |
|
/* 1 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["i18n"]; }()); |
|
|
|
/***/ }), |
|
/* 2 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["lodash"]; }()); |
|
|
|
/***/ }), |
|
/* 3 */, |
|
/* 4 */, |
|
/* 5 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; }); |
|
function _assertThisInitialized(self) { |
|
if (self === void 0) { |
|
throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); |
|
} |
|
|
|
return self; |
|
} |
|
|
|
/***/ }), |
|
/* 6 */, |
|
/* 7 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectSpread; }); |
|
/* harmony import */ var _defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(10); |
|
|
|
function _objectSpread(target) { |
|
for (var i = 1; i < arguments.length; i++) { |
|
var source = arguments[i] != null ? arguments[i] : {}; |
|
var ownKeys = Object.keys(source); |
|
|
|
if (typeof Object.getOwnPropertySymbols === 'function') { |
|
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { |
|
return Object.getOwnPropertyDescriptor(source, sym).enumerable; |
|
})); |
|
} |
|
|
|
ownKeys.forEach(function (key) { |
|
Object(_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(target, key, source[key]); |
|
}); |
|
} |
|
|
|
return target; |
|
} |
|
|
|
/***/ }), |
|
/* 8 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["compose"]; }()); |
|
|
|
/***/ }), |
|
/* 9 */, |
|
/* 10 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; }); |
|
function _defineProperty(obj, key, value) { |
|
if (key in obj) { |
|
Object.defineProperty(obj, key, { |
|
value: value, |
|
enumerable: true, |
|
configurable: true, |
|
writable: true |
|
}); |
|
} else { |
|
obj[key] = value; |
|
} |
|
|
|
return obj; |
|
} |
|
|
|
/***/ }), |
|
/* 11 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; }); |
|
function _defineProperties(target, props) { |
|
for (var i = 0; i < props.length; i++) { |
|
var descriptor = props[i]; |
|
descriptor.enumerable = descriptor.enumerable || false; |
|
descriptor.configurable = true; |
|
if ("value" in descriptor) descriptor.writable = true; |
|
Object.defineProperty(target, descriptor.key, descriptor); |
|
} |
|
} |
|
|
|
function _createClass(Constructor, protoProps, staticProps) { |
|
if (protoProps) _defineProperties(Constructor.prototype, protoProps); |
|
if (staticProps) _defineProperties(Constructor, staticProps); |
|
return Constructor; |
|
} |
|
|
|
/***/ }), |
|
/* 12 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; }); |
|
function _classCallCheck(instance, Constructor) { |
|
if (!(instance instanceof Constructor)) { |
|
throw new TypeError("Cannot call a class as a function"); |
|
} |
|
} |
|
|
|
/***/ }), |
|
/* 13 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; }); |
|
/* harmony import */ var _helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(31); |
|
/* harmony import */ var _assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5); |
|
|
|
|
|
function _possibleConstructorReturn(self, call) { |
|
if (call && (Object(_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(call) === "object" || typeof call === "function")) { |
|
return call; |
|
} |
|
|
|
return Object(_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self); |
|
} |
|
|
|
/***/ }), |
|
/* 14 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _getPrototypeOf; }); |
|
function _getPrototypeOf(o) { |
|
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { |
|
return o.__proto__ || Object.getPrototypeOf(o); |
|
}; |
|
return _getPrototypeOf(o); |
|
} |
|
|
|
/***/ }), |
|
/* 15 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js |
|
function _setPrototypeOf(o, p) { |
|
_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { |
|
o.__proto__ = p; |
|
return o; |
|
}; |
|
|
|
return _setPrototypeOf(o, p); |
|
} |
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _inherits; }); |
|
|
|
function _inherits(subClass, superClass) { |
|
if (typeof superClass !== "function" && superClass !== null) { |
|
throw new TypeError("Super expression must either be null or a function"); |
|
} |
|
|
|
subClass.prototype = Object.create(superClass && superClass.prototype, { |
|
constructor: { |
|
value: subClass, |
|
writable: true, |
|
configurable: true |
|
} |
|
}); |
|
if (superClass) _setPrototypeOf(subClass, superClass); |
|
} |
|
|
|
/***/ }), |
|
/* 16 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! |
|
Copyright (c) 2017 Jed Watson. |
|
Licensed under the MIT License (MIT), see |
|
http://jedwatson.github.io/classnames |
|
*/ |
|
/* global define */ |
|
|
|
(function () { |
|
'use strict'; |
|
|
|
var hasOwn = {}.hasOwnProperty; |
|
|
|
function classNames () { |
|
var classes = []; |
|
|
|
for (var i = 0; i < arguments.length; i++) { |
|
var arg = arguments[i]; |
|
if (!arg) continue; |
|
|
|
var argType = typeof arg; |
|
|
|
if (argType === 'string' || argType === 'number') { |
|
classes.push(arg); |
|
} else if (Array.isArray(arg) && arg.length) { |
|
var inner = classNames.apply(null, arg); |
|
if (inner) { |
|
classes.push(inner); |
|
} |
|
} else if (argType === 'object') { |
|
for (var key in arg) { |
|
if (hasOwn.call(arg, key) && arg[key]) { |
|
classes.push(key); |
|
} |
|
} |
|
} |
|
} |
|
|
|
return classes.join(' '); |
|
} |
|
|
|
if ( true && module.exports) { |
|
classNames.default = classNames; |
|
module.exports = classNames; |
|
} else if (true) { |
|
// register as 'classnames', consistent with npm package name |
|
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () { |
|
return classNames; |
|
}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), |
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); |
|
} else {} |
|
}()); |
|
|
|
|
|
/***/ }), |
|
/* 17 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js |
|
function _arrayWithoutHoles(arr) { |
|
if (Array.isArray(arr)) { |
|
for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { |
|
arr2[i] = arr[i]; |
|
} |
|
|
|
return arr2; |
|
} |
|
} |
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js |
|
var iterableToArray = __webpack_require__(30); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js |
|
function _nonIterableSpread() { |
|
throw new TypeError("Invalid attempt to spread non-iterable instance"); |
|
} |
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _toConsumableArray; }); |
|
|
|
|
|
|
|
function _toConsumableArray(arr) { |
|
return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || _nonIterableSpread(); |
|
} |
|
|
|
/***/ }), |
|
/* 18 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; }); |
|
function _extends() { |
|
_extends = Object.assign || function (target) { |
|
for (var i = 1; i < arguments.length; i++) { |
|
var source = arguments[i]; |
|
|
|
for (var key in source) { |
|
if (Object.prototype.hasOwnProperty.call(source, key)) { |
|
target[key] = source[key]; |
|
} |
|
} |
|
} |
|
|
|
return target; |
|
}; |
|
|
|
return _extends.apply(this, arguments); |
|
} |
|
|
|
/***/ }), |
|
/* 19 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["keycodes"]; }()); |
|
|
|
/***/ }), |
|
/* 20 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
module.exports = __webpack_require__(47); |
|
|
|
|
|
/***/ }), |
|
/* 21 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js |
|
function _objectWithoutPropertiesLoose(source, excluded) { |
|
if (source == null) return {}; |
|
var target = {}; |
|
var sourceKeys = Object.keys(source); |
|
var key, i; |
|
|
|
for (i = 0; i < sourceKeys.length; i++) { |
|
key = sourceKeys[i]; |
|
if (excluded.indexOf(key) >= 0) continue; |
|
target[key] = source[key]; |
|
} |
|
|
|
return target; |
|
} |
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutProperties; }); |
|
|
|
function _objectWithoutProperties(source, excluded) { |
|
if (source == null) return {}; |
|
var target = _objectWithoutPropertiesLoose(source, excluded); |
|
var key, i; |
|
|
|
if (Object.getOwnPropertySymbols) { |
|
var sourceSymbolKeys = Object.getOwnPropertySymbols(source); |
|
|
|
for (i = 0; i < sourceSymbolKeys.length; i++) { |
|
key = sourceSymbolKeys[i]; |
|
if (excluded.indexOf(key) >= 0) continue; |
|
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; |
|
target[key] = source[key]; |
|
} |
|
} |
|
|
|
return target; |
|
} |
|
|
|
/***/ }), |
|
/* 22 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["richText"]; }()); |
|
|
|
/***/ }), |
|
/* 23 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js |
|
var arrayWithHoles = __webpack_require__(38); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js |
|
function _iterableToArrayLimit(arr, i) { |
|
var _arr = []; |
|
var _n = true; |
|
var _d = false; |
|
var _e = undefined; |
|
|
|
try { |
|
for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { |
|
_arr.push(_s.value); |
|
|
|
if (i && _arr.length === i) break; |
|
} |
|
} catch (err) { |
|
_d = true; |
|
_e = err; |
|
} finally { |
|
try { |
|
if (!_n && _i["return"] != null) _i["return"](); |
|
} finally { |
|
if (_d) throw _e; |
|
} |
|
} |
|
|
|
return _arr; |
|
} |
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js |
|
var nonIterableRest = __webpack_require__(39); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _slicedToArray; }); |
|
|
|
|
|
|
|
function _slicedToArray(arr, i) { |
|
return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(nonIterableRest["a" /* default */])(); |
|
} |
|
|
|
/***/ }), |
|
/* 24 */, |
|
/* 25 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["dom"]; }()); |
|
|
|
/***/ }), |
|
/* 26 */, |
|
/* 27 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["hooks"]; }()); |
|
|
|
/***/ }), |
|
/* 28 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["React"]; }()); |
|
|
|
/***/ }), |
|
/* 29 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["moment"]; }()); |
|
|
|
/***/ }), |
|
/* 30 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; }); |
|
function _iterableToArray(iter) { |
|
if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); |
|
} |
|
|
|
/***/ }), |
|
/* 31 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _typeof; }); |
|
function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); } |
|
|
|
function _typeof(obj) { |
|
if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") { |
|
_typeof = function _typeof(obj) { |
|
return _typeof2(obj); |
|
}; |
|
} else { |
|
_typeof = function _typeof(obj) { |
|
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj); |
|
}; |
|
} |
|
|
|
return _typeof(obj); |
|
} |
|
|
|
/***/ }), |
|
/* 32 */, |
|
/* 33 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Copyright (c) 2013-present, Facebook, Inc. |
|
* |
|
* This source code is licensed under the MIT license found in the |
|
* LICENSE file in the root directory of this source tree. |
|
*/ |
|
|
|
if (false) { var throwOnDirectAccess, ReactIs; } else { |
|
// By explicitly using `prop-types` you are opting into new production behavior. |
|
// http://fb.me/prop-types-in-prod |
|
module.exports = __webpack_require__(87)(); |
|
} |
|
|
|
|
|
/***/ }), |
|
/* 34 */, |
|
/* 35 */, |
|
/* 36 */, |
|
/* 37 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["deprecated"]; }()); |
|
|
|
/***/ }), |
|
/* 38 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; }); |
|
function _arrayWithHoles(arr) { |
|
if (Array.isArray(arr)) return arr; |
|
} |
|
|
|
/***/ }), |
|
/* 39 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; }); |
|
function _nonIterableRest() { |
|
throw new TypeError("Invalid attempt to destructure non-iterable instance"); |
|
} |
|
|
|
/***/ }), |
|
/* 40 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
var DISPLAY_FORMAT = exports.DISPLAY_FORMAT = 'L'; |
|
var ISO_FORMAT = exports.ISO_FORMAT = 'YYYY-MM-DD'; |
|
var ISO_MONTH_FORMAT = exports.ISO_MONTH_FORMAT = 'YYYY-MM'; |
|
|
|
var START_DATE = exports.START_DATE = 'startDate'; |
|
var END_DATE = exports.END_DATE = 'endDate'; |
|
|
|
var HORIZONTAL_ORIENTATION = exports.HORIZONTAL_ORIENTATION = 'horizontal'; |
|
var VERTICAL_ORIENTATION = exports.VERTICAL_ORIENTATION = 'vertical'; |
|
var VERTICAL_SCROLLABLE = exports.VERTICAL_SCROLLABLE = 'verticalScrollable'; |
|
|
|
var ICON_BEFORE_POSITION = exports.ICON_BEFORE_POSITION = 'before'; |
|
var ICON_AFTER_POSITION = exports.ICON_AFTER_POSITION = 'after'; |
|
|
|
var INFO_POSITION_TOP = exports.INFO_POSITION_TOP = 'top'; |
|
var INFO_POSITION_BOTTOM = exports.INFO_POSITION_BOTTOM = 'bottom'; |
|
var INFO_POSITION_BEFORE = exports.INFO_POSITION_BEFORE = 'before'; |
|
var INFO_POSITION_AFTER = exports.INFO_POSITION_AFTER = 'after'; |
|
|
|
var ANCHOR_LEFT = exports.ANCHOR_LEFT = 'left'; |
|
var ANCHOR_RIGHT = exports.ANCHOR_RIGHT = 'right'; |
|
|
|
var OPEN_DOWN = exports.OPEN_DOWN = 'down'; |
|
var OPEN_UP = exports.OPEN_UP = 'up'; |
|
|
|
var DAY_SIZE = exports.DAY_SIZE = 39; |
|
var BLOCKED_MODIFIER = exports.BLOCKED_MODIFIER = 'blocked'; |
|
var WEEKDAYS = exports.WEEKDAYS = [0, 1, 2, 3, 4, 5, 6]; |
|
|
|
var FANG_WIDTH_PX = exports.FANG_WIDTH_PX = 20; |
|
var FANG_HEIGHT_PX = exports.FANG_HEIGHT_PX = 10; |
|
var DEFAULT_VERTICAL_SPACING = exports.DEFAULT_VERTICAL_SPACING = 22; |
|
|
|
var MODIFIER_KEY_NAMES = exports.MODIFIER_KEY_NAMES = new Set(['Shift', 'Control', 'Alt', 'Meta']); |
|
|
|
/***/ }), |
|
/* 41 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["isShallowEqual"]; }()); |
|
|
|
/***/ }), |
|
/* 42 */, |
|
/* 43 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _asyncToGenerator; }); |
|
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { |
|
try { |
|
var info = gen[key](arg); |
|
var value = info.value; |
|
} catch (error) { |
|
reject(error); |
|
return; |
|
} |
|
|
|
if (info.done) { |
|
resolve(value); |
|
} else { |
|
Promise.resolve(value).then(_next, _throw); |
|
} |
|
} |
|
|
|
function _asyncToGenerator(fn) { |
|
return function () { |
|
var self = this, |
|
args = arguments; |
|
return new Promise(function (resolve, reject) { |
|
var gen = fn.apply(self, args); |
|
|
|
function _next(value) { |
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); |
|
} |
|
|
|
function _throw(err) { |
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); |
|
} |
|
|
|
_next(undefined); |
|
}); |
|
}; |
|
} |
|
|
|
/***/ }), |
|
/* 44 */, |
|
/* 45 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["a11y"]; }()); |
|
|
|
/***/ }), |
|
/* 46 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
module.exports = true ? __webpack_require__(271) : undefined; |
|
|
|
|
|
|
|
/***/ }), |
|
/* 47 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Copyright (c) 2014-present, Facebook, Inc. |
|
* |
|
* This source code is licensed under the MIT license found in the |
|
* LICENSE file in the root directory of this source tree. |
|
*/ |
|
|
|
var runtime = (function (exports) { |
|
"use strict"; |
|
|
|
var Op = Object.prototype; |
|
var hasOwn = Op.hasOwnProperty; |
|
var undefined; // More compressible than void 0. |
|
var $Symbol = typeof Symbol === "function" ? Symbol : {}; |
|
var iteratorSymbol = $Symbol.iterator || "@@iterator"; |
|
var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator"; |
|
var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; |
|
|
|
function wrap(innerFn, outerFn, self, tryLocsList) { |
|
// If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator. |
|
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator; |
|
var generator = Object.create(protoGenerator.prototype); |
|
var context = new Context(tryLocsList || []); |
|
|
|
// The ._invoke method unifies the implementations of the .next, |
|
// .throw, and .return methods. |
|
generator._invoke = makeInvokeMethod(innerFn, self, context); |
|
|
|
return generator; |
|
} |
|
exports.wrap = wrap; |
|
|
|
// Try/catch helper to minimize deoptimizations. Returns a completion |
|
// record like context.tryEntries[i].completion. This interface could |
|
// have been (and was previously) designed to take a closure to be |
|
// invoked without arguments, but in all the cases we care about we |
|
// already have an existing method we want to call, so there's no need |
|
// to create a new function object. We can even get away with assuming |
|
// the method takes exactly one argument, since that happens to be true |
|
// in every case, so we don't have to touch the arguments object. The |
|
// only additional allocation required is the completion record, which |
|
// has a stable shape and so hopefully should be cheap to allocate. |
|
function tryCatch(fn, obj, arg) { |
|
try { |
|
return { type: "normal", arg: fn.call(obj, arg) }; |
|
} catch (err) { |
|
return { type: "throw", arg: err }; |
|
} |
|
} |
|
|
|
var GenStateSuspendedStart = "suspendedStart"; |
|
var GenStateSuspendedYield = "suspendedYield"; |
|
var GenStateExecuting = "executing"; |
|
var GenStateCompleted = "completed"; |
|
|
|
// Returning this object from the innerFn has the same effect as |
|
// breaking out of the dispatch switch statement. |
|
var ContinueSentinel = {}; |
|
|
|
// Dummy constructor functions that we use as the .constructor and |
|
// .constructor.prototype properties for functions that return Generator |
|
// objects. For full spec compliance, you may wish to configure your |
|
// minifier not to mangle the names of these two functions. |
|
function Generator() {} |
|
function GeneratorFunction() {} |
|
function GeneratorFunctionPrototype() {} |
|
|
|
// This is a polyfill for %IteratorPrototype% for environments that |
|
// don't natively support it. |
|
var IteratorPrototype = {}; |
|
IteratorPrototype[iteratorSymbol] = function () { |
|
return this; |
|
}; |
|
|
|
var getProto = Object.getPrototypeOf; |
|
var NativeIteratorPrototype = getProto && getProto(getProto(values([]))); |
|
if (NativeIteratorPrototype && |
|
NativeIteratorPrototype !== Op && |
|
hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) { |
|
// This environment has a native %IteratorPrototype%; use it instead |
|
// of the polyfill. |
|
IteratorPrototype = NativeIteratorPrototype; |
|
} |
|
|
|
var Gp = GeneratorFunctionPrototype.prototype = |
|
Generator.prototype = Object.create(IteratorPrototype); |
|
GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype; |
|
GeneratorFunctionPrototype.constructor = GeneratorFunction; |
|
GeneratorFunctionPrototype[toStringTagSymbol] = |
|
GeneratorFunction.displayName = "GeneratorFunction"; |
|
|
|
// Helper for defining the .next, .throw, and .return methods of the |
|
// Iterator interface in terms of a single ._invoke method. |
|
function defineIteratorMethods(prototype) { |
|
["next", "throw", "return"].forEach(function(method) { |
|
prototype[method] = function(arg) { |
|
return this._invoke(method, arg); |
|
}; |
|
}); |
|
} |
|
|
|
exports.isGeneratorFunction = function(genFun) { |
|
var ctor = typeof genFun === "function" && genFun.constructor; |
|
return ctor |
|
? ctor === GeneratorFunction || |
|
// For the native GeneratorFunction constructor, the best we can |
|
// do is to check its .name property. |
|
(ctor.displayName || ctor.name) === "GeneratorFunction" |
|
: false; |
|
}; |
|
|
|
exports.mark = function(genFun) { |
|
if (Object.setPrototypeOf) { |
|
Object.setPrototypeOf(genFun, GeneratorFunctionPrototype); |
|
} else { |
|
genFun.__proto__ = GeneratorFunctionPrototype; |
|
if (!(toStringTagSymbol in genFun)) { |
|
genFun[toStringTagSymbol] = "GeneratorFunction"; |
|
} |
|
} |
|
genFun.prototype = Object.create(Gp); |
|
return genFun; |
|
}; |
|
|
|
// Within the body of any async function, `await x` is transformed to |
|
// `yield regeneratorRuntime.awrap(x)`, so that the runtime can test |
|
// `hasOwn.call(value, "__await")` to determine if the yielded value is |
|
// meant to be awaited. |
|
exports.awrap = function(arg) { |
|
return { __await: arg }; |
|
}; |
|
|
|
function AsyncIterator(generator) { |
|
function invoke(method, arg, resolve, reject) { |
|
var record = tryCatch(generator[method], generator, arg); |
|
if (record.type === "throw") { |
|
reject(record.arg); |
|
} else { |
|
var result = record.arg; |
|
var value = result.value; |
|
if (value && |
|
typeof value === "object" && |
|
hasOwn.call(value, "__await")) { |
|
return Promise.resolve(value.__await).then(function(value) { |
|
invoke("next", value, resolve, reject); |
|
}, function(err) { |
|
invoke("throw", err, resolve, reject); |
|
}); |
|
} |
|
|
|
return Promise.resolve(value).then(function(unwrapped) { |
|
// When a yielded Promise is resolved, its final value becomes |
|
// the .value of the Promise<{value,done}> result for the |
|
// current iteration. |
|
result.value = unwrapped; |
|
resolve(result); |
|
}, function(error) { |
|
// If a rejected Promise was yielded, throw the rejection back |
|
// into the async generator function so it can be handled there. |
|
return invoke("throw", error, resolve, reject); |
|
}); |
|
} |
|
} |
|
|
|
var previousPromise; |
|
|
|
function enqueue(method, arg) { |
|
function callInvokeWithMethodAndArg() { |
|
return new Promise(function(resolve, reject) { |
|
invoke(method, arg, resolve, reject); |
|
}); |
|
} |
|
|
|
return previousPromise = |
|
// If enqueue has been called before, then we want to wait until |
|
// all previous Promises have been resolved before calling invoke, |
|
// so that results are always delivered in the correct order. If |
|
// enqueue has not been called before, then it is important to |
|
// call invoke immediately, without waiting on a callback to fire, |
|
// so that the async generator function has the opportunity to do |
|
// any necessary setup in a predictable way. This predictability |
|
// is why the Promise constructor synchronously invokes its |
|
// executor callback, and why async functions synchronously |
|
// execute code before the first await. Since we implement simple |
|
// async functions in terms of async generators, it is especially |
|
// important to get this right, even though it requires care. |
|
previousPromise ? previousPromise.then( |
|
callInvokeWithMethodAndArg, |
|
// Avoid propagating failures to Promises returned by later |
|
// invocations of the iterator. |
|
callInvokeWithMethodAndArg |
|
) : callInvokeWithMethodAndArg(); |
|
} |
|
|
|
// Define the unified helper method that is used to implement .next, |
|
// .throw, and .return (see defineIteratorMethods). |
|
this._invoke = enqueue; |
|
} |
|
|
|
defineIteratorMethods(AsyncIterator.prototype); |
|
AsyncIterator.prototype[asyncIteratorSymbol] = function () { |
|
return this; |
|
}; |
|
exports.AsyncIterator = AsyncIterator; |
|
|
|
// Note that simple async functions are implemented on top of |
|
// AsyncIterator objects; they just return a Promise for the value of |
|
// the final result produced by the iterator. |
|
exports.async = function(innerFn, outerFn, self, tryLocsList) { |
|
var iter = new AsyncIterator( |
|
wrap(innerFn, outerFn, self, tryLocsList) |
|
); |
|
|
|
return exports.isGeneratorFunction(outerFn) |
|
? iter // If outerFn is a generator, return the full iterator. |
|
: iter.next().then(function(result) { |
|
return result.done ? result.value : iter.next(); |
|
}); |
|
}; |
|
|
|
function makeInvokeMethod(innerFn, self, context) { |
|
var state = GenStateSuspendedStart; |
|
|
|
return function invoke(method, arg) { |
|
if (state === GenStateExecuting) { |
|
throw new Error("Generator is already running"); |
|
} |
|
|
|
if (state === GenStateCompleted) { |
|
if (method === "throw") { |
|
throw arg; |
|
} |
|
|
|
// Be forgiving, per 25.3.3.3.3 of the spec: |
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume |
|
return doneResult(); |
|
} |
|
|
|
context.method = method; |
|
context.arg = arg; |
|
|
|
while (true) { |
|
var delegate = context.delegate; |
|
if (delegate) { |
|
var delegateResult = maybeInvokeDelegate(delegate, context); |
|
if (delegateResult) { |
|
if (delegateResult === ContinueSentinel) continue; |
|
return delegateResult; |
|
} |
|
} |
|
|
|
if (context.method === "next") { |
|
// Setting context._sent for legacy support of Babel's |
|
// function.sent implementation. |
|
context.sent = context._sent = context.arg; |
|
|
|
} else if (context.method === "throw") { |
|
if (state === GenStateSuspendedStart) { |
|
state = GenStateCompleted; |
|
throw context.arg; |
|
} |
|
|
|
context.dispatchException(context.arg); |
|
|
|
} else if (context.method === "return") { |
|
context.abrupt("return", context.arg); |
|
} |
|
|
|
state = GenStateExecuting; |
|
|
|
var record = tryCatch(innerFn, self, context); |
|
if (record.type === "normal") { |
|
// If an exception is thrown from innerFn, we leave state === |
|
// GenStateExecuting and loop back for another invocation. |
|
state = context.done |
|
? GenStateCompleted |
|
: GenStateSuspendedYield; |
|
|
|
if (record.arg === ContinueSentinel) { |
|
continue; |
|
} |
|
|
|
return { |
|
value: record.arg, |
|
done: context.done |
|
}; |
|
|
|
} else if (record.type === "throw") { |
|
state = GenStateCompleted; |
|
// Dispatch the exception by looping back around to the |
|
// context.dispatchException(context.arg) call above. |
|
context.method = "throw"; |
|
context.arg = record.arg; |
|
} |
|
} |
|
}; |
|
} |
|
|
|
// Call delegate.iterator[context.method](context.arg) and handle the |
|
// result, either by returning a { value, done } result from the |
|
// delegate iterator, or by modifying context.method and context.arg, |
|
// setting context.delegate to null, and returning the ContinueSentinel. |
|
function maybeInvokeDelegate(delegate, context) { |
|
var method = delegate.iterator[context.method]; |
|
if (method === undefined) { |
|
// A .throw or .return when the delegate iterator has no .throw |
|
// method always terminates the yield* loop. |
|
context.delegate = null; |
|
|
|
if (context.method === "throw") { |
|
// Note: ["return"] must be used for ES3 parsing compatibility. |
|
if (delegate.iterator["return"]) { |
|
// If the delegate iterator has a return method, give it a |
|
// chance to clean up. |
|
context.method = "return"; |
|
context.arg = undefined; |
|
maybeInvokeDelegate(delegate, context); |
|
|
|
if (context.method === "throw") { |
|
// If maybeInvokeDelegate(context) changed context.method from |
|
// "return" to "throw", let that override the TypeError below. |
|
return ContinueSentinel; |
|
} |
|
} |
|
|
|
context.method = "throw"; |
|
context.arg = new TypeError( |
|
"The iterator does not provide a 'throw' method"); |
|
} |
|
|
|
return ContinueSentinel; |
|
} |
|
|
|
var record = tryCatch(method, delegate.iterator, context.arg); |
|
|
|
if (record.type === "throw") { |
|
context.method = "throw"; |
|
context.arg = record.arg; |
|
context.delegate = null; |
|
return ContinueSentinel; |
|
} |
|
|
|
var info = record.arg; |
|
|
|
if (! info) { |
|
context.method = "throw"; |
|
context.arg = new TypeError("iterator result is not an object"); |
|
context.delegate = null; |
|
return ContinueSentinel; |
|
} |
|
|
|
if (info.done) { |
|
// Assign the result of the finished delegate to the temporary |
|
// variable specified by delegate.resultName (see delegateYield). |
|
context[delegate.resultName] = info.value; |
|
|
|
// Resume execution at the desired location (see delegateYield). |
|
context.next = delegate.nextLoc; |
|
|
|
// If context.method was "throw" but the delegate handled the |
|
// exception, let the outer generator proceed normally. If |
|
// context.method was "next", forget context.arg since it has been |
|
// "consumed" by the delegate iterator. If context.method was |
|
// "return", allow the original .return call to continue in the |
|
// outer generator. |
|
if (context.method !== "return") { |
|
context.method = "next"; |
|
context.arg = undefined; |
|
} |
|
|
|
} else { |
|
// Re-yield the result returned by the delegate method. |
|
return info; |
|
} |
|
|
|
// The delegate iterator is finished, so forget it and continue with |
|
// the outer generator. |
|
context.delegate = null; |
|
return ContinueSentinel; |
|
} |
|
|
|
// Define Generator.prototype.{next,throw,return} in terms of the |
|
// unified ._invoke helper method. |
|
defineIteratorMethods(Gp); |
|
|
|
Gp[toStringTagSymbol] = "Generator"; |
|
|
|
// A Generator should always return itself as the iterator object when the |
|
// @@iterator function is called on it. Some browsers' implementations of the |
|
// iterator prototype chain incorrectly implement this, causing the Generator |
|
// object to not be returned from this call. This ensures that doesn't happen. |
|
// See https://github.com/facebook/regenerator/issues/274 for more details. |
|
Gp[iteratorSymbol] = function() { |
|
return this; |
|
}; |
|
|
|
Gp.toString = function() { |
|
return "[object Generator]"; |
|
}; |
|
|
|
function pushTryEntry(locs) { |
|
var entry = { tryLoc: locs[0] }; |
|
|
|
if (1 in locs) { |
|
entry.catchLoc = locs[1]; |
|
} |
|
|
|
if (2 in locs) { |
|
entry.finallyLoc = locs[2]; |
|
entry.afterLoc = locs[3]; |
|
} |
|
|
|
this.tryEntries.push(entry); |
|
} |
|
|
|
function resetTryEntry(entry) { |
|
var record = entry.completion || {}; |
|
record.type = "normal"; |
|
delete record.arg; |
|
entry.completion = record; |
|
} |
|
|
|
function Context(tryLocsList) { |
|
// The root entry object (effectively a try statement without a catch |
|
// or a finally block) gives us a place to store values thrown from |
|
// locations where there is no enclosing try statement. |
|
this.tryEntries = [{ tryLoc: "root" }]; |
|
tryLocsList.forEach(pushTryEntry, this); |
|
this.reset(true); |
|
} |
|
|
|
exports.keys = function(object) { |
|
var keys = []; |
|
for (var key in object) { |
|
keys.push(key); |
|
} |
|
keys.reverse(); |
|
|
|
// Rather than returning an object with a next method, we keep |
|
// things simple and return the next function itself. |
|
return function next() { |
|
while (keys.length) { |
|
var key = keys.pop(); |
|
if (key in object) { |
|
next.value = key; |
|
next.done = false; |
|
return next; |
|
} |
|
} |
|
|
|
// To avoid creating an additional object, we just hang the .value |
|
// and .done properties off the next function object itself. This |
|
// also ensures that the minifier will not anonymize the function. |
|
next.done = true; |
|
return next; |
|
}; |
|
}; |
|
|
|
function values(iterable) { |
|
if (iterable) { |
|
var iteratorMethod = iterable[iteratorSymbol]; |
|
if (iteratorMethod) { |
|
return iteratorMethod.call(iterable); |
|
} |
|
|
|
if (typeof iterable.next === "function") { |
|
return iterable; |
|
} |
|
|
|
if (!isNaN(iterable.length)) { |
|
var i = -1, next = function next() { |
|
while (++i < iterable.length) { |
|
if (hasOwn.call(iterable, i)) { |
|
next.value = iterable[i]; |
|
next.done = false; |
|
return next; |
|
} |
|
} |
|
|
|
next.value = undefined; |
|
next.done = true; |
|
|
|
return next; |
|
}; |
|
|
|
return next.next = next; |
|
} |
|
} |
|
|
|
// Return an iterator with no values. |
|
return { next: doneResult }; |
|
} |
|
exports.values = values; |
|
|
|
function doneResult() { |
|
return { value: undefined, done: true }; |
|
} |
|
|
|
Context.prototype = { |
|
constructor: Context, |
|
|
|
reset: function(skipTempReset) { |
|
this.prev = 0; |
|
this.next = 0; |
|
// Resetting context._sent for legacy support of Babel's |
|
// function.sent implementation. |
|
this.sent = this._sent = undefined; |
|
this.done = false; |
|
this.delegate = null; |
|
|
|
this.method = "next"; |
|
this.arg = undefined; |
|
|
|
this.tryEntries.forEach(resetTryEntry); |
|
|
|
if (!skipTempReset) { |
|
for (var name in this) { |
|
// Not sure about the optimal order of these conditions: |
|
if (name.charAt(0) === "t" && |
|
hasOwn.call(this, name) && |
|
!isNaN(+name.slice(1))) { |
|
this[name] = undefined; |
|
} |
|
} |
|
} |
|
}, |
|
|
|
stop: function() { |
|
this.done = true; |
|
|
|
var rootEntry = this.tryEntries[0]; |
|
var rootRecord = rootEntry.completion; |
|
if (rootRecord.type === "throw") { |
|
throw rootRecord.arg; |
|
} |
|
|
|
return this.rval; |
|
}, |
|
|
|
dispatchException: function(exception) { |
|
if (this.done) { |
|
throw exception; |
|
} |
|
|
|
var context = this; |
|
function handle(loc, caught) { |
|
record.type = "throw"; |
|
record.arg = exception; |
|
context.next = loc; |
|
|
|
if (caught) { |
|
// If the dispatched exception was caught by a catch block, |
|
// then let that catch block handle the exception normally. |
|
context.method = "next"; |
|
context.arg = undefined; |
|
} |
|
|
|
return !! caught; |
|
} |
|
|
|
for (var i = this.tryEntries.length - 1; i >= 0; --i) { |
|
var entry = this.tryEntries[i]; |
|
var record = entry.completion; |
|
|
|
if (entry.tryLoc === "root") { |
|
// Exception thrown outside of any try block that could handle |
|
// it, so set the completion value of the entire function to |
|
// throw the exception. |
|
return handle("end"); |
|
} |
|
|
|
if (entry.tryLoc <= this.prev) { |
|
var hasCatch = hasOwn.call(entry, "catchLoc"); |
|
var hasFinally = hasOwn.call(entry, "finallyLoc"); |
|
|
|
if (hasCatch && hasFinally) { |
|
if (this.prev < entry.catchLoc) { |
|
return handle(entry.catchLoc, true); |
|
} else if (this.prev < entry.finallyLoc) { |
|
return handle(entry.finallyLoc); |
|
} |
|
|
|
} else if (hasCatch) { |
|
if (this.prev < entry.catchLoc) { |
|
return handle(entry.catchLoc, true); |
|
} |
|
|
|
} else if (hasFinally) { |
|
if (this.prev < entry.finallyLoc) { |
|
return handle(entry.finallyLoc); |
|
} |
|
|
|
} else { |
|
throw new Error("try statement without catch or finally"); |
|
} |
|
} |
|
} |
|
}, |
|
|
|
abrupt: function(type, arg) { |
|
for (var i = this.tryEntries.length - 1; i >= 0; --i) { |
|
var entry = this.tryEntries[i]; |
|
if (entry.tryLoc <= this.prev && |
|
hasOwn.call(entry, "finallyLoc") && |
|
this.prev < entry.finallyLoc) { |
|
var finallyEntry = entry; |
|
break; |
|
} |
|
} |
|
|
|
if (finallyEntry && |
|
(type === "break" || |
|
type === "continue") && |
|
finallyEntry.tryLoc <= arg && |
|
arg <= finallyEntry.finallyLoc) { |
|
// Ignore the finally entry if control is not jumping to a |
|
// location outside the try/catch block. |
|
finallyEntry = null; |
|
} |
|
|
|
var record = finallyEntry ? finallyEntry.completion : {}; |
|
record.type = type; |
|
record.arg = arg; |
|
|
|
if (finallyEntry) { |
|
this.method = "next"; |
|
this.next = finallyEntry.finallyLoc; |
|
return ContinueSentinel; |
|
} |
|
|
|
return this.complete(record); |
|
}, |
|
|
|
complete: function(record, afterLoc) { |
|
if (record.type === "throw") { |
|
throw record.arg; |
|
} |
|
|
|
if (record.type === "break" || |
|
record.type === "continue") { |
|
this.next = record.arg; |
|
} else if (record.type === "return") { |
|
this.rval = this.arg = record.arg; |
|
this.method = "return"; |
|
this.next = "end"; |
|
} else if (record.type === "normal" && afterLoc) { |
|
this.next = afterLoc; |
|
} |
|
|
|
return ContinueSentinel; |
|
}, |
|
|
|
finish: function(finallyLoc) { |
|
for (var i = this.tryEntries.length - 1; i >= 0; --i) { |
|
var entry = this.tryEntries[i]; |
|
if (entry.finallyLoc === finallyLoc) { |
|
this.complete(entry.completion, entry.afterLoc); |
|
resetTryEntry(entry); |
|
return ContinueSentinel; |
|
} |
|
} |
|
}, |
|
|
|
"catch": function(tryLoc) { |
|
for (var i = this.tryEntries.length - 1; i >= 0; --i) { |
|
var entry = this.tryEntries[i]; |
|
if (entry.tryLoc === tryLoc) { |
|
var record = entry.completion; |
|
if (record.type === "throw") { |
|
var thrown = record.arg; |
|
resetTryEntry(entry); |
|
} |
|
return thrown; |
|
} |
|
} |
|
|
|
// The context.catch method must only be called with a location |
|
// argument that corresponds to a known catch block. |
|
throw new Error("illegal catch attempt"); |
|
}, |
|
|
|
delegateYield: function(iterable, resultName, nextLoc) { |
|
this.delegate = { |
|
iterator: values(iterable), |
|
resultName: resultName, |
|
nextLoc: nextLoc |
|
}; |
|
|
|
if (this.method === "next") { |
|
// Deliberately forget the last sent value so that we don't |
|
// accidentally pass it on to the delegate. |
|
this.arg = undefined; |
|
} |
|
|
|
return ContinueSentinel; |
|
} |
|
}; |
|
|
|
// Regardless of whether this script is executing as a CommonJS module |
|
// or not, return the runtime object so that we can declare the variable |
|
// regeneratorRuntime in the outer scope, which allows this module to be |
|
// injected easily by `bin/regenerator --include-runtime script.js`. |
|
return exports; |
|
|
|
}( |
|
// If this script is executing as a CommonJS module, use module.exports |
|
// as the regeneratorRuntime namespace. Otherwise create a new empty |
|
// object. Either way, the resulting object will be used to initialize |
|
// the regeneratorRuntime variable at the top of this file. |
|
true ? module.exports : undefined |
|
)); |
|
|
|
try { |
|
regeneratorRuntime = runtime; |
|
} catch (accidentalStrictMode) { |
|
// This module should not be running in strict mode, so the above |
|
// assignment should always work unless something is misconfigured. Just |
|
// in case runtime.js accidentally runs in strict mode, we can escape |
|
// strict mode using a global Function call. This could conceivably fail |
|
// if a Content Security Policy forbids using Function, but in that case |
|
// the proper solution is to fix the accidental strict mode problem. If |
|
// you've misconfigured your bundler to force strict mode and applied a |
|
// CSP to forbid Function, and you're not willing to fix either of those |
|
// problems, please detail your unique predicament in a GitHub issue. |
|
Function("r", "regeneratorRuntime = r")(runtime); |
|
} |
|
|
|
|
|
/***/ }), |
|
/* 48 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var __WEBPACK_AMD_DEFINE_RESULT__;// TinyColor v1.4.1 |
|
// https://github.com/bgrins/TinyColor |
|
// Brian Grinstead, MIT License |
|
|
|
(function(Math) { |
|
|
|
var trimLeft = /^\s+/, |
|
trimRight = /\s+$/, |
|
tinyCounter = 0, |
|
mathRound = Math.round, |
|
mathMin = Math.min, |
|
mathMax = Math.max, |
|
mathRandom = Math.random; |
|
|
|
function tinycolor (color, opts) { |
|
|
|
color = (color) ? color : ''; |
|
opts = opts || { }; |
|
|
|
// If input is already a tinycolor, return itself |
|
if (color instanceof tinycolor) { |
|
return color; |
|
} |
|
// If we are called as a function, call using new instead |
|
if (!(this instanceof tinycolor)) { |
|
return new tinycolor(color, opts); |
|
} |
|
|
|
var rgb = inputToRGB(color); |
|
this._originalInput = color, |
|
this._r = rgb.r, |
|
this._g = rgb.g, |
|
this._b = rgb.b, |
|
this._a = rgb.a, |
|
this._roundA = mathRound(100*this._a) / 100, |
|
this._format = opts.format || rgb.format; |
|
this._gradientType = opts.gradientType; |
|
|
|
// Don't let the range of [0,255] come back in [0,1]. |
|
// Potentially lose a little bit of precision here, but will fix issues where |
|
// .5 gets interpreted as half of the total, instead of half of 1 |
|
// If it was supposed to be 128, this was already taken care of by `inputToRgb` |
|
if (this._r < 1) { this._r = mathRound(this._r); } |
|
if (this._g < 1) { this._g = mathRound(this._g); } |
|
if (this._b < 1) { this._b = mathRound(this._b); } |
|
|
|
this._ok = rgb.ok; |
|
this._tc_id = tinyCounter++; |
|
} |
|
|
|
tinycolor.prototype = { |
|
isDark: function() { |
|
return this.getBrightness() < 128; |
|
}, |
|
isLight: function() { |
|
return !this.isDark(); |
|
}, |
|
isValid: function() { |
|
return this._ok; |
|
}, |
|
getOriginalInput: function() { |
|
return this._originalInput; |
|
}, |
|
getFormat: function() { |
|
return this._format; |
|
}, |
|
getAlpha: function() { |
|
return this._a; |
|
}, |
|
getBrightness: function() { |
|
//http://www.w3.org/TR/AERT#color-contrast |
|
var rgb = this.toRgb(); |
|
return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000; |
|
}, |
|
getLuminance: function() { |
|
//http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef |
|
var rgb = this.toRgb(); |
|
var RsRGB, GsRGB, BsRGB, R, G, B; |
|
RsRGB = rgb.r/255; |
|
GsRGB = rgb.g/255; |
|
BsRGB = rgb.b/255; |
|
|
|
if (RsRGB <= 0.03928) {R = RsRGB / 12.92;} else {R = Math.pow(((RsRGB + 0.055) / 1.055), 2.4);} |
|
if (GsRGB <= 0.03928) {G = GsRGB / 12.92;} else {G = Math.pow(((GsRGB + 0.055) / 1.055), 2.4);} |
|
if (BsRGB <= 0.03928) {B = BsRGB / 12.92;} else {B = Math.pow(((BsRGB + 0.055) / 1.055), 2.4);} |
|
return (0.2126 * R) + (0.7152 * G) + (0.0722 * B); |
|
}, |
|
setAlpha: function(value) { |
|
this._a = boundAlpha(value); |
|
this._roundA = mathRound(100*this._a) / 100; |
|
return this; |
|
}, |
|
toHsv: function() { |
|
var hsv = rgbToHsv(this._r, this._g, this._b); |
|
return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a }; |
|
}, |
|
toHsvString: function() { |
|
var hsv = rgbToHsv(this._r, this._g, this._b); |
|
var h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100); |
|
return (this._a == 1) ? |
|
"hsv(" + h + ", " + s + "%, " + v + "%)" : |
|
"hsva(" + h + ", " + s + "%, " + v + "%, "+ this._roundA + ")"; |
|
}, |
|
toHsl: function() { |
|
var hsl = rgbToHsl(this._r, this._g, this._b); |
|
return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a }; |
|
}, |
|
toHslString: function() { |
|
var hsl = rgbToHsl(this._r, this._g, this._b); |
|
var h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100); |
|
return (this._a == 1) ? |
|
"hsl(" + h + ", " + s + "%, " + l + "%)" : |
|
"hsla(" + h + ", " + s + "%, " + l + "%, "+ this._roundA + ")"; |
|
}, |
|
toHex: function(allow3Char) { |
|
return rgbToHex(this._r, this._g, this._b, allow3Char); |
|
}, |
|
toHexString: function(allow3Char) { |
|
return '#' + this.toHex(allow3Char); |
|
}, |
|
toHex8: function(allow4Char) { |
|
return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char); |
|
}, |
|
toHex8String: function(allow4Char) { |
|
return '#' + this.toHex8(allow4Char); |
|
}, |
|
toRgb: function() { |
|
return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a }; |
|
}, |
|
toRgbString: function() { |
|
return (this._a == 1) ? |
|
"rgb(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ")" : |
|
"rgba(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ", " + this._roundA + ")"; |
|
}, |
|
toPercentageRgb: function() { |
|
return { r: mathRound(bound01(this._r, 255) * 100) + "%", g: mathRound(bound01(this._g, 255) * 100) + "%", b: mathRound(bound01(this._b, 255) * 100) + "%", a: this._a }; |
|
}, |
|
toPercentageRgbString: function() { |
|
return (this._a == 1) ? |
|
"rgb(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%)" : |
|
"rgba(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%, " + this._roundA + ")"; |
|
}, |
|
toName: function() { |
|
if (this._a === 0) { |
|
return "transparent"; |
|
} |
|
|
|
if (this._a < 1) { |
|
return false; |
|
} |
|
|
|
return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false; |
|
}, |
|
toFilter: function(secondColor) { |
|
var hex8String = '#' + rgbaToArgbHex(this._r, this._g, this._b, this._a); |
|
var secondHex8String = hex8String; |
|
var gradientType = this._gradientType ? "GradientType = 1, " : ""; |
|
|
|
if (secondColor) { |
|
var s = tinycolor(secondColor); |
|
secondHex8String = '#' + rgbaToArgbHex(s._r, s._g, s._b, s._a); |
|
} |
|
|
|
return "progid:DXImageTransform.Microsoft.gradient("+gradientType+"startColorstr="+hex8String+",endColorstr="+secondHex8String+")"; |
|
}, |
|
toString: function(format) { |
|
var formatSet = !!format; |
|
format = format || this._format; |
|
|
|
var formattedString = false; |
|
var hasAlpha = this._a < 1 && this._a >= 0; |
|
var needsAlphaFormat = !formatSet && hasAlpha && (format === "hex" || format === "hex6" || format === "hex3" || format === "hex4" || format === "hex8" || format === "name"); |
|
|
|
if (needsAlphaFormat) { |
|
// Special case for "transparent", all other non-alpha formats |
|
// will return rgba when there is transparency. |
|
if (format === "name" && this._a === 0) { |
|
return this.toName(); |
|
} |
|
return this.toRgbString(); |
|
} |
|
if (format === "rgb") { |
|
formattedString = this.toRgbString(); |
|
} |
|
if (format === "prgb") { |
|
formattedString = this.toPercentageRgbString(); |
|
} |
|
if (format === "hex" || format === "hex6") { |
|
formattedString = this.toHexString(); |
|
} |
|
if (format === "hex3") { |
|
formattedString = this.toHexString(true); |
|
} |
|
if (format === "hex4") { |
|
formattedString = this.toHex8String(true); |
|
} |
|
if (format === "hex8") { |
|
formattedString = this.toHex8String(); |
|
} |
|
if (format === "name") { |
|
formattedString = this.toName(); |
|
} |
|
if (format === "hsl") { |
|
formattedString = this.toHslString(); |
|
} |
|
if (format === "hsv") { |
|
formattedString = this.toHsvString(); |
|
} |
|
|
|
return formattedString || this.toHexString(); |
|
}, |
|
clone: function() { |
|
return tinycolor(this.toString()); |
|
}, |
|
|
|
_applyModification: function(fn, args) { |
|
var color = fn.apply(null, [this].concat([].slice.call(args))); |
|
this._r = color._r; |
|
this._g = color._g; |
|
this._b = color._b; |
|
this.setAlpha(color._a); |
|
return this; |
|
}, |
|
lighten: function() { |
|
return this._applyModification(lighten, arguments); |
|
}, |
|
brighten: function() { |
|
return this._applyModification(brighten, arguments); |
|
}, |
|
darken: function() { |
|
return this._applyModification(darken, arguments); |
|
}, |
|
desaturate: function() { |
|
return this._applyModification(desaturate, arguments); |
|
}, |
|
saturate: function() { |
|
return this._applyModification(saturate, arguments); |
|
}, |
|
greyscale: function() { |
|
return this._applyModification(greyscale, arguments); |
|
}, |
|
spin: function() { |
|
return this._applyModification(spin, arguments); |
|
}, |
|
|
|
_applyCombination: function(fn, args) { |
|
return fn.apply(null, [this].concat([].slice.call(args))); |
|
}, |
|
analogous: function() { |
|
return this._applyCombination(analogous, arguments); |
|
}, |
|
complement: function() { |
|
return this._applyCombination(complement, arguments); |
|
}, |
|
monochromatic: function() { |
|
return this._applyCombination(monochromatic, arguments); |
|
}, |
|
splitcomplement: function() { |
|
return this._applyCombination(splitcomplement, arguments); |
|
}, |
|
triad: function() { |
|
return this._applyCombination(triad, arguments); |
|
}, |
|
tetrad: function() { |
|
return this._applyCombination(tetrad, arguments); |
|
} |
|
}; |
|
|
|
// If input is an object, force 1 into "1.0" to handle ratios properly |
|
// String input requires "1.0" as input, so 1 will be treated as 1 |
|
tinycolor.fromRatio = function(color, opts) { |
|
if (typeof color == "object") { |
|
var newColor = {}; |
|
for (var i in color) { |
|
if (color.hasOwnProperty(i)) { |
|
if (i === "a") { |
|
newColor[i] = color[i]; |
|
} |
|
else { |
|
newColor[i] = convertToPercentage(color[i]); |
|
} |
|
} |
|
} |
|
color = newColor; |
|
} |
|
|
|
return tinycolor(color, opts); |
|
}; |
|
|
|
// Given a string or object, convert that input to RGB |
|
// Possible string inputs: |
|
// |
|
// "red" |
|
// "#f00" or "f00" |
|
// "#ff0000" or "ff0000" |
|
// "#ff000000" or "ff000000" |
|
// "rgb 255 0 0" or "rgb (255, 0, 0)" |
|
// "rgb 1.0 0 0" or "rgb (1, 0, 0)" |
|
// "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1" |
|
// "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1" |
|
// "hsl(0, 100%, 50%)" or "hsl 0 100% 50%" |
|
// "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1" |
|
// "hsv(0, 100%, 100%)" or "hsv 0 100% 100%" |
|
// |
|
function inputToRGB(color) { |
|
|
|
var rgb = { r: 0, g: 0, b: 0 }; |
|
var a = 1; |
|
var s = null; |
|
var v = null; |
|
var l = null; |
|
var ok = false; |
|
var format = false; |
|
|
|
if (typeof color == "string") { |
|
color = stringInputToObject(color); |
|
} |
|
|
|
if (typeof color == "object") { |
|
if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) { |
|
rgb = rgbToRgb(color.r, color.g, color.b); |
|
ok = true; |
|
format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb"; |
|
} |
|
else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) { |
|
s = convertToPercentage(color.s); |
|
v = convertToPercentage(color.v); |
|
rgb = hsvToRgb(color.h, s, v); |
|
ok = true; |
|
format = "hsv"; |
|
} |
|
else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) { |
|
s = convertToPercentage(color.s); |
|
l = convertToPercentage(color.l); |
|
rgb = hslToRgb(color.h, s, l); |
|
ok = true; |
|
format = "hsl"; |
|
} |
|
|
|
if (color.hasOwnProperty("a")) { |
|
a = color.a; |
|
} |
|
} |
|
|
|
a = boundAlpha(a); |
|
|
|
return { |
|
ok: ok, |
|
format: color.format || format, |
|
r: mathMin(255, mathMax(rgb.r, 0)), |
|
g: mathMin(255, mathMax(rgb.g, 0)), |
|
b: mathMin(255, mathMax(rgb.b, 0)), |
|
a: a |
|
}; |
|
} |
|
|
|
|
|
// Conversion Functions |
|
// -------------------- |
|
|
|
// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from: |
|
// <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript> |
|
|
|
// `rgbToRgb` |
|
// Handle bounds / percentage checking to conform to CSS color spec |
|
// <http://www.w3.org/TR/css3-color/> |
|
// *Assumes:* r, g, b in [0, 255] or [0, 1] |
|
// *Returns:* { r, g, b } in [0, 255] |
|
function rgbToRgb(r, g, b){ |
|
return { |
|
r: bound01(r, 255) * 255, |
|
g: bound01(g, 255) * 255, |
|
b: bound01(b, 255) * 255 |
|
}; |
|
} |
|
|
|
// `rgbToHsl` |
|
// Converts an RGB color value to HSL. |
|
// *Assumes:* r, g, and b are contained in [0, 255] or [0, 1] |
|
// *Returns:* { h, s, l } in [0,1] |
|
function rgbToHsl(r, g, b) { |
|
|
|
r = bound01(r, 255); |
|
g = bound01(g, 255); |
|
b = bound01(b, 255); |
|
|
|
var max = mathMax(r, g, b), min = mathMin(r, g, b); |
|
var h, s, l = (max + min) / 2; |
|
|
|
if(max == min) { |
|
h = s = 0; // achromatic |
|
} |
|
else { |
|
var d = max - min; |
|
s = l > 0.5 ? d / (2 - max - min) : d / (max + min); |
|
switch(max) { |
|
case r: h = (g - b) / d + (g < b ? 6 : 0); break; |
|
case g: h = (b - r) / d + 2; break; |
|
case b: h = (r - g) / d + 4; break; |
|
} |
|
|
|
h /= 6; |
|
} |
|
|
|
return { h: h, s: s, l: l }; |
|
} |
|
|
|
// `hslToRgb` |
|
// Converts an HSL color value to RGB. |
|
// *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100] |
|
// *Returns:* { r, g, b } in the set [0, 255] |
|
function hslToRgb(h, s, l) { |
|
var r, g, b; |
|
|
|
h = bound01(h, 360); |
|
s = bound01(s, 100); |
|
l = bound01(l, 100); |
|
|
|
function hue2rgb(p, q, t) { |
|
if(t < 0) t += 1; |
|
if(t > 1) t -= 1; |
|
if(t < 1/6) return p + (q - p) * 6 * t; |
|
if(t < 1/2) return q; |
|
if(t < 2/3) return p + (q - p) * (2/3 - t) * 6; |
|
return p; |
|
} |
|
|
|
if(s === 0) { |
|
r = g = b = l; // achromatic |
|
} |
|
else { |
|
var q = l < 0.5 ? l * (1 + s) : l + s - l * s; |
|
var p = 2 * l - q; |
|
r = hue2rgb(p, q, h + 1/3); |
|
g = hue2rgb(p, q, h); |
|
b = hue2rgb(p, q, h - 1/3); |
|
} |
|
|
|
return { r: r * 255, g: g * 255, b: b * 255 }; |
|
} |
|
|
|
// `rgbToHsv` |
|
// Converts an RGB color value to HSV |
|
// *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1] |
|
// *Returns:* { h, s, v } in [0,1] |
|
function rgbToHsv(r, g, b) { |
|
|
|
r = bound01(r, 255); |
|
g = bound01(g, 255); |
|
b = bound01(b, 255); |
|
|
|
var max = mathMax(r, g, b), min = mathMin(r, g, b); |
|
var h, s, v = max; |
|
|
|
var d = max - min; |
|
s = max === 0 ? 0 : d / max; |
|
|
|
if(max == min) { |
|
h = 0; // achromatic |
|
} |
|
else { |
|
switch(max) { |
|
case r: h = (g - b) / d + (g < b ? 6 : 0); break; |
|
case g: h = (b - r) / d + 2; break; |
|
case b: h = (r - g) / d + 4; break; |
|
} |
|
h /= 6; |
|
} |
|
return { h: h, s: s, v: v }; |
|
} |
|
|
|
// `hsvToRgb` |
|
// Converts an HSV color value to RGB. |
|
// *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100] |
|
// *Returns:* { r, g, b } in the set [0, 255] |
|
function hsvToRgb(h, s, v) { |
|
|
|
h = bound01(h, 360) * 6; |
|
s = bound01(s, 100); |
|
v = bound01(v, 100); |
|
|
|
var i = Math.floor(h), |
|
f = h - i, |
|
p = v * (1 - s), |
|
q = v * (1 - f * s), |
|
t = v * (1 - (1 - f) * s), |
|
mod = i % 6, |
|
r = [v, q, p, p, t, v][mod], |
|
g = [t, v, v, q, p, p][mod], |
|
b = [p, p, t, v, v, q][mod]; |
|
|
|
return { r: r * 255, g: g * 255, b: b * 255 }; |
|
} |
|
|
|
// `rgbToHex` |
|
// Converts an RGB color to hex |
|
// Assumes r, g, and b are contained in the set [0, 255] |
|
// Returns a 3 or 6 character hex |
|
function rgbToHex(r, g, b, allow3Char) { |
|
|
|
var hex = [ |
|
pad2(mathRound(r).toString(16)), |
|
pad2(mathRound(g).toString(16)), |
|
pad2(mathRound(b).toString(16)) |
|
]; |
|
|
|
// Return a 3 character hex if possible |
|
if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) { |
|
return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0); |
|
} |
|
|
|
return hex.join(""); |
|
} |
|
|
|
// `rgbaToHex` |
|
// Converts an RGBA color plus alpha transparency to hex |
|
// Assumes r, g, b are contained in the set [0, 255] and |
|
// a in [0, 1]. Returns a 4 or 8 character rgba hex |
|
function rgbaToHex(r, g, b, a, allow4Char) { |
|
|
|
var hex = [ |
|
pad2(mathRound(r).toString(16)), |
|
pad2(mathRound(g).toString(16)), |
|
pad2(mathRound(b).toString(16)), |
|
pad2(convertDecimalToHex(a)) |
|
]; |
|
|
|
// Return a 4 character hex if possible |
|
if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) { |
|
return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0); |
|
} |
|
|
|
return hex.join(""); |
|
} |
|
|
|
// `rgbaToArgbHex` |
|
// Converts an RGBA color to an ARGB Hex8 string |
|
// Rarely used, but required for "toFilter()" |
|
function rgbaToArgbHex(r, g, b, a) { |
|
|
|
var hex = [ |
|
pad2(convertDecimalToHex(a)), |
|
pad2(mathRound(r).toString(16)), |
|
pad2(mathRound(g).toString(16)), |
|
pad2(mathRound(b).toString(16)) |
|
]; |
|
|
|
return hex.join(""); |
|
} |
|
|
|
// `equals` |
|
// Can be called with any tinycolor input |
|
tinycolor.equals = function (color1, color2) { |
|
if (!color1 || !color2) { return false; } |
|
return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString(); |
|
}; |
|
|
|
tinycolor.random = function() { |
|
return tinycolor.fromRatio({ |
|
r: mathRandom(), |
|
g: mathRandom(), |
|
b: mathRandom() |
|
}); |
|
}; |
|
|
|
|
|
// Modification Functions |
|
// ---------------------- |
|
// Thanks to less.js for some of the basics here |
|
// <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js> |
|
|
|
function desaturate(color, amount) { |
|
amount = (amount === 0) ? 0 : (amount || 10); |
|
var hsl = tinycolor(color).toHsl(); |
|
hsl.s -= amount / 100; |
|
hsl.s = clamp01(hsl.s); |
|
return tinycolor(hsl); |
|
} |
|
|
|
function saturate(color, amount) { |
|
amount = (amount === 0) ? 0 : (amount || 10); |
|
var hsl = tinycolor(color).toHsl(); |
|
hsl.s += amount / 100; |
|
hsl.s = clamp01(hsl.s); |
|
return tinycolor(hsl); |
|
} |
|
|
|
function greyscale(color) { |
|
return tinycolor(color).desaturate(100); |
|
} |
|
|
|
function lighten (color, amount) { |
|
amount = (amount === 0) ? 0 : (amount || 10); |
|
var hsl = tinycolor(color).toHsl(); |
|
hsl.l += amount / 100; |
|
hsl.l = clamp01(hsl.l); |
|
return tinycolor(hsl); |
|
} |
|
|
|
function brighten(color, amount) { |
|
amount = (amount === 0) ? 0 : (amount || 10); |
|
var rgb = tinycolor(color).toRgb(); |
|
rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * - (amount / 100)))); |
|
rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * - (amount / 100)))); |
|
rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * - (amount / 100)))); |
|
return tinycolor(rgb); |
|
} |
|
|
|
function darken (color, amount) { |
|
amount = (amount === 0) ? 0 : (amount || 10); |
|
var hsl = tinycolor(color).toHsl(); |
|
hsl.l -= amount / 100; |
|
hsl.l = clamp01(hsl.l); |
|
return tinycolor(hsl); |
|
} |
|
|
|
// Spin takes a positive or negative amount within [-360, 360] indicating the change of hue. |
|
// Values outside of this range will be wrapped into this range. |
|
function spin(color, amount) { |
|
var hsl = tinycolor(color).toHsl(); |
|
var hue = (hsl.h + amount) % 360; |
|
hsl.h = hue < 0 ? 360 + hue : hue; |
|
return tinycolor(hsl); |
|
} |
|
|
|
// Combination Functions |
|
// --------------------- |
|
// Thanks to jQuery xColor for some of the ideas behind these |
|
// <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js> |
|
|
|
function complement(color) { |
|
var hsl = tinycolor(color).toHsl(); |
|
hsl.h = (hsl.h + 180) % 360; |
|
return tinycolor(hsl); |
|
} |
|
|
|
function triad(color) { |
|
var hsl = tinycolor(color).toHsl(); |
|
var h = hsl.h; |
|
return [ |
|
tinycolor(color), |
|
tinycolor({ h: (h + 120) % 360, s: hsl.s, l: hsl.l }), |
|
tinycolor({ h: (h + 240) % 360, s: hsl.s, l: hsl.l }) |
|
]; |
|
} |
|
|
|
function tetrad(color) { |
|
var hsl = tinycolor(color).toHsl(); |
|
var h = hsl.h; |
|
return [ |
|
tinycolor(color), |
|
tinycolor({ h: (h + 90) % 360, s: hsl.s, l: hsl.l }), |
|
tinycolor({ h: (h + 180) % 360, s: hsl.s, l: hsl.l }), |
|
tinycolor({ h: (h + 270) % 360, s: hsl.s, l: hsl.l }) |
|
]; |
|
} |
|
|
|
function splitcomplement(color) { |
|
var hsl = tinycolor(color).toHsl(); |
|
var h = hsl.h; |
|
return [ |
|
tinycolor(color), |
|
tinycolor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l}), |
|
tinycolor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l}) |
|
]; |
|
} |
|
|
|
function analogous(color, results, slices) { |
|
results = results || 6; |
|
slices = slices || 30; |
|
|
|
var hsl = tinycolor(color).toHsl(); |
|
var part = 360 / slices; |
|
var ret = [tinycolor(color)]; |
|
|
|
for (hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360; --results; ) { |
|
hsl.h = (hsl.h + part) % 360; |
|
ret.push(tinycolor(hsl)); |
|
} |
|
return ret; |
|
} |
|
|
|
function monochromatic(color, results) { |
|
results = results || 6; |
|
var hsv = tinycolor(color).toHsv(); |
|
var h = hsv.h, s = hsv.s, v = hsv.v; |
|
var ret = []; |
|
var modification = 1 / results; |
|
|
|
while (results--) { |
|
ret.push(tinycolor({ h: h, s: s, v: v})); |
|
v = (v + modification) % 1; |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
// Utility Functions |
|
// --------------------- |
|
|
|
tinycolor.mix = function(color1, color2, amount) { |
|
amount = (amount === 0) ? 0 : (amount || 50); |
|
|
|
var rgb1 = tinycolor(color1).toRgb(); |
|
var rgb2 = tinycolor(color2).toRgb(); |
|
|
|
var p = amount / 100; |
|
|
|
var rgba = { |
|
r: ((rgb2.r - rgb1.r) * p) + rgb1.r, |
|
g: ((rgb2.g - rgb1.g) * p) + rgb1.g, |
|
b: ((rgb2.b - rgb1.b) * p) + rgb1.b, |
|
a: ((rgb2.a - rgb1.a) * p) + rgb1.a |
|
}; |
|
|
|
return tinycolor(rgba); |
|
}; |
|
|
|
|
|
// Readability Functions |
|
// --------------------- |
|
// <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2) |
|
|
|
// `contrast` |
|
// Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2) |
|
tinycolor.readability = function(color1, color2) { |
|
var c1 = tinycolor(color1); |
|
var c2 = tinycolor(color2); |
|
return (Math.max(c1.getLuminance(),c2.getLuminance())+0.05) / (Math.min(c1.getLuminance(),c2.getLuminance())+0.05); |
|
}; |
|
|
|
// `isReadable` |
|
// Ensure that foreground and background color combinations meet WCAG2 guidelines. |
|
// The third argument is an optional Object. |
|
// the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA'; |
|
// the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'. |
|
// If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}. |
|
|
|
// *Example* |
|
// tinycolor.isReadable("#000", "#111") => false |
|
// tinycolor.isReadable("#000", "#111",{level:"AA",size:"large"}) => false |
|
tinycolor.isReadable = function(color1, color2, wcag2) { |
|
var readability = tinycolor.readability(color1, color2); |
|
var wcag2Parms, out; |
|
|
|
out = false; |
|
|
|
wcag2Parms = validateWCAG2Parms(wcag2); |
|
switch (wcag2Parms.level + wcag2Parms.size) { |
|
case "AAsmall": |
|
case "AAAlarge": |
|
out = readability >= 4.5; |
|
break; |
|
case "AAlarge": |
|
out = readability >= 3; |
|
break; |
|
case "AAAsmall": |
|
out = readability >= 7; |
|
break; |
|
} |
|
return out; |
|
|
|
}; |
|
|
|
// `mostReadable` |
|
// Given a base color and a list of possible foreground or background |
|
// colors for that base, returns the most readable color. |
|
// Optionally returns Black or White if the most readable color is unreadable. |
|
// *Example* |
|
// tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:false}).toHexString(); // "#112255" |
|
// tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:true}).toHexString(); // "#ffffff" |
|
// tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"large"}).toHexString(); // "#faf3f3" |
|
// tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"small"}).toHexString(); // "#ffffff" |
|
tinycolor.mostReadable = function(baseColor, colorList, args) { |
|
var bestColor = null; |
|
var bestScore = 0; |
|
var readability; |
|
var includeFallbackColors, level, size ; |
|
args = args || {}; |
|
includeFallbackColors = args.includeFallbackColors ; |
|
level = args.level; |
|
size = args.size; |
|
|
|
for (var i= 0; i < colorList.length ; i++) { |
|
readability = tinycolor.readability(baseColor, colorList[i]); |
|
if (readability > bestScore) { |
|
bestScore = readability; |
|
bestColor = tinycolor(colorList[i]); |
|
} |
|
} |
|
|
|
if (tinycolor.isReadable(baseColor, bestColor, {"level":level,"size":size}) || !includeFallbackColors) { |
|
return bestColor; |
|
} |
|
else { |
|
args.includeFallbackColors=false; |
|
return tinycolor.mostReadable(baseColor,["#fff", "#000"],args); |
|
} |
|
}; |
|
|
|
|
|
// Big List of Colors |
|
// ------------------ |
|
// <http://www.w3.org/TR/css3-color/#svg-color> |
|
var names = tinycolor.names = { |
|
aliceblue: "f0f8ff", |
|
antiquewhite: "faebd7", |
|
aqua: "0ff", |
|
aquamarine: "7fffd4", |
|
azure: "f0ffff", |
|
beige: "f5f5dc", |
|
bisque: "ffe4c4", |
|
black: "000", |
|
blanchedalmond: "ffebcd", |
|
blue: "00f", |
|
blueviolet: "8a2be2", |
|
brown: "a52a2a", |
|
burlywood: "deb887", |
|
burntsienna: "ea7e5d", |
|
cadetblue: "5f9ea0", |
|
chartreuse: "7fff00", |
|
chocolate: "d2691e", |
|
coral: "ff7f50", |
|
cornflowerblue: "6495ed", |
|
cornsilk: "fff8dc", |
|
crimson: "dc143c", |
|
cyan: "0ff", |
|
darkblue: "00008b", |
|
darkcyan: "008b8b", |
|
darkgoldenrod: "b8860b", |
|
darkgray: "a9a9a9", |
|
darkgreen: "006400", |
|
darkgrey: "a9a9a9", |
|
darkkhaki: "bdb76b", |
|
darkmagenta: "8b008b", |
|
darkolivegreen: "556b2f", |
|
darkorange: "ff8c00", |
|
darkorchid: "9932cc", |
|
darkred: "8b0000", |
|
darksalmon: "e9967a", |
|
darkseagreen: "8fbc8f", |
|
darkslateblue: "483d8b", |
|
darkslategray: "2f4f4f", |
|
darkslategrey: "2f4f4f", |
|
darkturquoise: "00ced1", |
|
darkviolet: "9400d3", |
|
deeppink: "ff1493", |
|
deepskyblue: "00bfff", |
|
dimgray: "696969", |
|
dimgrey: "696969", |
|
dodgerblue: "1e90ff", |
|
firebrick: "b22222", |
|
floralwhite: "fffaf0", |
|
forestgreen: "228b22", |
|
fuchsia: "f0f", |
|
gainsboro: "dcdcdc", |
|
ghostwhite: "f8f8ff", |
|
gold: "ffd700", |
|
goldenrod: "daa520", |
|
gray: "808080", |
|
green: "008000", |
|
greenyellow: "adff2f", |
|
grey: "808080", |
|
honeydew: "f0fff0", |
|
hotpink: "ff69b4", |
|
indianred: "cd5c5c", |
|
indigo: "4b0082", |
|
ivory: "fffff0", |
|
khaki: "f0e68c", |
|
lavender: "e6e6fa", |
|
lavenderblush: "fff0f5", |
|
lawngreen: "7cfc00", |
|
lemonchiffon: "fffacd", |
|
lightblue: "add8e6", |
|
lightcoral: "f08080", |
|
lightcyan: "e0ffff", |
|
lightgoldenrodyellow: "fafad2", |
|
lightgray: "d3d3d3", |
|
lightgreen: "90ee90", |
|
lightgrey: "d3d3d3", |
|
lightpink: "ffb6c1", |
|
lightsalmon: "ffa07a", |
|
lightseagreen: "20b2aa", |
|
lightskyblue: "87cefa", |
|
lightslategray: "789", |
|
lightslategrey: "789", |
|
lightsteelblue: "b0c4de", |
|
lightyellow: "ffffe0", |
|
lime: "0f0", |
|
limegreen: "32cd32", |
|
linen: "faf0e6", |
|
magenta: "f0f", |
|
maroon: "800000", |
|
mediumaquamarine: "66cdaa", |
|
mediumblue: "0000cd", |
|
mediumorchid: "ba55d3", |
|
mediumpurple: "9370db", |
|
mediumseagreen: "3cb371", |
|
mediumslateblue: "7b68ee", |
|
mediumspringgreen: "00fa9a", |
|
mediumturquoise: "48d1cc", |
|
mediumvioletred: "c71585", |
|
midnightblue: "191970", |
|
mintcream: "f5fffa", |
|
mistyrose: "ffe4e1", |
|
moccasin: "ffe4b5", |
|
navajowhite: "ffdead", |
|
navy: "000080", |
|
oldlace: "fdf5e6", |
|
olive: "808000", |
|
olivedrab: "6b8e23", |
|
orange: "ffa500", |
|
orangered: "ff4500", |
|
orchid: "da70d6", |
|
palegoldenrod: "eee8aa", |
|
palegreen: "98fb98", |
|
paleturquoise: "afeeee", |
|
palevioletred: "db7093", |
|
papayawhip: "ffefd5", |
|
peachpuff: "ffdab9", |
|
peru: "cd853f", |
|
pink: "ffc0cb", |
|
plum: "dda0dd", |
|
powderblue: "b0e0e6", |
|
purple: "800080", |
|
rebeccapurple: "663399", |
|
red: "f00", |
|
rosybrown: "bc8f8f", |
|
royalblue: "4169e1", |
|
saddlebrown: "8b4513", |
|
salmon: "fa8072", |
|
sandybrown: "f4a460", |
|
seagreen: "2e8b57", |
|
seashell: "fff5ee", |
|
sienna: "a0522d", |
|
silver: "c0c0c0", |
|
skyblue: "87ceeb", |
|
slateblue: "6a5acd", |
|
slategray: "708090", |
|
slategrey: "708090", |
|
snow: "fffafa", |
|
springgreen: "00ff7f", |
|
steelblue: "4682b4", |
|
tan: "d2b48c", |
|
teal: "008080", |
|
thistle: "d8bfd8", |
|
tomato: "ff6347", |
|
turquoise: "40e0d0", |
|
violet: "ee82ee", |
|
wheat: "f5deb3", |
|
white: "fff", |
|
whitesmoke: "f5f5f5", |
|
yellow: "ff0", |
|
yellowgreen: "9acd32" |
|
}; |
|
|
|
// Make it easy to access colors via `hexNames[hex]` |
|
var hexNames = tinycolor.hexNames = flip(names); |
|
|
|
|
|
// Utilities |
|
// --------- |
|
|
|
// `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }` |
|
function flip(o) { |
|
var flipped = { }; |
|
for (var i in o) { |
|
if (o.hasOwnProperty(i)) { |
|
flipped[o[i]] = i; |
|
} |
|
} |
|
return flipped; |
|
} |
|
|
|
// Return a valid alpha value [0,1] with all invalid values being set to 1 |
|
function boundAlpha(a) { |
|
a = parseFloat(a); |
|
|
|
if (isNaN(a) || a < 0 || a > 1) { |
|
a = 1; |
|
} |
|
|
|
return a; |
|
} |
|
|
|
// Take input from [0, n] and return it as [0, 1] |
|
function bound01(n, max) { |
|
if (isOnePointZero(n)) { n = "100%"; } |
|
|
|
var processPercent = isPercentage(n); |
|
n = mathMin(max, mathMax(0, parseFloat(n))); |
|
|
|
// Automatically convert percentage into number |
|
if (processPercent) { |
|
n = parseInt(n * max, 10) / 100; |
|
} |
|
|
|
// Handle floating point rounding errors |
|
if ((Math.abs(n - max) < 0.000001)) { |
|
return 1; |
|
} |
|
|
|
// Convert into [0, 1] range if it isn't already |
|
return (n % max) / parseFloat(max); |
|
} |
|
|
|
// Force a number between 0 and 1 |
|
function clamp01(val) { |
|
return mathMin(1, mathMax(0, val)); |
|
} |
|
|
|
// Parse a base-16 hex value into a base-10 integer |
|
function parseIntFromHex(val) { |
|
return parseInt(val, 16); |
|
} |
|
|
|
// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1 |
|
// <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0> |
|
function isOnePointZero(n) { |
|
return typeof n == "string" && n.indexOf('.') != -1 && parseFloat(n) === 1; |
|
} |
|
|
|
// Check to see if string passed in is a percentage |
|
function isPercentage(n) { |
|
return typeof n === "string" && n.indexOf('%') != -1; |
|
} |
|
|
|
// Force a hex value to have 2 characters |
|
function pad2(c) { |
|
return c.length == 1 ? '0' + c : '' + c; |
|
} |
|
|
|
// Replace a decimal with it's percentage value |
|
function convertToPercentage(n) { |
|
if (n <= 1) { |
|
n = (n * 100) + "%"; |
|
} |
|
|
|
return n; |
|
} |
|
|
|
// Converts a decimal to a hex value |
|
function convertDecimalToHex(d) { |
|
return Math.round(parseFloat(d) * 255).toString(16); |
|
} |
|
// Converts a hex value to a decimal |
|
function convertHexToDecimal(h) { |
|
return (parseIntFromHex(h) / 255); |
|
} |
|
|
|
var matchers = (function() { |
|
|
|
// <http://www.w3.org/TR/css3-values/#integers> |
|
var CSS_INTEGER = "[-\\+]?\\d+%?"; |
|
|
|
// <http://www.w3.org/TR/css3-values/#number-value> |
|
var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?"; |
|
|
|
// Allow positive/negative integer/number. Don't capture the either/or, just the entire outcome. |
|
var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")"; |
|
|
|
// Actual matching. |
|
// Parentheses and commas are optional, but not required. |
|
// Whitespace can take the place of commas or opening paren |
|
var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?"; |
|
var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?"; |
|
|
|
return { |
|
CSS_UNIT: new RegExp(CSS_UNIT), |
|
rgb: new RegExp("rgb" + PERMISSIVE_MATCH3), |
|
rgba: new RegExp("rgba" + PERMISSIVE_MATCH4), |
|
hsl: new RegExp("hsl" + PERMISSIVE_MATCH3), |
|
hsla: new RegExp("hsla" + PERMISSIVE_MATCH4), |
|
hsv: new RegExp("hsv" + PERMISSIVE_MATCH3), |
|
hsva: new RegExp("hsva" + PERMISSIVE_MATCH4), |
|
hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, |
|
hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/, |
|
hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, |
|
hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/ |
|
}; |
|
})(); |
|
|
|
// `isValidCSSUnit` |
|
// Take in a single string / number and check to see if it looks like a CSS unit |
|
// (see `matchers` above for definition). |
|
function isValidCSSUnit(color) { |
|
return !!matchers.CSS_UNIT.exec(color); |
|
} |
|
|
|
// `stringInputToObject` |
|
// Permissive string parsing. Take in a number of formats, and output an object |
|
// based on detected format. Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}` |
|
function stringInputToObject(color) { |
|
|
|
color = color.replace(trimLeft,'').replace(trimRight, '').toLowerCase(); |
|
var named = false; |
|
if (names[color]) { |
|
color = names[color]; |
|
named = true; |
|
} |
|
else if (color == 'transparent') { |
|
return { r: 0, g: 0, b: 0, a: 0, format: "name" }; |
|
} |
|
|
|
// Try to match string input using regular expressions. |
|
// Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360] |
|
// Just return an object and let the conversion functions handle that. |
|
// This way the result will be the same whether the tinycolor is initialized with string or object. |
|
var match; |
|
if ((match = matchers.rgb.exec(color))) { |
|
return { r: match[1], g: match[2], b: match[3] }; |
|
} |
|
if ((match = matchers.rgba.exec(color))) { |
|
return { r: match[1], g: match[2], b: match[3], a: match[4] }; |
|
} |
|
if ((match = matchers.hsl.exec(color))) { |
|
return { h: match[1], s: match[2], l: match[3] }; |
|
} |
|
if ((match = matchers.hsla.exec(color))) { |
|
return { h: match[1], s: match[2], l: match[3], a: match[4] }; |
|
} |
|
if ((match = matchers.hsv.exec(color))) { |
|
return { h: match[1], s: match[2], v: match[3] }; |
|
} |
|
if ((match = matchers.hsva.exec(color))) { |
|
return { h: match[1], s: match[2], v: match[3], a: match[4] }; |
|
} |
|
if ((match = matchers.hex8.exec(color))) { |
|
return { |
|
r: parseIntFromHex(match[1]), |
|
g: parseIntFromHex(match[2]), |
|
b: parseIntFromHex(match[3]), |
|
a: convertHexToDecimal(match[4]), |
|
format: named ? "name" : "hex8" |
|
}; |
|
} |
|
if ((match = matchers.hex6.exec(color))) { |
|
return { |
|
r: parseIntFromHex(match[1]), |
|
g: parseIntFromHex(match[2]), |
|
b: parseIntFromHex(match[3]), |
|
format: named ? "name" : "hex" |
|
}; |
|
} |
|
if ((match = matchers.hex4.exec(color))) { |
|
return { |
|
r: parseIntFromHex(match[1] + '' + match[1]), |
|
g: parseIntFromHex(match[2] + '' + match[2]), |
|
b: parseIntFromHex(match[3] + '' + match[3]), |
|
a: convertHexToDecimal(match[4] + '' + match[4]), |
|
format: named ? "name" : "hex8" |
|
}; |
|
} |
|
if ((match = matchers.hex3.exec(color))) { |
|
return { |
|
r: parseIntFromHex(match[1] + '' + match[1]), |
|
g: parseIntFromHex(match[2] + '' + match[2]), |
|
b: parseIntFromHex(match[3] + '' + match[3]), |
|
format: named ? "name" : "hex" |
|
}; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
function validateWCAG2Parms(parms) { |
|
// return valid WCAG2 parms for isReadable. |
|
// If input parms are invalid, return {"level":"AA", "size":"small"} |
|
var level, size; |
|
parms = parms || {"level":"AA", "size":"small"}; |
|
level = (parms.level || "AA").toUpperCase(); |
|
size = (parms.size || "small").toLowerCase(); |
|
if (level !== "AA" && level !== "AAA") { |
|
level = "AA"; |
|
} |
|
if (size !== "small" && size !== "large") { |
|
size = "small"; |
|
} |
|
return {"level":level, "size":size}; |
|
} |
|
|
|
// Node: Export function |
|
if ( true && module.exports) { |
|
module.exports = tinycolor; |
|
} |
|
// AMD/requirejs: Define the module |
|
else if (true) { |
|
!(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {return tinycolor;}).call(exports, __webpack_require__, exports, module), |
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); |
|
} |
|
// Browser: Expose to window |
|
else {} |
|
|
|
})(Math); |
|
|
|
|
|
/***/ }), |
|
/* 49 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var defineProperties = __webpack_require__(55); |
|
|
|
var implementation = __webpack_require__(170); |
|
var getPolyfill = __webpack_require__(171); |
|
var shim = __webpack_require__(267); |
|
|
|
var polyfill = getPolyfill(); |
|
|
|
defineProperties(polyfill, { |
|
getPolyfill: getPolyfill, |
|
implementation: implementation, |
|
shim: shim |
|
}); |
|
|
|
module.exports = polyfill; |
|
|
|
|
|
/***/ }), |
|
/* 50 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
var calendarLabel = 'Calendar'; |
|
var closeDatePicker = 'Close'; |
|
var focusStartDate = 'Interact with the calendar and add the check-in date for your trip.'; |
|
var clearDate = 'Clear Date'; |
|
var clearDates = 'Clear Dates'; |
|
var jumpToPrevMonth = 'Move backward to switch to the previous month.'; |
|
var jumpToNextMonth = 'Move forward to switch to the next month.'; |
|
var keyboardShortcuts = 'Keyboard Shortcuts'; |
|
var showKeyboardShortcutsPanel = 'Open the keyboard shortcuts panel.'; |
|
var hideKeyboardShortcutsPanel = 'Close the shortcuts panel.'; |
|
var openThisPanel = 'Open this panel.'; |
|
var enterKey = 'Enter key'; |
|
var leftArrowRightArrow = 'Right and left arrow keys'; |
|
var upArrowDownArrow = 'up and down arrow keys'; |
|
var pageUpPageDown = 'page up and page down keys'; |
|
var homeEnd = 'Home and end keys'; |
|
var escape = 'Escape key'; |
|
var questionMark = 'Question mark'; |
|
var selectFocusedDate = 'Select the date in focus.'; |
|
var moveFocusByOneDay = 'Move backward (left) and forward (right) by one day.'; |
|
var moveFocusByOneWeek = 'Move backward (up) and forward (down) by one week.'; |
|
var moveFocusByOneMonth = 'Switch months.'; |
|
var moveFocustoStartAndEndOfWeek = 'Go to the first or last day of a week.'; |
|
var returnFocusToInput = 'Return to the date input field.'; |
|
var keyboardNavigationInstructions = 'Press the down arrow key to interact with the calendar and\n select a date. Press the question mark key to get the keyboard shortcuts for changing dates.'; |
|
|
|
var chooseAvailableStartDate = function chooseAvailableStartDate(_ref) { |
|
var date = _ref.date; |
|
return 'Choose ' + String(date) + ' as your check-in date. It\u2019s available.'; |
|
}; |
|
var chooseAvailableEndDate = function chooseAvailableEndDate(_ref2) { |
|
var date = _ref2.date; |
|
return 'Choose ' + String(date) + ' as your check-out date. It\u2019s available.'; |
|
}; |
|
var chooseAvailableDate = function chooseAvailableDate(_ref3) { |
|
var date = _ref3.date; |
|
return date; |
|
}; |
|
var dateIsUnavailable = function dateIsUnavailable(_ref4) { |
|
var date = _ref4.date; |
|
return 'Not available. ' + String(date); |
|
}; |
|
var dateIsSelected = function dateIsSelected(_ref5) { |
|
var date = _ref5.date; |
|
return 'Selected. ' + String(date); |
|
}; |
|
|
|
exports['default'] = { |
|
calendarLabel: calendarLabel, |
|
closeDatePicker: closeDatePicker, |
|
focusStartDate: focusStartDate, |
|
clearDate: clearDate, |
|
clearDates: clearDates, |
|
jumpToPrevMonth: jumpToPrevMonth, |
|
jumpToNextMonth: jumpToNextMonth, |
|
keyboardShortcuts: keyboardShortcuts, |
|
showKeyboardShortcutsPanel: showKeyboardShortcutsPanel, |
|
hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel, |
|
openThisPanel: openThisPanel, |
|
enterKey: enterKey, |
|
leftArrowRightArrow: leftArrowRightArrow, |
|
upArrowDownArrow: upArrowDownArrow, |
|
pageUpPageDown: pageUpPageDown, |
|
homeEnd: homeEnd, |
|
escape: escape, |
|
questionMark: questionMark, |
|
selectFocusedDate: selectFocusedDate, |
|
moveFocusByOneDay: moveFocusByOneDay, |
|
moveFocusByOneWeek: moveFocusByOneWeek, |
|
moveFocusByOneMonth: moveFocusByOneMonth, |
|
moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek, |
|
returnFocusToInput: returnFocusToInput, |
|
keyboardNavigationInstructions: keyboardNavigationInstructions, |
|
|
|
chooseAvailableStartDate: chooseAvailableStartDate, |
|
chooseAvailableEndDate: chooseAvailableEndDate, |
|
dateIsUnavailable: dateIsUnavailable, |
|
dateIsSelected: dateIsSelected |
|
}; |
|
var DateRangePickerPhrases = exports.DateRangePickerPhrases = { |
|
calendarLabel: calendarLabel, |
|
closeDatePicker: closeDatePicker, |
|
clearDates: clearDates, |
|
focusStartDate: focusStartDate, |
|
jumpToPrevMonth: jumpToPrevMonth, |
|
jumpToNextMonth: jumpToNextMonth, |
|
keyboardShortcuts: keyboardShortcuts, |
|
showKeyboardShortcutsPanel: showKeyboardShortcutsPanel, |
|
hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel, |
|
openThisPanel: openThisPanel, |
|
enterKey: enterKey, |
|
leftArrowRightArrow: leftArrowRightArrow, |
|
upArrowDownArrow: upArrowDownArrow, |
|
pageUpPageDown: pageUpPageDown, |
|
homeEnd: homeEnd, |
|
escape: escape, |
|
questionMark: questionMark, |
|
selectFocusedDate: selectFocusedDate, |
|
moveFocusByOneDay: moveFocusByOneDay, |
|
moveFocusByOneWeek: moveFocusByOneWeek, |
|
moveFocusByOneMonth: moveFocusByOneMonth, |
|
moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek, |
|
returnFocusToInput: returnFocusToInput, |
|
keyboardNavigationInstructions: keyboardNavigationInstructions, |
|
chooseAvailableStartDate: chooseAvailableStartDate, |
|
chooseAvailableEndDate: chooseAvailableEndDate, |
|
dateIsUnavailable: dateIsUnavailable, |
|
dateIsSelected: dateIsSelected |
|
}; |
|
|
|
var DateRangePickerInputPhrases = exports.DateRangePickerInputPhrases = { |
|
focusStartDate: focusStartDate, |
|
clearDates: clearDates, |
|
keyboardNavigationInstructions: keyboardNavigationInstructions |
|
}; |
|
|
|
var SingleDatePickerPhrases = exports.SingleDatePickerPhrases = { |
|
calendarLabel: calendarLabel, |
|
closeDatePicker: closeDatePicker, |
|
clearDate: clearDate, |
|
jumpToPrevMonth: jumpToPrevMonth, |
|
jumpToNextMonth: jumpToNextMonth, |
|
keyboardShortcuts: keyboardShortcuts, |
|
showKeyboardShortcutsPanel: showKeyboardShortcutsPanel, |
|
hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel, |
|
openThisPanel: openThisPanel, |
|
enterKey: enterKey, |
|
leftArrowRightArrow: leftArrowRightArrow, |
|
upArrowDownArrow: upArrowDownArrow, |
|
pageUpPageDown: pageUpPageDown, |
|
homeEnd: homeEnd, |
|
escape: escape, |
|
questionMark: questionMark, |
|
selectFocusedDate: selectFocusedDate, |
|
moveFocusByOneDay: moveFocusByOneDay, |
|
moveFocusByOneWeek: moveFocusByOneWeek, |
|
moveFocusByOneMonth: moveFocusByOneMonth, |
|
moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek, |
|
returnFocusToInput: returnFocusToInput, |
|
keyboardNavigationInstructions: keyboardNavigationInstructions, |
|
chooseAvailableDate: chooseAvailableDate, |
|
dateIsUnavailable: dateIsUnavailable, |
|
dateIsSelected: dateIsSelected |
|
}; |
|
|
|
var SingleDatePickerInputPhrases = exports.SingleDatePickerInputPhrases = { |
|
clearDate: clearDate, |
|
keyboardNavigationInstructions: keyboardNavigationInstructions |
|
}; |
|
|
|
var DayPickerPhrases = exports.DayPickerPhrases = { |
|
calendarLabel: calendarLabel, |
|
jumpToPrevMonth: jumpToPrevMonth, |
|
jumpToNextMonth: jumpToNextMonth, |
|
keyboardShortcuts: keyboardShortcuts, |
|
showKeyboardShortcutsPanel: showKeyboardShortcutsPanel, |
|
hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel, |
|
openThisPanel: openThisPanel, |
|
enterKey: enterKey, |
|
leftArrowRightArrow: leftArrowRightArrow, |
|
upArrowDownArrow: upArrowDownArrow, |
|
pageUpPageDown: pageUpPageDown, |
|
homeEnd: homeEnd, |
|
escape: escape, |
|
questionMark: questionMark, |
|
selectFocusedDate: selectFocusedDate, |
|
moveFocusByOneDay: moveFocusByOneDay, |
|
moveFocusByOneWeek: moveFocusByOneWeek, |
|
moveFocusByOneMonth: moveFocusByOneMonth, |
|
moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek, |
|
returnFocusToInput: returnFocusToInput, |
|
chooseAvailableStartDate: chooseAvailableStartDate, |
|
chooseAvailableEndDate: chooseAvailableEndDate, |
|
chooseAvailableDate: chooseAvailableDate, |
|
dateIsUnavailable: dateIsUnavailable, |
|
dateIsSelected: dateIsSelected |
|
}; |
|
|
|
var DayPickerKeyboardShortcutsPhrases = exports.DayPickerKeyboardShortcutsPhrases = { |
|
keyboardShortcuts: keyboardShortcuts, |
|
showKeyboardShortcutsPanel: showKeyboardShortcutsPanel, |
|
hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel, |
|
openThisPanel: openThisPanel, |
|
enterKey: enterKey, |
|
leftArrowRightArrow: leftArrowRightArrow, |
|
upArrowDownArrow: upArrowDownArrow, |
|
pageUpPageDown: pageUpPageDown, |
|
homeEnd: homeEnd, |
|
escape: escape, |
|
questionMark: questionMark, |
|
selectFocusedDate: selectFocusedDate, |
|
moveFocusByOneDay: moveFocusByOneDay, |
|
moveFocusByOneWeek: moveFocusByOneWeek, |
|
moveFocusByOneMonth: moveFocusByOneMonth, |
|
moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek, |
|
returnFocusToInput: returnFocusToInput |
|
}; |
|
|
|
var DayPickerNavigationPhrases = exports.DayPickerNavigationPhrases = { |
|
jumpToPrevMonth: jumpToPrevMonth, |
|
jumpToNextMonth: jumpToNextMonth |
|
}; |
|
|
|
var CalendarDayPhrases = exports.CalendarDayPhrases = { |
|
chooseAvailableDate: chooseAvailableDate, |
|
dateIsUnavailable: dateIsUnavailable, |
|
dateIsSelected: dateIsSelected |
|
}; |
|
|
|
/***/ }), |
|
/* 51 */, |
|
/* 52 */, |
|
/* 53 */, |
|
/* 54 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = getPhrasePropTypes; |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } |
|
|
|
function getPhrasePropTypes(defaultPhrases) { |
|
return Object.keys(defaultPhrases).reduce(function (phrases, key) { |
|
return (0, _object2['default'])({}, phrases, _defineProperty({}, key, _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].func, _propTypes2['default'].node]))); |
|
}, {}); |
|
} |
|
|
|
/***/ }), |
|
/* 55 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var keys = __webpack_require__(90); |
|
var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol'; |
|
|
|
var toStr = Object.prototype.toString; |
|
var concat = Array.prototype.concat; |
|
var origDefineProperty = Object.defineProperty; |
|
|
|
var isFunction = function (fn) { |
|
return typeof fn === 'function' && toStr.call(fn) === '[object Function]'; |
|
}; |
|
|
|
var arePropertyDescriptorsSupported = function () { |
|
var obj = {}; |
|
try { |
|
origDefineProperty(obj, 'x', { enumerable: false, value: obj }); |
|
// eslint-disable-next-line no-unused-vars, no-restricted-syntax |
|
for (var _ in obj) { // jscs:ignore disallowUnusedVariables |
|
return false; |
|
} |
|
return obj.x === obj; |
|
} catch (e) { /* this is IE 8. */ |
|
return false; |
|
} |
|
}; |
|
var supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported(); |
|
|
|
var defineProperty = function (object, name, value, predicate) { |
|
if (name in object && (!isFunction(predicate) || !predicate())) { |
|
return; |
|
} |
|
if (supportsDescriptors) { |
|
origDefineProperty(object, name, { |
|
configurable: true, |
|
enumerable: false, |
|
value: value, |
|
writable: true |
|
}); |
|
} else { |
|
object[name] = value; |
|
} |
|
}; |
|
|
|
var defineProperties = function (object, map) { |
|
var predicates = arguments.length > 2 ? arguments[2] : {}; |
|
var props = keys(map); |
|
if (hasSymbols) { |
|
props = concat.call(props, Object.getOwnPropertySymbols(map)); |
|
} |
|
for (var i = 0; i < props.length; i += 1) { |
|
defineProperty(object, props[i], map[props[i]], predicates[props[i]]); |
|
} |
|
}; |
|
|
|
defineProperties.supportsDescriptors = !!supportsDescriptors; |
|
|
|
module.exports = defineProperties; |
|
|
|
|
|
/***/ }), |
|
/* 56 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.withStylesPropTypes = exports.css = undefined; |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
exports.withStyles = withStyles; |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _hoistNonReactStatics = __webpack_require__(272); |
|
|
|
var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics); |
|
|
|
var _constants = __webpack_require__(275); |
|
|
|
var _brcast = __webpack_require__(276); |
|
|
|
var _brcast2 = _interopRequireDefault(_brcast); |
|
|
|
var _ThemedStyleSheet = __webpack_require__(168); |
|
|
|
var _ThemedStyleSheet2 = _interopRequireDefault(_ThemedStyleSheet); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } /* eslint react/forbid-foreign-prop-types: off */ |
|
|
|
// Add some named exports to assist in upgrading and for convenience |
|
var css = exports.css = _ThemedStyleSheet2['default'].resolveLTR; |
|
var withStylesPropTypes = exports.withStylesPropTypes = { |
|
styles: _propTypes2['default'].object.isRequired, // eslint-disable-line react/forbid-prop-types |
|
theme: _propTypes2['default'].object.isRequired, // eslint-disable-line react/forbid-prop-types |
|
css: _propTypes2['default'].func.isRequired |
|
}; |
|
|
|
var EMPTY_STYLES = {}; |
|
var EMPTY_STYLES_FN = function EMPTY_STYLES_FN() { |
|
return EMPTY_STYLES; |
|
}; |
|
|
|
var START_MARK = 'react-with-styles.createStyles.start'; |
|
var END_MARK = 'react-with-styles.createStyles.end'; |
|
|
|
function baseClass(pureComponent) { |
|
if (pureComponent) { |
|
if (!_react2['default'].PureComponent) { |
|
throw new ReferenceError('withStyles() pureComponent option requires React 15.3.0 or later'); |
|
} |
|
|
|
return _react2['default'].PureComponent; |
|
} |
|
|
|
return _react2['default'].Component; |
|
} |
|
|
|
var contextTypes = _defineProperty({}, _constants.CHANNEL, _brcast2['default']); |
|
|
|
var defaultDirection = _constants.DIRECTIONS.LTR; |
|
|
|
function withStyles(styleFn) { |
|
var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, |
|
_ref$stylesPropName = _ref.stylesPropName, |
|
stylesPropName = _ref$stylesPropName === undefined ? 'styles' : _ref$stylesPropName, |
|
_ref$themePropName = _ref.themePropName, |
|
themePropName = _ref$themePropName === undefined ? 'theme' : _ref$themePropName, |
|
_ref$cssPropName = _ref.cssPropName, |
|
cssPropName = _ref$cssPropName === undefined ? 'css' : _ref$cssPropName, |
|
_ref$flushBefore = _ref.flushBefore, |
|
flushBefore = _ref$flushBefore === undefined ? false : _ref$flushBefore, |
|
_ref$pureComponent = _ref.pureComponent, |
|
pureComponent = _ref$pureComponent === undefined ? false : _ref$pureComponent; |
|
|
|
var styleDefLTR = void 0; |
|
var styleDefRTL = void 0; |
|
var currentThemeLTR = void 0; |
|
var currentThemeRTL = void 0; |
|
var BaseClass = baseClass(pureComponent); |
|
|
|
function getResolveMethod(direction) { |
|
return direction === _constants.DIRECTIONS.LTR ? _ThemedStyleSheet2['default'].resolveLTR : _ThemedStyleSheet2['default'].resolveRTL; |
|
} |
|
|
|
function getCurrentTheme(direction) { |
|
return direction === _constants.DIRECTIONS.LTR ? currentThemeLTR : currentThemeRTL; |
|
} |
|
|
|
function getStyleDef(direction, wrappedComponentName) { |
|
var currentTheme = getCurrentTheme(direction); |
|
var styleDef = direction === _constants.DIRECTIONS.LTR ? styleDefLTR : styleDefRTL; |
|
|
|
var registeredTheme = _ThemedStyleSheet2['default'].get(); |
|
|
|
// Return the existing styles if they've already been defined |
|
// and if the theme used to create them corresponds to the theme |
|
// registered with ThemedStyleSheet |
|
if (styleDef && currentTheme === registeredTheme) { |
|
return styleDef; |
|
} |
|
|
|
if (false) {} |
|
|
|
var isRTL = direction === _constants.DIRECTIONS.RTL; |
|
|
|
if (isRTL) { |
|
styleDefRTL = styleFn ? _ThemedStyleSheet2['default'].createRTL(styleFn) : EMPTY_STYLES_FN; |
|
|
|
currentThemeRTL = registeredTheme; |
|
styleDef = styleDefRTL; |
|
} else { |
|
styleDefLTR = styleFn ? _ThemedStyleSheet2['default'].createLTR(styleFn) : EMPTY_STYLES_FN; |
|
|
|
currentThemeLTR = registeredTheme; |
|
styleDef = styleDefLTR; |
|
} |
|
|
|
if (false) { var measureName; } |
|
|
|
return styleDef; |
|
} |
|
|
|
function getState(direction, wrappedComponentName) { |
|
return { |
|
resolveMethod: getResolveMethod(direction), |
|
styleDef: getStyleDef(direction, wrappedComponentName) |
|
}; |
|
} |
|
|
|
return function () { |
|
function withStylesHOC(WrappedComponent) { |
|
var wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || 'Component'; |
|
|
|
// NOTE: Use a class here so components are ref-able if need be: |
|
// eslint-disable-next-line react/prefer-stateless-function |
|
|
|
var WithStyles = function (_BaseClass) { |
|
_inherits(WithStyles, _BaseClass); |
|
|
|
function WithStyles(props, context) { |
|
_classCallCheck(this, WithStyles); |
|
|
|
var _this = _possibleConstructorReturn(this, (WithStyles.__proto__ || Object.getPrototypeOf(WithStyles)).call(this, props, context)); |
|
|
|
var direction = _this.context[_constants.CHANNEL] ? _this.context[_constants.CHANNEL].getState() : defaultDirection; |
|
|
|
_this.state = getState(direction, wrappedComponentName); |
|
return _this; |
|
} |
|
|
|
_createClass(WithStyles, [{ |
|
key: 'componentDidMount', |
|
value: function () { |
|
function componentDidMount() { |
|
var _this2 = this; |
|
|
|
if (this.context[_constants.CHANNEL]) { |
|
// subscribe to future direction changes |
|
this.channelUnsubscribe = this.context[_constants.CHANNEL].subscribe(function (direction) { |
|
_this2.setState(getState(direction, wrappedComponentName)); |
|
}); |
|
} |
|
} |
|
|
|
return componentDidMount; |
|
}() |
|
}, { |
|
key: 'componentWillUnmount', |
|
value: function () { |
|
function componentWillUnmount() { |
|
if (this.channelUnsubscribe) { |
|
this.channelUnsubscribe(); |
|
} |
|
} |
|
|
|
return componentWillUnmount; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _ref2; |
|
|
|
// As some components will depend on previous styles in |
|
// the component tree, we provide the option of flushing the |
|
// buffered styles (i.e. to a style tag) **before** the rendering |
|
// cycle begins. |
|
// |
|
// The interfaces provide the optional "flush" method which |
|
// is run in turn by ThemedStyleSheet.flush. |
|
if (flushBefore) { |
|
_ThemedStyleSheet2['default'].flush(); |
|
} |
|
|
|
var _state = this.state, |
|
resolveMethod = _state.resolveMethod, |
|
styleDef = _state.styleDef; |
|
|
|
|
|
return _react2['default'].createElement(WrappedComponent, _extends({}, this.props, (_ref2 = {}, _defineProperty(_ref2, themePropName, _ThemedStyleSheet2['default'].get()), _defineProperty(_ref2, stylesPropName, styleDef()), _defineProperty(_ref2, cssPropName, resolveMethod), _ref2))); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return WithStyles; |
|
}(BaseClass); |
|
|
|
WithStyles.WrappedComponent = WrappedComponent; |
|
WithStyles.displayName = 'withStyles(' + String(wrappedComponentName) + ')'; |
|
WithStyles.contextTypes = contextTypes; |
|
if (WrappedComponent.propTypes) { |
|
WithStyles.propTypes = (0, _object2['default'])({}, WrappedComponent.propTypes); |
|
delete WithStyles.propTypes[stylesPropName]; |
|
delete WithStyles.propTypes[themePropName]; |
|
delete WithStyles.propTypes[cssPropName]; |
|
} |
|
if (WrappedComponent.defaultProps) { |
|
WithStyles.defaultProps = (0, _object2['default'])({}, WrappedComponent.defaultProps); |
|
} |
|
|
|
return (0, _hoistNonReactStatics2['default'])(WithStyles, WrappedComponent); |
|
} |
|
|
|
return withStylesHOC; |
|
}(); |
|
} |
|
|
|
/***/ }), |
|
/* 57 */ |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["ReactDOM"]; }()); |
|
|
|
/***/ }), |
|
/* 58 */, |
|
/* 59 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var implementation = __webpack_require__(244); |
|
|
|
module.exports = Function.prototype.bind || implementation; |
|
|
|
|
|
/***/ }), |
|
/* 60 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
/* globals |
|
Atomics, |
|
SharedArrayBuffer, |
|
*/ |
|
|
|
var undefined; // eslint-disable-line no-shadow-restricted-names |
|
|
|
var $TypeError = TypeError; |
|
|
|
var ThrowTypeError = Object.getOwnPropertyDescriptor |
|
? (function () { return Object.getOwnPropertyDescriptor(arguments, 'callee').get; }()) |
|
: function () { throw new $TypeError(); }; |
|
|
|
var hasSymbols = __webpack_require__(100)(); |
|
|
|
var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto |
|
|
|
var generator; // = function * () {}; |
|
var generatorFunction = generator ? getProto(generator) : undefined; |
|
var asyncFn; // async function() {}; |
|
var asyncFunction = asyncFn ? asyncFn.constructor : undefined; |
|
var asyncGen; // async function * () {}; |
|
var asyncGenFunction = asyncGen ? getProto(asyncGen) : undefined; |
|
var asyncGenIterator = asyncGen ? asyncGen() : undefined; |
|
|
|
var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array); |
|
|
|
var INTRINSICS = { |
|
'$ %Array%': Array, |
|
'$ %ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer, |
|
'$ %ArrayBufferPrototype%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer.prototype, |
|
'$ %ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined, |
|
'$ %ArrayPrototype%': Array.prototype, |
|
'$ %ArrayProto_entries%': Array.prototype.entries, |
|
'$ %ArrayProto_forEach%': Array.prototype.forEach, |
|
'$ %ArrayProto_keys%': Array.prototype.keys, |
|
'$ %ArrayProto_values%': Array.prototype.values, |
|
'$ %AsyncFromSyncIteratorPrototype%': undefined, |
|
'$ %AsyncFunction%': asyncFunction, |
|
'$ %AsyncFunctionPrototype%': asyncFunction ? asyncFunction.prototype : undefined, |
|
'$ %AsyncGenerator%': asyncGen ? getProto(asyncGenIterator) : undefined, |
|
'$ %AsyncGeneratorFunction%': asyncGenFunction, |
|
'$ %AsyncGeneratorPrototype%': asyncGenFunction ? asyncGenFunction.prototype : undefined, |
|
'$ %AsyncIteratorPrototype%': asyncGenIterator && hasSymbols && Symbol.asyncIterator ? asyncGenIterator[Symbol.asyncIterator]() : undefined, |
|
'$ %Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics, |
|
'$ %Boolean%': Boolean, |
|
'$ %BooleanPrototype%': Boolean.prototype, |
|
'$ %DataView%': typeof DataView === 'undefined' ? undefined : DataView, |
|
'$ %DataViewPrototype%': typeof DataView === 'undefined' ? undefined : DataView.prototype, |
|
'$ %Date%': Date, |
|
'$ %DatePrototype%': Date.prototype, |
|
'$ %decodeURI%': decodeURI, |
|
'$ %decodeURIComponent%': decodeURIComponent, |
|
'$ %encodeURI%': encodeURI, |
|
'$ %encodeURIComponent%': encodeURIComponent, |
|
'$ %Error%': Error, |
|
'$ %ErrorPrototype%': Error.prototype, |
|
'$ %eval%': eval, // eslint-disable-line no-eval |
|
'$ %EvalError%': EvalError, |
|
'$ %EvalErrorPrototype%': EvalError.prototype, |
|
'$ %Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array, |
|
'$ %Float32ArrayPrototype%': typeof Float32Array === 'undefined' ? undefined : Float32Array.prototype, |
|
'$ %Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array, |
|
'$ %Float64ArrayPrototype%': typeof Float64Array === 'undefined' ? undefined : Float64Array.prototype, |
|
'$ %Function%': Function, |
|
'$ %FunctionPrototype%': Function.prototype, |
|
'$ %Generator%': generator ? getProto(generator()) : undefined, |
|
'$ %GeneratorFunction%': generatorFunction, |
|
'$ %GeneratorPrototype%': generatorFunction ? generatorFunction.prototype : undefined, |
|
'$ %Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array, |
|
'$ %Int8ArrayPrototype%': typeof Int8Array === 'undefined' ? undefined : Int8Array.prototype, |
|
'$ %Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array, |
|
'$ %Int16ArrayPrototype%': typeof Int16Array === 'undefined' ? undefined : Int8Array.prototype, |
|
'$ %Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array, |
|
'$ %Int32ArrayPrototype%': typeof Int32Array === 'undefined' ? undefined : Int32Array.prototype, |
|
'$ %isFinite%': isFinite, |
|
'$ %isNaN%': isNaN, |
|
'$ %IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined, |
|
'$ %JSON%': JSON, |
|
'$ %JSONParse%': JSON.parse, |
|
'$ %Map%': typeof Map === 'undefined' ? undefined : Map, |
|
'$ %MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()), |
|
'$ %MapPrototype%': typeof Map === 'undefined' ? undefined : Map.prototype, |
|
'$ %Math%': Math, |
|
'$ %Number%': Number, |
|
'$ %NumberPrototype%': Number.prototype, |
|
'$ %Object%': Object, |
|
'$ %ObjectPrototype%': Object.prototype, |
|
'$ %ObjProto_toString%': Object.prototype.toString, |
|
'$ %ObjProto_valueOf%': Object.prototype.valueOf, |
|
'$ %parseFloat%': parseFloat, |
|
'$ %parseInt%': parseInt, |
|
'$ %Promise%': typeof Promise === 'undefined' ? undefined : Promise, |
|
'$ %PromisePrototype%': typeof Promise === 'undefined' ? undefined : Promise.prototype, |
|
'$ %PromiseProto_then%': typeof Promise === 'undefined' ? undefined : Promise.prototype.then, |
|
'$ %Promise_all%': typeof Promise === 'undefined' ? undefined : Promise.all, |
|
'$ %Promise_reject%': typeof Promise === 'undefined' ? undefined : Promise.reject, |
|
'$ %Promise_resolve%': typeof Promise === 'undefined' ? undefined : Promise.resolve, |
|
'$ %Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy, |
|
'$ %RangeError%': RangeError, |
|
'$ %RangeErrorPrototype%': RangeError.prototype, |
|
'$ %ReferenceError%': ReferenceError, |
|
'$ %ReferenceErrorPrototype%': ReferenceError.prototype, |
|
'$ %Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect, |
|
'$ %RegExp%': RegExp, |
|
'$ %RegExpPrototype%': RegExp.prototype, |
|
'$ %Set%': typeof Set === 'undefined' ? undefined : Set, |
|
'$ %SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()), |
|
'$ %SetPrototype%': typeof Set === 'undefined' ? undefined : Set.prototype, |
|
'$ %SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer, |
|
'$ %SharedArrayBufferPrototype%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer.prototype, |
|
'$ %String%': String, |
|
'$ %StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined, |
|
'$ %StringPrototype%': String.prototype, |
|
'$ %Symbol%': hasSymbols ? Symbol : undefined, |
|
'$ %SymbolPrototype%': hasSymbols ? Symbol.prototype : undefined, |
|
'$ %SyntaxError%': SyntaxError, |
|
'$ %SyntaxErrorPrototype%': SyntaxError.prototype, |
|
'$ %ThrowTypeError%': ThrowTypeError, |
|
'$ %TypedArray%': TypedArray, |
|
'$ %TypedArrayPrototype%': TypedArray ? TypedArray.prototype : undefined, |
|
'$ %TypeError%': $TypeError, |
|
'$ %TypeErrorPrototype%': $TypeError.prototype, |
|
'$ %Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array, |
|
'$ %Uint8ArrayPrototype%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array.prototype, |
|
'$ %Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray, |
|
'$ %Uint8ClampedArrayPrototype%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray.prototype, |
|
'$ %Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array, |
|
'$ %Uint16ArrayPrototype%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array.prototype, |
|
'$ %Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array, |
|
'$ %Uint32ArrayPrototype%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array.prototype, |
|
'$ %URIError%': URIError, |
|
'$ %URIErrorPrototype%': URIError.prototype, |
|
'$ %WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap, |
|
'$ %WeakMapPrototype%': typeof WeakMap === 'undefined' ? undefined : WeakMap.prototype, |
|
'$ %WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet, |
|
'$ %WeakSetPrototype%': typeof WeakSet === 'undefined' ? undefined : WeakSet.prototype |
|
}; |
|
|
|
var bind = __webpack_require__(59); |
|
var $replace = bind.call(Function.call, String.prototype.replace); |
|
|
|
/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */ |
|
var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g; |
|
var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */ |
|
var stringToPath = function stringToPath(string) { |
|
var result = []; |
|
$replace(string, rePropName, function (match, number, quote, subString) { |
|
result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : (number || match); |
|
}); |
|
return result; |
|
}; |
|
/* end adaptation */ |
|
|
|
var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) { |
|
var key = '$ ' + name; |
|
if (!(key in INTRINSICS)) { |
|
throw new SyntaxError('intrinsic ' + name + ' does not exist!'); |
|
} |
|
|
|
// istanbul ignore if // hopefully this is impossible to test :-) |
|
if (typeof INTRINSICS[key] === 'undefined' && !allowMissing) { |
|
throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!'); |
|
} |
|
|
|
return INTRINSICS[key]; |
|
}; |
|
|
|
module.exports = function GetIntrinsic(name, allowMissing) { |
|
if (arguments.length > 1 && typeof allowMissing !== 'boolean') { |
|
throw new TypeError('"allowMissing" argument must be a boolean'); |
|
} |
|
|
|
var parts = stringToPath(name); |
|
|
|
if (parts.length === 0) { |
|
return getBaseIntrinsic(name, allowMissing); |
|
} |
|
|
|
var value = getBaseIntrinsic('%' + parts[0] + '%', allowMissing); |
|
for (var i = 1; i < parts.length; i += 1) { |
|
if (value != null) { |
|
value = value[parts[i]]; |
|
} |
|
} |
|
return value; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 61 */, |
|
/* 62 */, |
|
/* 63 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var bind = __webpack_require__(59); |
|
|
|
module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty); |
|
|
|
|
|
/***/ }), |
|
/* 64 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true }); |
|
|
|
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } |
|
|
|
var _extends = _interopDefault(__webpack_require__(119)); |
|
var _objectWithoutPropertiesLoose = _interopDefault(__webpack_require__(120)); |
|
var React = __webpack_require__(28); |
|
var React__default = _interopDefault(React); |
|
var _inheritsLoose = _interopDefault(__webpack_require__(121)); |
|
var _assertThisInitialized = _interopDefault(__webpack_require__(122)); |
|
|
|
var is = { |
|
arr: Array.isArray, |
|
obj: function obj(a) { |
|
return Object.prototype.toString.call(a) === '[object Object]'; |
|
}, |
|
fun: function fun(a) { |
|
return typeof a === 'function'; |
|
}, |
|
str: function str(a) { |
|
return typeof a === 'string'; |
|
}, |
|
num: function num(a) { |
|
return typeof a === 'number'; |
|
}, |
|
und: function und(a) { |
|
return a === void 0; |
|
}, |
|
nul: function nul(a) { |
|
return a === null; |
|
}, |
|
set: function set(a) { |
|
return a instanceof Set; |
|
}, |
|
map: function map(a) { |
|
return a instanceof Map; |
|
}, |
|
equ: function equ(a, b) { |
|
if (typeof a !== typeof b) return false; |
|
if (is.str(a) || is.num(a)) return a === b; |
|
if (is.obj(a) && is.obj(b) && Object.keys(a).length + Object.keys(b).length === 0) return true; |
|
var i; |
|
|
|
for (i in a) { |
|
if (!(i in b)) return false; |
|
} |
|
|
|
for (i in b) { |
|
if (a[i] !== b[i]) return false; |
|
} |
|
|
|
return is.und(i) ? a === b : true; |
|
} |
|
}; |
|
function merge(target, lowercase) { |
|
if (lowercase === void 0) { |
|
lowercase = true; |
|
} |
|
|
|
return function (object) { |
|
return (is.arr(object) ? object : Object.keys(object)).reduce(function (acc, element) { |
|
var key = lowercase ? element[0].toLowerCase() + element.substring(1) : element; |
|
acc[key] = target(key); |
|
return acc; |
|
}, target); |
|
}; |
|
} |
|
function useForceUpdate() { |
|
var _useState = React.useState(false), |
|
f = _useState[1]; |
|
|
|
var forceUpdate = React.useCallback(function () { |
|
return f(function (v) { |
|
return !v; |
|
}); |
|
}, []); |
|
return forceUpdate; |
|
} |
|
function withDefault(value, defaultValue) { |
|
return is.und(value) || is.nul(value) ? defaultValue : value; |
|
} |
|
function toArray(a) { |
|
return !is.und(a) ? is.arr(a) ? a : [a] : []; |
|
} |
|
function callProp(obj) { |
|
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { |
|
args[_key - 1] = arguments[_key]; |
|
} |
|
|
|
return is.fun(obj) ? obj.apply(void 0, args) : obj; |
|
} |
|
|
|
function getForwardProps(props) { |
|
var to = props.to, |
|
from = props.from, |
|
config = props.config, |
|
onStart = props.onStart, |
|
onRest = props.onRest, |
|
onFrame = props.onFrame, |
|
children = props.children, |
|
reset = props.reset, |
|
reverse = props.reverse, |
|
force = props.force, |
|
immediate = props.immediate, |
|
delay = props.delay, |
|
attach = props.attach, |
|
destroyed = props.destroyed, |
|
interpolateTo = props.interpolateTo, |
|
ref = props.ref, |
|
lazy = props.lazy, |
|
forward = _objectWithoutPropertiesLoose(props, ["to", "from", "config", "onStart", "onRest", "onFrame", "children", "reset", "reverse", "force", "immediate", "delay", "attach", "destroyed", "interpolateTo", "ref", "lazy"]); |
|
|
|
return forward; |
|
} |
|
|
|
function interpolateTo(props) { |
|
var forward = getForwardProps(props); |
|
if (is.und(forward)) return _extends({ |
|
to: forward |
|
}, props); |
|
var rest = Object.keys(props).reduce(function (a, k) { |
|
var _extends2; |
|
|
|
return !is.und(forward[k]) ? a : _extends({}, a, (_extends2 = {}, _extends2[k] = props[k], _extends2)); |
|
}, {}); |
|
return _extends({ |
|
to: forward |
|
}, rest); |
|
} |
|
function handleRef(ref, forward) { |
|
if (forward) { |
|
// If it's a function, assume it's a ref callback |
|
if (is.fun(forward)) forward(ref);else if (is.obj(forward)) { |
|
forward.current = ref; |
|
} |
|
} |
|
|
|
return ref; |
|
} |
|
|
|
var Animated = |
|
/*#__PURE__*/ |
|
function () { |
|
function Animated() { |
|
this.payload = void 0; |
|
this.children = []; |
|
} |
|
|
|
var _proto = Animated.prototype; |
|
|
|
_proto.getAnimatedValue = function getAnimatedValue() { |
|
return this.getValue(); |
|
}; |
|
|
|
_proto.getPayload = function getPayload() { |
|
return this.payload || this; |
|
}; |
|
|
|
_proto.attach = function attach() {}; |
|
|
|
_proto.detach = function detach() {}; |
|
|
|
_proto.getChildren = function getChildren() { |
|
return this.children; |
|
}; |
|
|
|
_proto.addChild = function addChild(child) { |
|
if (this.children.length === 0) this.attach(); |
|
this.children.push(child); |
|
}; |
|
|
|
_proto.removeChild = function removeChild(child) { |
|
var index = this.children.indexOf(child); |
|
this.children.splice(index, 1); |
|
if (this.children.length === 0) this.detach(); |
|
}; |
|
|
|
return Animated; |
|
}(); |
|
var AnimatedArray = |
|
/*#__PURE__*/ |
|
function (_Animated) { |
|
_inheritsLoose(AnimatedArray, _Animated); |
|
|
|
function AnimatedArray() { |
|
var _this; |
|
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { |
|
args[_key] = arguments[_key]; |
|
} |
|
|
|
_this = _Animated.call.apply(_Animated, [this].concat(args)) || this; |
|
_this.payload = []; |
|
|
|
_this.attach = function () { |
|
return _this.payload.forEach(function (p) { |
|
return p instanceof Animated && p.addChild(_assertThisInitialized(_this)); |
|
}); |
|
}; |
|
|
|
_this.detach = function () { |
|
return _this.payload.forEach(function (p) { |
|
return p instanceof Animated && p.removeChild(_assertThisInitialized(_this)); |
|
}); |
|
}; |
|
|
|
return _this; |
|
} |
|
|
|
return AnimatedArray; |
|
}(Animated); |
|
var AnimatedObject = |
|
/*#__PURE__*/ |
|
function (_Animated2) { |
|
_inheritsLoose(AnimatedObject, _Animated2); |
|
|
|
function AnimatedObject() { |
|
var _this2; |
|
|
|
for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { |
|
args[_key3] = arguments[_key3]; |
|
} |
|
|
|
_this2 = _Animated2.call.apply(_Animated2, [this].concat(args)) || this; |
|
_this2.payload = {}; |
|
|
|
_this2.attach = function () { |
|
return Object.values(_this2.payload).forEach(function (s) { |
|
return s instanceof Animated && s.addChild(_assertThisInitialized(_this2)); |
|
}); |
|
}; |
|
|
|
_this2.detach = function () { |
|
return Object.values(_this2.payload).forEach(function (s) { |
|
return s instanceof Animated && s.removeChild(_assertThisInitialized(_this2)); |
|
}); |
|
}; |
|
|
|
return _this2; |
|
} |
|
|
|
var _proto2 = AnimatedObject.prototype; |
|
|
|
_proto2.getValue = function getValue(animated) { |
|
if (animated === void 0) { |
|
animated = false; |
|
} |
|
|
|
var payload = {}; |
|
|
|
for (var _key4 in this.payload) { |
|
var value = this.payload[_key4]; |
|
if (animated && !(value instanceof Animated)) continue; |
|
payload[_key4] = value instanceof Animated ? value[animated ? 'getAnimatedValue' : 'getValue']() : value; |
|
} |
|
|
|
return payload; |
|
}; |
|
|
|
_proto2.getAnimatedValue = function getAnimatedValue() { |
|
return this.getValue(true); |
|
}; |
|
|
|
return AnimatedObject; |
|
}(Animated); |
|
|
|
var applyAnimatedValues; |
|
function injectApplyAnimatedValues(fn, transform) { |
|
applyAnimatedValues = { |
|
fn: fn, |
|
transform: transform |
|
}; |
|
} |
|
var colorNames; |
|
function injectColorNames(names) { |
|
colorNames = names; |
|
} |
|
var requestFrame = function requestFrame(cb) { |
|
return typeof window !== 'undefined' ? window.requestAnimationFrame(cb) : -1; |
|
}; |
|
var cancelFrame = function cancelFrame(id) { |
|
typeof window !== 'undefined' && window.cancelAnimationFrame(id); |
|
}; |
|
function injectFrame(raf, caf) { |
|
requestFrame = raf; |
|
cancelFrame = caf; |
|
} |
|
var interpolation; |
|
function injectStringInterpolator(fn) { |
|
interpolation = fn; |
|
} |
|
var now = function now() { |
|
return Date.now(); |
|
}; |
|
function injectNow(nowFn) { |
|
now = nowFn; |
|
} |
|
var defaultElement; |
|
function injectDefaultElement(el) { |
|
defaultElement = el; |
|
} |
|
var animatedApi = function animatedApi(node) { |
|
return node.current; |
|
}; |
|
function injectAnimatedApi(fn) { |
|
animatedApi = fn; |
|
} |
|
var createAnimatedStyle; |
|
function injectCreateAnimatedStyle(factory) { |
|
createAnimatedStyle = factory; |
|
} |
|
var manualFrameloop; |
|
function injectManualFrameloop(callback) { |
|
manualFrameloop = callback; |
|
} |
|
|
|
var Globals = /*#__PURE__*/Object.freeze({ |
|
get applyAnimatedValues () { return applyAnimatedValues; }, |
|
injectApplyAnimatedValues: injectApplyAnimatedValues, |
|
get colorNames () { return colorNames; }, |
|
injectColorNames: injectColorNames, |
|
get requestFrame () { return requestFrame; }, |
|
get cancelFrame () { return cancelFrame; }, |
|
injectFrame: injectFrame, |
|
get interpolation () { return interpolation; }, |
|
injectStringInterpolator: injectStringInterpolator, |
|
get now () { return now; }, |
|
injectNow: injectNow, |
|
get defaultElement () { return defaultElement; }, |
|
injectDefaultElement: injectDefaultElement, |
|
get animatedApi () { return animatedApi; }, |
|
injectAnimatedApi: injectAnimatedApi, |
|
get createAnimatedStyle () { return createAnimatedStyle; }, |
|
injectCreateAnimatedStyle: injectCreateAnimatedStyle, |
|
get manualFrameloop () { return manualFrameloop; }, |
|
injectManualFrameloop: injectManualFrameloop |
|
}); |
|
|
|
/** |
|
* Wraps the `style` property with `AnimatedStyle`. |
|
*/ |
|
|
|
var AnimatedProps = |
|
/*#__PURE__*/ |
|
function (_AnimatedObject) { |
|
_inheritsLoose(AnimatedProps, _AnimatedObject); |
|
|
|
function AnimatedProps(props, callback) { |
|
var _this; |
|
|
|
_this = _AnimatedObject.call(this) || this; |
|
_this.update = void 0; |
|
_this.payload = !props.style ? props : _extends({}, props, { |
|
style: createAnimatedStyle(props.style) |
|
}); |
|
_this.update = callback; |
|
|
|
_this.attach(); |
|
|
|
return _this; |
|
} |
|
|
|
return AnimatedProps; |
|
}(AnimatedObject); |
|
|
|
var isFunctionComponent = function isFunctionComponent(val) { |
|
return is.fun(val) && !(val.prototype instanceof React__default.Component); |
|
}; |
|
|
|
var createAnimatedComponent = function createAnimatedComponent(Component) { |
|
var AnimatedComponent = React.forwardRef(function (props, ref) { |
|
var forceUpdate = useForceUpdate(); |
|
var mounted = React.useRef(true); |
|
var propsAnimated = React.useRef(null); |
|
var node = React.useRef(null); |
|
var attachProps = React.useCallback(function (props) { |
|
var oldPropsAnimated = propsAnimated.current; |
|
|
|
var callback = function callback() { |
|
var didUpdate = false; |
|
|
|
if (node.current) { |
|
didUpdate = applyAnimatedValues.fn(node.current, propsAnimated.current.getAnimatedValue()); |
|
} |
|
|
|
if (!node.current || didUpdate === false) { |
|
// If no referenced node has been found, or the update target didn't have a |
|
// native-responder, then forceUpdate the animation ... |
|
forceUpdate(); |
|
} |
|
}; |
|
|
|
propsAnimated.current = new AnimatedProps(props, callback); |
|
oldPropsAnimated && oldPropsAnimated.detach(); |
|
}, []); |
|
React.useEffect(function () { |
|
return function () { |
|
mounted.current = false; |
|
propsAnimated.current && propsAnimated.current.detach(); |
|
}; |
|
}, []); |
|
React.useImperativeHandle(ref, function () { |
|
return animatedApi(node, mounted, forceUpdate); |
|
}); |
|
attachProps(props); |
|
|
|
var _getValue = propsAnimated.current.getValue(), |
|
scrollTop = _getValue.scrollTop, |
|
scrollLeft = _getValue.scrollLeft, |
|
animatedProps = _objectWithoutPropertiesLoose(_getValue, ["scrollTop", "scrollLeft"]); // Functions cannot have refs, see: |
|
// See: https://github.com/react-spring/react-spring/issues/569 |
|
|
|
|
|
var refFn = isFunctionComponent(Component) ? undefined : function (childRef) { |
|
return node.current = handleRef(childRef, ref); |
|
}; |
|
return React__default.createElement(Component, _extends({}, animatedProps, { |
|
ref: refFn |
|
})); |
|
}); |
|
return AnimatedComponent; |
|
}; |
|
|
|
var active = false; |
|
var controllers = new Set(); |
|
|
|
var update = function update() { |
|
if (!active) return false; |
|
var time = now(); |
|
|
|
for (var _iterator = controllers, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { |
|
var _ref; |
|
|
|
if (_isArray) { |
|
if (_i >= _iterator.length) break; |
|
_ref = _iterator[_i++]; |
|
} else { |
|
_i = _iterator.next(); |
|
if (_i.done) break; |
|
_ref = _i.value; |
|
} |
|
|
|
var controller = _ref; |
|
var isActive = false; |
|
|
|
for (var configIdx = 0; configIdx < controller.configs.length; configIdx++) { |
|
var config = controller.configs[configIdx]; |
|
var endOfAnimation = void 0, |
|
lastTime = void 0; |
|
|
|
for (var valIdx = 0; valIdx < config.animatedValues.length; valIdx++) { |
|
var animation = config.animatedValues[valIdx]; // If an animation is done, skip, until all of them conclude |
|
|
|
if (animation.done) continue; |
|
var from = config.fromValues[valIdx]; |
|
var to = config.toValues[valIdx]; |
|
var position = animation.lastPosition; |
|
var isAnimated = to instanceof Animated; |
|
var velocity = Array.isArray(config.initialVelocity) ? config.initialVelocity[valIdx] : config.initialVelocity; |
|
if (isAnimated) to = to.getValue(); // Conclude animation if it's either immediate, or from-values match end-state |
|
|
|
if (config.immediate) { |
|
animation.setValue(to); |
|
animation.done = true; |
|
continue; |
|
} // Break animation when string values are involved |
|
|
|
|
|
if (typeof from === 'string' || typeof to === 'string') { |
|
animation.setValue(to); |
|
animation.done = true; |
|
continue; |
|
} |
|
|
|
if (config.duration !== void 0) { |
|
/** Duration easing */ |
|
position = from + config.easing((time - animation.startTime) / config.duration) * (to - from); |
|
endOfAnimation = time >= animation.startTime + config.duration; |
|
} else if (config.decay) { |
|
/** Decay easing */ |
|
position = from + velocity / (1 - 0.998) * (1 - Math.exp(-(1 - 0.998) * (time - animation.startTime))); |
|
endOfAnimation = Math.abs(animation.lastPosition - position) < 0.1; |
|
if (endOfAnimation) to = position; |
|
} else { |
|
/** Spring easing */ |
|
lastTime = animation.lastTime !== void 0 ? animation.lastTime : time; |
|
velocity = animation.lastVelocity !== void 0 ? animation.lastVelocity : config.initialVelocity; // If we lost a lot of frames just jump to the end. |
|
|
|
if (time > lastTime + 64) lastTime = time; // http://gafferongames.com/game-physics/fix-your-timestep/ |
|
|
|
var numSteps = Math.floor(time - lastTime); |
|
|
|
for (var i = 0; i < numSteps; ++i) { |
|
var force = -config.tension * (position - to); |
|
var damping = -config.friction * velocity; |
|
var acceleration = (force + damping) / config.mass; |
|
velocity = velocity + acceleration * 1 / 1000; |
|
position = position + velocity * 1 / 1000; |
|
} // Conditions for stopping the spring animation |
|
|
|
|
|
var isOvershooting = config.clamp && config.tension !== 0 ? from < to ? position > to : position < to : false; |
|
var isVelocity = Math.abs(velocity) <= config.precision; |
|
var isDisplacement = config.tension !== 0 ? Math.abs(to - position) <= config.precision : true; |
|
endOfAnimation = isOvershooting || isVelocity && isDisplacement; |
|
animation.lastVelocity = velocity; |
|
animation.lastTime = time; |
|
} // Trails aren't done until their parents conclude |
|
|
|
|
|
if (isAnimated && !config.toValues[valIdx].done) endOfAnimation = false; |
|
|
|
if (endOfAnimation) { |
|
// Ensure that we end up with a round value |
|
if (animation.value !== to) position = to; |
|
animation.done = true; |
|
} else isActive = true; |
|
|
|
animation.setValue(position); |
|
animation.lastPosition = position; |
|
} // Keep track of updated values only when necessary |
|
|
|
|
|
if (controller.props.onFrame) controller.values[config.name] = config.interpolation.getValue(); |
|
} // Update callbacks in the end of the frame |
|
|
|
|
|
if (controller.props.onFrame) controller.props.onFrame(controller.values); // Either call onEnd or next frame |
|
|
|
if (!isActive) { |
|
controllers.delete(controller); |
|
controller.stop(true); |
|
} |
|
} // Loop over as long as there are controllers ... |
|
|
|
|
|
if (controllers.size) { |
|
if (manualFrameloop) manualFrameloop();else requestFrame(update); |
|
} else { |
|
active = false; |
|
} |
|
|
|
return active; |
|
}; |
|
|
|
var start = function start(controller) { |
|
if (!controllers.has(controller)) controllers.add(controller); |
|
|
|
if (!active) { |
|
active = true; |
|
if (manualFrameloop) requestFrame(manualFrameloop);else requestFrame(update); |
|
} |
|
}; |
|
|
|
var stop = function stop(controller) { |
|
if (controllers.has(controller)) controllers.delete(controller); |
|
}; |
|
|
|
function createInterpolator(range, output, extrapolate) { |
|
if (typeof range === 'function') { |
|
return range; |
|
} |
|
|
|
if (Array.isArray(range)) { |
|
return createInterpolator({ |
|
range: range, |
|
output: output, |
|
extrapolate: extrapolate |
|
}); |
|
} |
|
|
|
if (interpolation && typeof range.output[0] === 'string') { |
|
return interpolation(range); |
|
} |
|
|
|
var config = range; |
|
var outputRange = config.output; |
|
var inputRange = config.range || [0, 1]; |
|
var extrapolateLeft = config.extrapolateLeft || config.extrapolate || 'extend'; |
|
var extrapolateRight = config.extrapolateRight || config.extrapolate || 'extend'; |
|
|
|
var easing = config.easing || function (t) { |
|
return t; |
|
}; |
|
|
|
return function (input) { |
|
var range = findRange(input, inputRange); |
|
return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight, config.map); |
|
}; |
|
} |
|
|
|
function interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight, map) { |
|
var result = map ? map(input) : input; // Extrapolate |
|
|
|
if (result < inputMin) { |
|
if (extrapolateLeft === 'identity') return result;else if (extrapolateLeft === 'clamp') result = inputMin; |
|
} |
|
|
|
if (result > inputMax) { |
|
if (extrapolateRight === 'identity') return result;else if (extrapolateRight === 'clamp') result = inputMax; |
|
} |
|
|
|
if (outputMin === outputMax) return outputMin; |
|
if (inputMin === inputMax) return input <= inputMin ? outputMin : outputMax; // Input Range |
|
|
|
if (inputMin === -Infinity) result = -result;else if (inputMax === Infinity) result = result - inputMin;else result = (result - inputMin) / (inputMax - inputMin); // Easing |
|
|
|
result = easing(result); // Output Range |
|
|
|
if (outputMin === -Infinity) result = -result;else if (outputMax === Infinity) result = result + outputMin;else result = result * (outputMax - outputMin) + outputMin; |
|
return result; |
|
} |
|
|
|
function findRange(input, inputRange) { |
|
for (var i = 1; i < inputRange.length - 1; ++i) { |
|
if (inputRange[i] >= input) break; |
|
} |
|
|
|
return i - 1; |
|
} |
|
|
|
var AnimatedInterpolation = |
|
/*#__PURE__*/ |
|
function (_AnimatedArray) { |
|
_inheritsLoose(AnimatedInterpolation, _AnimatedArray); |
|
|
|
function AnimatedInterpolation(parents, range, output, extrapolate) { |
|
var _this; |
|
|
|
_this = _AnimatedArray.call(this) || this; |
|
_this.calc = void 0; |
|
_this.payload = parents instanceof AnimatedArray && !(parents instanceof AnimatedInterpolation) ? parents.getPayload() : Array.isArray(parents) ? parents : [parents]; |
|
_this.calc = createInterpolator(range, output, extrapolate); |
|
return _this; |
|
} |
|
|
|
var _proto = AnimatedInterpolation.prototype; |
|
|
|
_proto.getValue = function getValue() { |
|
return this.calc.apply(this, this.payload.map(function (value) { |
|
return value.getValue(); |
|
})); |
|
}; |
|
|
|
_proto.updateConfig = function updateConfig(range, output, extrapolate) { |
|
this.calc = createInterpolator(range, output, extrapolate); |
|
}; |
|
|
|
_proto.interpolate = function interpolate(range, output, extrapolate) { |
|
return new AnimatedInterpolation(this, range, output, extrapolate); |
|
}; |
|
|
|
return AnimatedInterpolation; |
|
}(AnimatedArray); |
|
|
|
var interpolate$1 = function interpolate(parents, range, output) { |
|
return parents && new AnimatedInterpolation(parents, range, output); |
|
}; |
|
|
|
var config = { |
|
default: { |
|
tension: 170, |
|
friction: 26 |
|
}, |
|
gentle: { |
|
tension: 120, |
|
friction: 14 |
|
}, |
|
wobbly: { |
|
tension: 180, |
|
friction: 12 |
|
}, |
|
stiff: { |
|
tension: 210, |
|
friction: 20 |
|
}, |
|
slow: { |
|
tension: 280, |
|
friction: 60 |
|
}, |
|
molasses: { |
|
tension: 280, |
|
friction: 120 |
|
} |
|
}; |
|
|
|
/** API |
|
* useChain(references, timeSteps, timeFrame) |
|
*/ |
|
|
|
function useChain(refs, timeSteps, timeFrame) { |
|
if (timeFrame === void 0) { |
|
timeFrame = 1000; |
|
} |
|
|
|
var previous = React.useRef(); |
|
React.useEffect(function () { |
|
if (is.equ(refs, previous.current)) refs.forEach(function (_ref) { |
|
var current = _ref.current; |
|
return current && current.start(); |
|
});else if (timeSteps) { |
|
refs.forEach(function (_ref2, index) { |
|
var current = _ref2.current; |
|
|
|
if (current) { |
|
var ctrls = current.controllers; |
|
|
|
if (ctrls.length) { |
|
var t = timeFrame * timeSteps[index]; |
|
ctrls.forEach(function (ctrl) { |
|
ctrl.queue = ctrl.queue.map(function (e) { |
|
return _extends({}, e, { |
|
delay: e.delay + t |
|
}); |
|
}); |
|
ctrl.start(); |
|
}); |
|
} |
|
} |
|
}); |
|
} else refs.reduce(function (q, _ref3, rI) { |
|
var current = _ref3.current; |
|
return q = q.then(function () { |
|
return current.start(); |
|
}); |
|
}, Promise.resolve()); |
|
previous.current = refs; |
|
}); |
|
} |
|
|
|
/** |
|
* Animated works by building a directed acyclic graph of dependencies |
|
* transparently when you render your Animated components. |
|
* |
|
* new Animated.Value(0) |
|
* .interpolate() .interpolate() new Animated.Value(1) |
|
* opacity translateY scale |
|
* style transform |
|
* View#234 style |
|
* View#123 |
|
* |
|
* A) Top Down phase |
|
* When an AnimatedValue is updated, we recursively go down through this |
|
* graph in order to find leaf nodes: the views that we flag as needing |
|
* an update. |
|
* |
|
* B) Bottom Up phase |
|
* When a view is flagged as needing an update, we recursively go back up |
|
* in order to build the new value that it needs. The reason why we need |
|
* this two-phases process is to deal with composite props such as |
|
* transform which can receive values from multiple parents. |
|
*/ |
|
function addAnimatedStyles(node, styles) { |
|
if ('update' in node) { |
|
styles.add(node); |
|
} else { |
|
node.getChildren().forEach(function (child) { |
|
return addAnimatedStyles(child, styles); |
|
}); |
|
} |
|
} |
|
|
|
var AnimatedValue = |
|
/*#__PURE__*/ |
|
function (_Animated) { |
|
_inheritsLoose(AnimatedValue, _Animated); |
|
|
|
function AnimatedValue(_value) { |
|
var _this; |
|
|
|
_this = _Animated.call(this) || this; |
|
_this.animatedStyles = new Set(); |
|
_this.value = void 0; |
|
_this.startPosition = void 0; |
|
_this.lastPosition = void 0; |
|
_this.lastVelocity = void 0; |
|
_this.startTime = void 0; |
|
_this.lastTime = void 0; |
|
_this.done = false; |
|
|
|
_this.setValue = function (value, flush) { |
|
if (flush === void 0) { |
|
flush = true; |
|
} |
|
|
|
_this.value = value; |
|
if (flush) _this.flush(); |
|
}; |
|
|
|
_this.value = _value; |
|
_this.startPosition = _value; |
|
_this.lastPosition = _value; |
|
return _this; |
|
} |
|
|
|
var _proto = AnimatedValue.prototype; |
|
|
|
_proto.flush = function flush() { |
|
if (this.animatedStyles.size === 0) { |
|
addAnimatedStyles(this, this.animatedStyles); |
|
} |
|
|
|
this.animatedStyles.forEach(function (animatedStyle) { |
|
return animatedStyle.update(); |
|
}); |
|
}; |
|
|
|
_proto.clearStyles = function clearStyles() { |
|
this.animatedStyles.clear(); |
|
}; |
|
|
|
_proto.getValue = function getValue() { |
|
return this.value; |
|
}; |
|
|
|
_proto.interpolate = function interpolate(range, output, extrapolate) { |
|
return new AnimatedInterpolation(this, range, output, extrapolate); |
|
}; |
|
|
|
return AnimatedValue; |
|
}(Animated); |
|
|
|
var AnimatedValueArray = |
|
/*#__PURE__*/ |
|
function (_AnimatedArray) { |
|
_inheritsLoose(AnimatedValueArray, _AnimatedArray); |
|
|
|
function AnimatedValueArray(values) { |
|
var _this; |
|
|
|
_this = _AnimatedArray.call(this) || this; |
|
_this.payload = values.map(function (n) { |
|
return new AnimatedValue(n); |
|
}); |
|
return _this; |
|
} |
|
|
|
var _proto = AnimatedValueArray.prototype; |
|
|
|
_proto.setValue = function setValue(value, flush) { |
|
var _this2 = this; |
|
|
|
if (flush === void 0) { |
|
flush = true; |
|
} |
|
|
|
if (Array.isArray(value)) { |
|
if (value.length === this.payload.length) { |
|
value.forEach(function (v, i) { |
|
return _this2.payload[i].setValue(v, flush); |
|
}); |
|
} |
|
} else { |
|
this.payload.forEach(function (p) { |
|
return p.setValue(value, flush); |
|
}); |
|
} |
|
}; |
|
|
|
_proto.getValue = function getValue() { |
|
return this.payload.map(function (v) { |
|
return v.getValue(); |
|
}); |
|
}; |
|
|
|
_proto.interpolate = function interpolate(range, output) { |
|
return new AnimatedInterpolation(this, range, output); |
|
}; |
|
|
|
return AnimatedValueArray; |
|
}(AnimatedArray); |
|
|
|
var G = 0; |
|
|
|
var Controller = |
|
/*#__PURE__*/ |
|
function () { |
|
function Controller() { |
|
var _this = this; |
|
|
|
this.id = void 0; |
|
this.idle = true; |
|
this.hasChanged = false; |
|
this.guid = 0; |
|
this.local = 0; |
|
this.props = {}; |
|
this.merged = {}; |
|
this.animations = {}; |
|
this.interpolations = {}; |
|
this.values = {}; |
|
this.configs = []; |
|
this.listeners = []; |
|
this.queue = []; |
|
this.localQueue = void 0; |
|
|
|
this.getValues = function () { |
|
return _this.interpolations; |
|
}; |
|
|
|
this.id = G++; |
|
} |
|
/** update(props) |
|
* This function filters input props and creates an array of tasks which are executed in .start() |
|
* Each task is allowed to carry a delay, which means it can execute asnychroneously */ |
|
|
|
|
|
var _proto = Controller.prototype; |
|
|
|
_proto.update = function update$$1(args) { |
|
//this._id = n + this.id |
|
if (!args) return this; // Extract delay and the to-prop from props |
|
|
|
var _ref = interpolateTo(args), |
|
_ref$delay = _ref.delay, |
|
delay = _ref$delay === void 0 ? 0 : _ref$delay, |
|
to = _ref.to, |
|
props = _objectWithoutPropertiesLoose(_ref, ["delay", "to"]); |
|
|
|
if (is.arr(to) || is.fun(to)) { |
|
// If config is either a function or an array queue it up as is |
|
this.queue.push(_extends({}, props, { |
|
delay: delay, |
|
to: to |
|
})); |
|
} else if (to) { |
|
// Otherwise go through each key since it could be delayed individually |
|
var ops = {}; |
|
Object.entries(to).forEach(function (_ref2) { |
|
var _to; |
|
|
|
var k = _ref2[0], |
|
v = _ref2[1]; |
|
|
|
// Fetch delay and create an entry, consisting of the to-props, the delay, and basic props |
|
var entry = _extends({ |
|
to: (_to = {}, _to[k] = v, _to), |
|
delay: callProp(delay, k) |
|
}, props); |
|
|
|
var previous = ops[entry.delay] && ops[entry.delay].to; |
|
ops[entry.delay] = _extends({}, ops[entry.delay], entry, { |
|
to: _extends({}, previous, entry.to) |
|
}); |
|
}); |
|
this.queue = Object.values(ops); |
|
} // Sort queue, so that async calls go last |
|
|
|
|
|
this.queue = this.queue.sort(function (a, b) { |
|
return a.delay - b.delay; |
|
}); // Diff the reduced props immediately (they'll contain the from-prop and some config) |
|
|
|
this.diff(props); |
|
return this; |
|
} |
|
/** start(onEnd) |
|
* This function either executes a queue, if present, or starts the frameloop, which animates */ |
|
; |
|
|
|
_proto.start = function start$$1(onEnd) { |
|
var _this2 = this; |
|
|
|
// If a queue is present we must excecute it |
|
if (this.queue.length) { |
|
this.idle = false; // Updates can interrupt trailing queues, in that case we just merge values |
|
|
|
if (this.localQueue) { |
|
this.localQueue.forEach(function (_ref3) { |
|
var _ref3$from = _ref3.from, |
|
from = _ref3$from === void 0 ? {} : _ref3$from, |
|
_ref3$to = _ref3.to, |
|
to = _ref3$to === void 0 ? {} : _ref3$to; |
|
if (is.obj(from)) _this2.merged = _extends({}, from, _this2.merged); |
|
if (is.obj(to)) _this2.merged = _extends({}, _this2.merged, to); |
|
}); |
|
} // The guid helps us tracking frames, a new queue over an old one means an override |
|
// We discard async calls in that caseÍ |
|
|
|
|
|
var local = this.local = ++this.guid; |
|
var queue = this.localQueue = this.queue; |
|
this.queue = []; // Go through each entry and execute it |
|
|
|
queue.forEach(function (_ref4, index) { |
|
var delay = _ref4.delay, |
|
props = _objectWithoutPropertiesLoose(_ref4, ["delay"]); |
|
|
|
var cb = function cb(finished) { |
|
if (index === queue.length - 1 && local === _this2.guid && finished) { |
|
_this2.idle = true; |
|
if (_this2.props.onRest) _this2.props.onRest(_this2.merged); |
|
} |
|
|
|
if (onEnd) onEnd(); |
|
}; // Entries can be delayed, ansyc or immediate |
|
|
|
|
|
var async = is.arr(props.to) || is.fun(props.to); |
|
|
|
if (delay) { |
|
setTimeout(function () { |
|
if (local === _this2.guid) { |
|
if (async) _this2.runAsync(props, cb);else _this2.diff(props).start(cb); |
|
} |
|
}, delay); |
|
} else if (async) _this2.runAsync(props, cb);else _this2.diff(props).start(cb); |
|
}); |
|
} // Otherwise we kick of the frameloop |
|
else { |
|
if (is.fun(onEnd)) this.listeners.push(onEnd); |
|
if (this.props.onStart) this.props.onStart(); |
|
|
|
start(this); |
|
} |
|
|
|
return this; |
|
}; |
|
|
|
_proto.stop = function stop$$1(finished) { |
|
this.listeners.forEach(function (onEnd) { |
|
return onEnd(finished); |
|
}); |
|
this.listeners = []; |
|
return this; |
|
} |
|
/** Pause sets onEnd listeners free, but also removes the controller from the frameloop */ |
|
; |
|
|
|
_proto.pause = function pause(finished) { |
|
this.stop(true); |
|
if (finished) stop(this); |
|
return this; |
|
}; |
|
|
|
_proto.runAsync = function runAsync(_ref5, onEnd) { |
|
var _this3 = this; |
|
|
|
var delay = _ref5.delay, |
|
props = _objectWithoutPropertiesLoose(_ref5, ["delay"]); |
|
|
|
var local = this.local; // If "to" is either a function or an array it will be processed async, therefor "to" should be empty right now |
|
// If the view relies on certain values "from" has to be present |
|
|
|
var queue = Promise.resolve(undefined); |
|
|
|
if (is.arr(props.to)) { |
|
var _loop = function _loop(i) { |
|
var index = i; |
|
|
|
var fresh = _extends({}, props, interpolateTo(props.to[index])); |
|
|
|
if (is.arr(fresh.config)) fresh.config = fresh.config[index]; |
|
queue = queue.then(function () { |
|
//this.stop() |
|
if (local === _this3.guid) return new Promise(function (r) { |
|
return _this3.diff(fresh).start(r); |
|
}); |
|
}); |
|
}; |
|
|
|
for (var i = 0; i < props.to.length; i++) { |
|
_loop(i); |
|
} |
|
} else if (is.fun(props.to)) { |
|
var index = 0; |
|
var last; |
|
queue = queue.then(function () { |
|
return props.to( // next(props) |
|
function (p) { |
|
var fresh = _extends({}, props, interpolateTo(p)); |
|
|
|
if (is.arr(fresh.config)) fresh.config = fresh.config[index]; |
|
index++; //this.stop() |
|
|
|
if (local === _this3.guid) return last = new Promise(function (r) { |
|
return _this3.diff(fresh).start(r); |
|
}); |
|
return; |
|
}, // cancel() |
|
function (finished) { |
|
if (finished === void 0) { |
|
finished = true; |
|
} |
|
|
|
return _this3.stop(finished); |
|
}).then(function () { |
|
return last; |
|
}); |
|
}); |
|
} |
|
|
|
queue.then(onEnd); |
|
}; |
|
|
|
_proto.diff = function diff(props) { |
|
var _this4 = this; |
|
|
|
this.props = _extends({}, this.props, props); |
|
var _this$props = this.props, |
|
_this$props$from = _this$props.from, |
|
from = _this$props$from === void 0 ? {} : _this$props$from, |
|
_this$props$to = _this$props.to, |
|
to = _this$props$to === void 0 ? {} : _this$props$to, |
|
_this$props$config = _this$props.config, |
|
config = _this$props$config === void 0 ? {} : _this$props$config, |
|
reverse = _this$props.reverse, |
|
attach = _this$props.attach, |
|
reset = _this$props.reset, |
|
immediate = _this$props.immediate; // Reverse values when requested |
|
|
|
if (reverse) { |
|
var _ref6 = [to, from]; |
|
from = _ref6[0]; |
|
to = _ref6[1]; |
|
} // This will collect all props that were ever set, reset merged props when necessary |
|
|
|
|
|
this.merged = _extends({}, from, this.merged, to); |
|
this.hasChanged = false; // Attachment handling, trailed springs can "attach" themselves to a previous spring |
|
|
|
var target = attach && attach(this); // Reduces input { name: value } pairs into animated values |
|
|
|
this.animations = Object.entries(this.merged).reduce(function (acc, _ref7) { |
|
var name = _ref7[0], |
|
value = _ref7[1]; |
|
// Issue cached entries, except on reset |
|
var entry = acc[name] || {}; // Figure out what the value is supposed to be |
|
|
|
var isNumber = is.num(value); |
|
var isString = is.str(value) && !value.startsWith('#') && !/\d/.test(value) && !colorNames[value]; |
|
var isArray = is.arr(value); |
|
var isInterpolation = !isNumber && !isArray && !isString; |
|
var fromValue = !is.und(from[name]) ? from[name] : value; |
|
var toValue = isNumber || isArray ? value : isString ? value : 1; |
|
var toConfig = callProp(config, name); |
|
if (target) toValue = target.animations[name].parent; |
|
var parent = entry.parent, |
|
interpolation$$1 = entry.interpolation, |
|
toValues = toArray(target ? toValue.getPayload() : toValue), |
|
animatedValues; |
|
var newValue = value; |
|
if (isInterpolation) newValue = interpolation({ |
|
range: [0, 1], |
|
output: [value, value] |
|
})(1); |
|
var currentValue = interpolation$$1 && interpolation$$1.getValue(); // Change detection flags |
|
|
|
var isFirst = is.und(parent); |
|
var isActive = !isFirst && entry.animatedValues.some(function (v) { |
|
return !v.done; |
|
}); |
|
var currentValueDiffersFromGoal = !is.equ(newValue, currentValue); |
|
var hasNewGoal = !is.equ(newValue, entry.previous); |
|
var hasNewConfig = !is.equ(toConfig, entry.config); // Change animation props when props indicate a new goal (new value differs from previous one) |
|
// and current values differ from it. Config changes trigger a new update as well (though probably shouldn't?) |
|
|
|
if (reset || hasNewGoal && currentValueDiffersFromGoal || hasNewConfig) { |
|
var _extends2; |
|
|
|
// Convert regular values into animated values, ALWAYS re-use if possible |
|
if (isNumber || isString) parent = interpolation$$1 = entry.parent || new AnimatedValue(fromValue);else if (isArray) parent = interpolation$$1 = entry.parent || new AnimatedValueArray(fromValue);else if (isInterpolation) { |
|
var prev = entry.interpolation && entry.interpolation.calc(entry.parent.value); |
|
prev = prev !== void 0 && !reset ? prev : fromValue; |
|
|
|
if (entry.parent) { |
|
parent = entry.parent; |
|
parent.setValue(0, false); |
|
} else parent = new AnimatedValue(0); |
|
|
|
var range = { |
|
output: [prev, value] |
|
}; |
|
|
|
if (entry.interpolation) { |
|
interpolation$$1 = entry.interpolation; |
|
entry.interpolation.updateConfig(range); |
|
} else interpolation$$1 = parent.interpolate(range); |
|
} |
|
toValues = toArray(target ? toValue.getPayload() : toValue); |
|
animatedValues = toArray(parent.getPayload()); |
|
if (reset && !isInterpolation) parent.setValue(fromValue, false); |
|
_this4.hasChanged = true; // Reset animated values |
|
|
|
animatedValues.forEach(function (value) { |
|
value.startPosition = value.value; |
|
value.lastPosition = value.value; |
|
value.lastVelocity = isActive ? value.lastVelocity : undefined; |
|
value.lastTime = isActive ? value.lastTime : undefined; |
|
value.startTime = now(); |
|
value.done = false; |
|
value.animatedStyles.clear(); |
|
}); // Set immediate values |
|
|
|
if (callProp(immediate, name)) { |
|
parent.setValue(isInterpolation ? toValue : value, false); |
|
} |
|
|
|
return _extends({}, acc, (_extends2 = {}, _extends2[name] = _extends({}, entry, { |
|
name: name, |
|
parent: parent, |
|
interpolation: interpolation$$1, |
|
animatedValues: animatedValues, |
|
toValues: toValues, |
|
previous: newValue, |
|
config: toConfig, |
|
fromValues: toArray(parent.getValue()), |
|
immediate: callProp(immediate, name), |
|
initialVelocity: withDefault(toConfig.velocity, 0), |
|
clamp: withDefault(toConfig.clamp, false), |
|
precision: withDefault(toConfig.precision, 0.01), |
|
tension: withDefault(toConfig.tension, 170), |
|
friction: withDefault(toConfig.friction, 26), |
|
mass: withDefault(toConfig.mass, 1), |
|
duration: toConfig.duration, |
|
easing: withDefault(toConfig.easing, function (t) { |
|
return t; |
|
}), |
|
decay: toConfig.decay |
|
}), _extends2)); |
|
} else { |
|
if (!currentValueDiffersFromGoal) { |
|
var _extends3; |
|
|
|
// So ... the current target value (newValue) appears to be different from the previous value, |
|
// which normally constitutes an update, but the actual value (currentValue) matches the target! |
|
// In order to resolve this without causing an animation update we silently flag the animation as done, |
|
// which it technically is. Interpolations also needs a config update with their target set to 1. |
|
if (isInterpolation) { |
|
parent.setValue(1, false); |
|
interpolation$$1.updateConfig({ |
|
output: [newValue, newValue] |
|
}); |
|
} |
|
|
|
parent.done = true; |
|
_this4.hasChanged = true; |
|
return _extends({}, acc, (_extends3 = {}, _extends3[name] = _extends({}, acc[name], { |
|
previous: newValue |
|
}), _extends3)); |
|
} |
|
|
|
return acc; |
|
} |
|
}, this.animations); |
|
|
|
if (this.hasChanged) { |
|
// Make animations available to frameloop |
|
this.configs = Object.values(this.animations); |
|
this.values = {}; |
|
this.interpolations = {}; |
|
|
|
for (var key in this.animations) { |
|
this.interpolations[key] = this.animations[key].interpolation; |
|
this.values[key] = this.animations[key].interpolation.getValue(); |
|
} |
|
} |
|
|
|
return this; |
|
}; |
|
|
|
_proto.destroy = function destroy() { |
|
this.stop(); |
|
this.props = {}; |
|
this.merged = {}; |
|
this.animations = {}; |
|
this.interpolations = {}; |
|
this.values = {}; |
|
this.configs = []; |
|
this.local = 0; |
|
}; |
|
|
|
return Controller; |
|
}(); |
|
|
|
/** API |
|
* const props = useSprings(number, [{ ... }, { ... }, ...]) |
|
* const [props, set] = useSprings(number, (i, controller) => ({ ... })) |
|
*/ |
|
|
|
var useSprings = function useSprings(length, props) { |
|
var mounted = React.useRef(false); |
|
var ctrl = React.useRef(); |
|
var isFn = is.fun(props); // The controller maintains the animation values, starts and stops animations |
|
|
|
var _useMemo = React.useMemo(function () { |
|
// Remove old controllers |
|
if (ctrl.current) { |
|
ctrl.current.map(function (c) { |
|
return c.destroy(); |
|
}); |
|
ctrl.current = undefined; |
|
} |
|
|
|
var ref; |
|
return [new Array(length).fill().map(function (_, i) { |
|
var ctrl = new Controller(); |
|
var newProps = isFn ? callProp(props, i, ctrl) : props[i]; |
|
if (i === 0) ref = newProps.ref; |
|
ctrl.update(newProps); |
|
if (!ref) ctrl.start(); |
|
return ctrl; |
|
}), ref]; |
|
}, [length]), |
|
controllers = _useMemo[0], |
|
ref = _useMemo[1]; |
|
|
|
ctrl.current = controllers; // The hooks reference api gets defined here ... |
|
|
|
var api = React.useImperativeHandle(ref, function () { |
|
return { |
|
start: function start() { |
|
return Promise.all(ctrl.current.map(function (c) { |
|
return new Promise(function (r) { |
|
return c.start(r); |
|
}); |
|
})); |
|
}, |
|
stop: function stop(finished) { |
|
return ctrl.current.forEach(function (c) { |
|
return c.stop(finished); |
|
}); |
|
}, |
|
|
|
get controllers() { |
|
return ctrl.current; |
|
} |
|
|
|
}; |
|
}); // This function updates the controllers |
|
|
|
var updateCtrl = React.useMemo(function () { |
|
return function (updateProps) { |
|
return ctrl.current.map(function (c, i) { |
|
c.update(isFn ? callProp(updateProps, i, c) : updateProps[i]); |
|
if (!ref) c.start(); |
|
}); |
|
}; |
|
}, [length]); // Update controller if props aren't functional |
|
|
|
React.useEffect(function () { |
|
if (mounted.current) { |
|
if (!isFn) updateCtrl(props); |
|
} else if (!ref) ctrl.current.forEach(function (c) { |
|
return c.start(); |
|
}); |
|
}); // Update mounted flag and destroy controller on unmount |
|
|
|
React.useEffect(function () { |
|
return mounted.current = true, function () { |
|
return ctrl.current.forEach(function (c) { |
|
return c.destroy(); |
|
}); |
|
}; |
|
}, []); // Return animated props, or, anim-props + the update-setter above |
|
|
|
var propValues = ctrl.current.map(function (c) { |
|
return c.getValues(); |
|
}); |
|
return isFn ? [propValues, updateCtrl, function (finished) { |
|
return ctrl.current.forEach(function (c) { |
|
return c.pause(finished); |
|
}); |
|
}] : propValues; |
|
}; |
|
|
|
/** API |
|
* const props = useSpring({ ... }) |
|
* const [props, set] = useSpring(() => ({ ... })) |
|
*/ |
|
|
|
var useSpring = function useSpring(props) { |
|
var isFn = is.fun(props); |
|
|
|
var _useSprings = useSprings(1, isFn ? props : [props]), |
|
result = _useSprings[0], |
|
set = _useSprings[1], |
|
pause = _useSprings[2]; |
|
|
|
return isFn ? [result[0], set, pause] : result; |
|
}; |
|
|
|
/** API |
|
* const trails = useTrail(number, { ... }) |
|
* const [trails, set] = useTrail(number, () => ({ ... })) |
|
*/ |
|
|
|
var useTrail = function useTrail(length, props) { |
|
var mounted = React.useRef(false); |
|
var isFn = is.fun(props); |
|
var updateProps = callProp(props); |
|
var instances = React.useRef(); |
|
|
|
var _useSprings = useSprings(length, function (i, ctrl) { |
|
if (i === 0) instances.current = []; |
|
instances.current.push(ctrl); |
|
return _extends({}, updateProps, { |
|
config: callProp(updateProps.config, i), |
|
attach: i > 0 && function () { |
|
return instances.current[i - 1]; |
|
} |
|
}); |
|
}), |
|
result = _useSprings[0], |
|
set = _useSprings[1], |
|
pause = _useSprings[2]; // Set up function to update controller |
|
|
|
|
|
var updateCtrl = React.useMemo(function () { |
|
return function (props) { |
|
return set(function (i, ctrl) { |
|
var last = props.reverse ? i === 0 : length - 1 === i; |
|
var attachIdx = props.reverse ? i + 1 : i - 1; |
|
var attachController = instances.current[attachIdx]; |
|
return _extends({}, props, { |
|
config: callProp(props.config || updateProps.config, i), |
|
attach: attachController && function () { |
|
return attachController; |
|
} |
|
}); |
|
}); |
|
}; |
|
}, [length, updateProps.reverse]); // Update controller if props aren't functional |
|
|
|
React.useEffect(function () { |
|
return void (mounted.current && !isFn && updateCtrl(props)); |
|
}); // Update mounted flag and destroy controller on unmount |
|
|
|
React.useEffect(function () { |
|
return void (mounted.current = true); |
|
}, []); |
|
return isFn ? [result, updateCtrl, pause] : result; |
|
}; |
|
|
|
/** API |
|
* const transitions = useTransition(items, itemKeys, { ... }) |
|
* const [transitions, update] = useTransition(items, itemKeys, () => ({ ... })) |
|
*/ |
|
|
|
var guid = 0; |
|
var ENTER = 'enter'; |
|
var LEAVE = 'leave'; |
|
var UPDATE = 'update'; |
|
|
|
var mapKeys = function mapKeys(items, keys) { |
|
return (typeof keys === 'function' ? items.map(keys) : toArray(keys)).map(String); |
|
}; |
|
|
|
var get = function get(props) { |
|
var items = props.items, |
|
_props$keys = props.keys, |
|
keys = _props$keys === void 0 ? function (item) { |
|
return item; |
|
} : _props$keys, |
|
rest = _objectWithoutPropertiesLoose(props, ["items", "keys"]); |
|
|
|
items = toArray(items !== void 0 ? items : null); |
|
return _extends({ |
|
items: items, |
|
keys: mapKeys(items, keys) |
|
}, rest); |
|
}; |
|
|
|
function useTransition(input, keyTransform, config) { |
|
var props = _extends({ |
|
items: input, |
|
keys: keyTransform || function (i) { |
|
return i; |
|
} |
|
}, config); |
|
|
|
var _get = get(props), |
|
_get$lazy = _get.lazy, |
|
lazy = _get$lazy === void 0 ? false : _get$lazy, |
|
_get$unique = _get.unique, |
|
_get$reset = _get.reset, |
|
reset = _get$reset === void 0 ? false : _get$reset, |
|
enter = _get.enter, |
|
leave = _get.leave, |
|
update = _get.update, |
|
onDestroyed = _get.onDestroyed, |
|
keys = _get.keys, |
|
items = _get.items, |
|
onFrame = _get.onFrame, |
|
_onRest = _get.onRest, |
|
onStart = _get.onStart, |
|
ref = _get.ref, |
|
extra = _objectWithoutPropertiesLoose(_get, ["lazy", "unique", "reset", "enter", "leave", "update", "onDestroyed", "keys", "items", "onFrame", "onRest", "onStart", "ref"]); |
|
|
|
var forceUpdate = useForceUpdate(); |
|
var mounted = React.useRef(false); |
|
var state = React.useRef({ |
|
mounted: false, |
|
first: true, |
|
deleted: [], |
|
current: {}, |
|
transitions: [], |
|
prevProps: {}, |
|
paused: !!props.ref, |
|
instances: !mounted.current && new Map(), |
|
forceUpdate: forceUpdate |
|
}); |
|
React.useImperativeHandle(props.ref, function () { |
|
return { |
|
start: function start() { |
|
return Promise.all(Array.from(state.current.instances).map(function (_ref) { |
|
var c = _ref[1]; |
|
return new Promise(function (r) { |
|
return c.start(r); |
|
}); |
|
})); |
|
}, |
|
stop: function stop(finished) { |
|
return Array.from(state.current.instances).forEach(function (_ref2) { |
|
var c = _ref2[1]; |
|
return c.stop(finished); |
|
}); |
|
}, |
|
|
|
get controllers() { |
|
return Array.from(state.current.instances).map(function (_ref3) { |
|
var c = _ref3[1]; |
|
return c; |
|
}); |
|
} |
|
|
|
}; |
|
}); // Update state |
|
|
|
state.current = diffItems(state.current, props); |
|
|
|
if (state.current.changed) { |
|
// Update state |
|
state.current.transitions.forEach(function (transition) { |
|
var slot = transition.slot, |
|
from = transition.from, |
|
to = transition.to, |
|
config = transition.config, |
|
trail = transition.trail, |
|
key = transition.key, |
|
item = transition.item; |
|
if (!state.current.instances.has(key)) state.current.instances.set(key, new Controller()); // update the map object |
|
|
|
var ctrl = state.current.instances.get(key); |
|
|
|
var newProps = _extends({}, extra, { |
|
to: to, |
|
from: from, |
|
config: config, |
|
ref: ref, |
|
onRest: function onRest(values) { |
|
if (state.current.mounted) { |
|
if (transition.destroyed) { |
|
// If no ref is given delete destroyed items immediately |
|
if (!ref && !lazy) cleanUp(state, key); |
|
if (onDestroyed) onDestroyed(item); |
|
} // A transition comes to rest once all its springs conclude |
|
|
|
|
|
var curInstances = Array.from(state.current.instances); |
|
var active = curInstances.some(function (_ref4) { |
|
var c = _ref4[1]; |
|
return !c.idle; |
|
}); |
|
if (!active && (ref || lazy) && state.current.deleted.length > 0) cleanUp(state); |
|
if (_onRest) _onRest(item, slot, values); |
|
} |
|
}, |
|
onStart: onStart && function () { |
|
return onStart(item, slot); |
|
}, |
|
onFrame: onFrame && function (values) { |
|
return onFrame(item, slot, values); |
|
}, |
|
delay: trail, |
|
reset: reset && slot === ENTER // Update controller |
|
|
|
}); |
|
|
|
ctrl.update(newProps); |
|
if (!state.current.paused) ctrl.start(); |
|
}); |
|
} |
|
|
|
React.useEffect(function () { |
|
state.current.mounted = mounted.current = true; |
|
return function () { |
|
state.current.mounted = mounted.current = false; |
|
Array.from(state.current.instances).map(function (_ref5) { |
|
var c = _ref5[1]; |
|
return c.destroy(); |
|
}); |
|
state.current.instances.clear(); |
|
}; |
|
}, []); |
|
return state.current.transitions.map(function (_ref6) { |
|
var item = _ref6.item, |
|
slot = _ref6.slot, |
|
key = _ref6.key; |
|
return { |
|
item: item, |
|
key: key, |
|
state: slot, |
|
props: state.current.instances.get(key).getValues() |
|
}; |
|
}); |
|
} |
|
|
|
function cleanUp(state, filterKey) { |
|
var deleted = state.current.deleted; |
|
|
|
var _loop = function _loop() { |
|
if (_isArray) { |
|
if (_i >= _iterator.length) return "break"; |
|
_ref8 = _iterator[_i++]; |
|
} else { |
|
_i = _iterator.next(); |
|
if (_i.done) return "break"; |
|
_ref8 = _i.value; |
|
} |
|
|
|
var _ref7 = _ref8; |
|
var key = _ref7.key; |
|
|
|
var filter = function filter(t) { |
|
return t.key !== key; |
|
}; |
|
|
|
if (is.und(filterKey) || filterKey === key) { |
|
state.current.instances.delete(key); |
|
state.current.transitions = state.current.transitions.filter(filter); |
|
state.current.deleted = state.current.deleted.filter(filter); |
|
} |
|
}; |
|
|
|
for (var _iterator = deleted, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { |
|
var _ref8; |
|
|
|
var _ret = _loop(); |
|
|
|
if (_ret === "break") break; |
|
} |
|
|
|
state.current.forceUpdate(); |
|
} |
|
|
|
function diffItems(_ref9, props) { |
|
var first = _ref9.first, |
|
prevProps = _ref9.prevProps, |
|
state = _objectWithoutPropertiesLoose(_ref9, ["first", "prevProps"]); |
|
|
|
var _get2 = get(props), |
|
items = _get2.items, |
|
keys = _get2.keys, |
|
initial = _get2.initial, |
|
from = _get2.from, |
|
enter = _get2.enter, |
|
leave = _get2.leave, |
|
update = _get2.update, |
|
_get2$trail = _get2.trail, |
|
trail = _get2$trail === void 0 ? 0 : _get2$trail, |
|
unique = _get2.unique, |
|
config = _get2.config, |
|
_get2$order = _get2.order, |
|
order = _get2$order === void 0 ? [ENTER, LEAVE, UPDATE] : _get2$order; |
|
|
|
var _get3 = get(prevProps), |
|
_keys = _get3.keys, |
|
_items = _get3.items; |
|
|
|
var current = _extends({}, state.current); |
|
|
|
var deleted = [].concat(state.deleted); // Compare next keys with current keys |
|
|
|
var currentKeys = Object.keys(current); |
|
var currentSet = new Set(currentKeys); |
|
var nextSet = new Set(keys); |
|
var added = keys.filter(function (item) { |
|
return !currentSet.has(item); |
|
}); |
|
var removed = state.transitions.filter(function (item) { |
|
return !item.destroyed && !nextSet.has(item.originalKey); |
|
}).map(function (i) { |
|
return i.originalKey; |
|
}); |
|
var updated = keys.filter(function (item) { |
|
return currentSet.has(item); |
|
}); |
|
var delay = -trail; |
|
|
|
while (order.length) { |
|
var changeType = order.shift(); |
|
|
|
switch (changeType) { |
|
case ENTER: |
|
{ |
|
added.forEach(function (key, index) { |
|
// In unique mode, remove fading out transitions if their key comes in again |
|
if (unique && deleted.find(function (d) { |
|
return d.originalKey === key; |
|
})) deleted = deleted.filter(function (t) { |
|
return t.originalKey !== key; |
|
}); |
|
var keyIndex = keys.indexOf(key); |
|
var item = items[keyIndex]; |
|
var slot = first && initial !== void 0 ? 'initial' : ENTER; |
|
current[key] = { |
|
slot: slot, |
|
originalKey: key, |
|
key: unique ? String(key) : guid++, |
|
item: item, |
|
trail: delay = delay + trail, |
|
config: callProp(config, item, slot), |
|
from: callProp(first ? initial !== void 0 ? initial || {} : from : from, item), |
|
to: callProp(enter, item) |
|
}; |
|
}); |
|
break; |
|
} |
|
|
|
case LEAVE: |
|
{ |
|
removed.forEach(function (key) { |
|
var keyIndex = _keys.indexOf(key); |
|
|
|
var item = _items[keyIndex]; |
|
var slot = LEAVE; |
|
deleted.unshift(_extends({}, current[key], { |
|
slot: slot, |
|
destroyed: true, |
|
left: _keys[Math.max(0, keyIndex - 1)], |
|
right: _keys[Math.min(_keys.length, keyIndex + 1)], |
|
trail: delay = delay + trail, |
|
config: callProp(config, item, slot), |
|
to: callProp(leave, item) |
|
})); |
|
delete current[key]; |
|
}); |
|
break; |
|
} |
|
|
|
case UPDATE: |
|
{ |
|
updated.forEach(function (key) { |
|
var keyIndex = keys.indexOf(key); |
|
var item = items[keyIndex]; |
|
var slot = UPDATE; |
|
current[key] = _extends({}, current[key], { |
|
item: item, |
|
slot: slot, |
|
trail: delay = delay + trail, |
|
config: callProp(config, item, slot), |
|
to: callProp(update, item) |
|
}); |
|
}); |
|
break; |
|
} |
|
} |
|
} |
|
|
|
var out = keys.map(function (key) { |
|
return current[key]; |
|
}); // This tries to restore order for deleted items by finding their last known siblings |
|
// only using the left sibling to keep order placement consistent for all deleted items |
|
|
|
deleted.forEach(function (_ref10) { |
|
var left = _ref10.left, |
|
right = _ref10.right, |
|
item = _objectWithoutPropertiesLoose(_ref10, ["left", "right"]); |
|
|
|
var pos; // Was it the element on the left, if yes, move there ... |
|
|
|
if ((pos = out.findIndex(function (t) { |
|
return t.originalKey === left; |
|
})) !== -1) pos += 1; // And if nothing else helps, move it to the start ¯\_(ツ)_/¯ |
|
|
|
pos = Math.max(0, pos); |
|
out = [].concat(out.slice(0, pos), [item], out.slice(pos)); |
|
}); |
|
return _extends({}, state, { |
|
changed: added.length || removed.length || updated.length, |
|
first: first && added.length === 0, |
|
transitions: out, |
|
current: current, |
|
deleted: deleted, |
|
prevProps: props |
|
}); |
|
} |
|
|
|
var AnimatedStyle = |
|
/*#__PURE__*/ |
|
function (_AnimatedObject) { |
|
_inheritsLoose(AnimatedStyle, _AnimatedObject); |
|
|
|
function AnimatedStyle(style) { |
|
var _this; |
|
|
|
if (style === void 0) { |
|
style = {}; |
|
} |
|
|
|
_this = _AnimatedObject.call(this) || this; |
|
|
|
if (style.transform && !(style.transform instanceof Animated)) { |
|
style = applyAnimatedValues.transform(style); |
|
} |
|
|
|
_this.payload = style; |
|
return _this; |
|
} |
|
|
|
return AnimatedStyle; |
|
}(AnimatedObject); |
|
|
|
// http://www.w3.org/TR/css3-color/#svg-color |
|
var colors = { |
|
transparent: 0x00000000, |
|
aliceblue: 0xf0f8ffff, |
|
antiquewhite: 0xfaebd7ff, |
|
aqua: 0x00ffffff, |
|
aquamarine: 0x7fffd4ff, |
|
azure: 0xf0ffffff, |
|
beige: 0xf5f5dcff, |
|
bisque: 0xffe4c4ff, |
|
black: 0x000000ff, |
|
blanchedalmond: 0xffebcdff, |
|
blue: 0x0000ffff, |
|
blueviolet: 0x8a2be2ff, |
|
brown: 0xa52a2aff, |
|
burlywood: 0xdeb887ff, |
|
burntsienna: 0xea7e5dff, |
|
cadetblue: 0x5f9ea0ff, |
|
chartreuse: 0x7fff00ff, |
|
chocolate: 0xd2691eff, |
|
coral: 0xff7f50ff, |
|
cornflowerblue: 0x6495edff, |
|
cornsilk: 0xfff8dcff, |
|
crimson: 0xdc143cff, |
|
cyan: 0x00ffffff, |
|
darkblue: 0x00008bff, |
|
darkcyan: 0x008b8bff, |
|
darkgoldenrod: 0xb8860bff, |
|
darkgray: 0xa9a9a9ff, |
|
darkgreen: 0x006400ff, |
|
darkgrey: 0xa9a9a9ff, |
|
darkkhaki: 0xbdb76bff, |
|
darkmagenta: 0x8b008bff, |
|
darkolivegreen: 0x556b2fff, |
|
darkorange: 0xff8c00ff, |
|
darkorchid: 0x9932ccff, |
|
darkred: 0x8b0000ff, |
|
darksalmon: 0xe9967aff, |
|
darkseagreen: 0x8fbc8fff, |
|
darkslateblue: 0x483d8bff, |
|
darkslategray: 0x2f4f4fff, |
|
darkslategrey: 0x2f4f4fff, |
|
darkturquoise: 0x00ced1ff, |
|
darkviolet: 0x9400d3ff, |
|
deeppink: 0xff1493ff, |
|
deepskyblue: 0x00bfffff, |
|
dimgray: 0x696969ff, |
|
dimgrey: 0x696969ff, |
|
dodgerblue: 0x1e90ffff, |
|
firebrick: 0xb22222ff, |
|
floralwhite: 0xfffaf0ff, |
|
forestgreen: 0x228b22ff, |
|
fuchsia: 0xff00ffff, |
|
gainsboro: 0xdcdcdcff, |
|
ghostwhite: 0xf8f8ffff, |
|
gold: 0xffd700ff, |
|
goldenrod: 0xdaa520ff, |
|
gray: 0x808080ff, |
|
green: 0x008000ff, |
|
greenyellow: 0xadff2fff, |
|
grey: 0x808080ff, |
|
honeydew: 0xf0fff0ff, |
|
hotpink: 0xff69b4ff, |
|
indianred: 0xcd5c5cff, |
|
indigo: 0x4b0082ff, |
|
ivory: 0xfffff0ff, |
|
khaki: 0xf0e68cff, |
|
lavender: 0xe6e6faff, |
|
lavenderblush: 0xfff0f5ff, |
|
lawngreen: 0x7cfc00ff, |
|
lemonchiffon: 0xfffacdff, |
|
lightblue: 0xadd8e6ff, |
|
lightcoral: 0xf08080ff, |
|
lightcyan: 0xe0ffffff, |
|
lightgoldenrodyellow: 0xfafad2ff, |
|
lightgray: 0xd3d3d3ff, |
|
lightgreen: 0x90ee90ff, |
|
lightgrey: 0xd3d3d3ff, |
|
lightpink: 0xffb6c1ff, |
|
lightsalmon: 0xffa07aff, |
|
lightseagreen: 0x20b2aaff, |
|
lightskyblue: 0x87cefaff, |
|
lightslategray: 0x778899ff, |
|
lightslategrey: 0x778899ff, |
|
lightsteelblue: 0xb0c4deff, |
|
lightyellow: 0xffffe0ff, |
|
lime: 0x00ff00ff, |
|
limegreen: 0x32cd32ff, |
|
linen: 0xfaf0e6ff, |
|
magenta: 0xff00ffff, |
|
maroon: 0x800000ff, |
|
mediumaquamarine: 0x66cdaaff, |
|
mediumblue: 0x0000cdff, |
|
mediumorchid: 0xba55d3ff, |
|
mediumpurple: 0x9370dbff, |
|
mediumseagreen: 0x3cb371ff, |
|
mediumslateblue: 0x7b68eeff, |
|
mediumspringgreen: 0x00fa9aff, |
|
mediumturquoise: 0x48d1ccff, |
|
mediumvioletred: 0xc71585ff, |
|
midnightblue: 0x191970ff, |
|
mintcream: 0xf5fffaff, |
|
mistyrose: 0xffe4e1ff, |
|
moccasin: 0xffe4b5ff, |
|
navajowhite: 0xffdeadff, |
|
navy: 0x000080ff, |
|
oldlace: 0xfdf5e6ff, |
|
olive: 0x808000ff, |
|
olivedrab: 0x6b8e23ff, |
|
orange: 0xffa500ff, |
|
orangered: 0xff4500ff, |
|
orchid: 0xda70d6ff, |
|
palegoldenrod: 0xeee8aaff, |
|
palegreen: 0x98fb98ff, |
|
paleturquoise: 0xafeeeeff, |
|
palevioletred: 0xdb7093ff, |
|
papayawhip: 0xffefd5ff, |
|
peachpuff: 0xffdab9ff, |
|
peru: 0xcd853fff, |
|
pink: 0xffc0cbff, |
|
plum: 0xdda0ddff, |
|
powderblue: 0xb0e0e6ff, |
|
purple: 0x800080ff, |
|
rebeccapurple: 0x663399ff, |
|
red: 0xff0000ff, |
|
rosybrown: 0xbc8f8fff, |
|
royalblue: 0x4169e1ff, |
|
saddlebrown: 0x8b4513ff, |
|
salmon: 0xfa8072ff, |
|
sandybrown: 0xf4a460ff, |
|
seagreen: 0x2e8b57ff, |
|
seashell: 0xfff5eeff, |
|
sienna: 0xa0522dff, |
|
silver: 0xc0c0c0ff, |
|
skyblue: 0x87ceebff, |
|
slateblue: 0x6a5acdff, |
|
slategray: 0x708090ff, |
|
slategrey: 0x708090ff, |
|
snow: 0xfffafaff, |
|
springgreen: 0x00ff7fff, |
|
steelblue: 0x4682b4ff, |
|
tan: 0xd2b48cff, |
|
teal: 0x008080ff, |
|
thistle: 0xd8bfd8ff, |
|
tomato: 0xff6347ff, |
|
turquoise: 0x40e0d0ff, |
|
violet: 0xee82eeff, |
|
wheat: 0xf5deb3ff, |
|
white: 0xffffffff, |
|
whitesmoke: 0xf5f5f5ff, |
|
yellow: 0xffff00ff, |
|
yellowgreen: 0x9acd32ff |
|
}; |
|
|
|
// const INTEGER = '[-+]?\\d+'; |
|
var NUMBER = '[-+]?\\d*\\.?\\d+'; |
|
var PERCENTAGE = NUMBER + '%'; |
|
|
|
function call() { |
|
for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) { |
|
parts[_key] = arguments[_key]; |
|
} |
|
|
|
return '\\(\\s*(' + parts.join(')\\s*,\\s*(') + ')\\s*\\)'; |
|
} |
|
|
|
var rgb = new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER)); |
|
var rgba = new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER)); |
|
var hsl = new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE)); |
|
var hsla = new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER)); |
|
var hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/; |
|
var hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/; |
|
var hex6 = /^#([0-9a-fA-F]{6})$/; |
|
var hex8 = /^#([0-9a-fA-F]{8})$/; |
|
|
|
/* |
|
https://github.com/react-community/normalize-css-color |
|
|
|
BSD 3-Clause License |
|
|
|
Copyright (c) 2016, React Community |
|
All rights reserved. |
|
|
|
Redistribution and use in source and binary forms, with or without |
|
modification, are permitted provided that the following conditions are met: |
|
|
|
* Redistributions of source code must retain the above copyright notice, this |
|
list of conditions and the following disclaimer. |
|
|
|
* Redistributions in binary form must reproduce the above copyright notice, |
|
this list of conditions and the following disclaimer in the documentation |
|
and/or other materials provided with the distribution. |
|
|
|
* Neither the name of the copyright holder nor the names of its |
|
contributors may be used to endorse or promote products derived from |
|
this software without specific prior written permission. |
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
|
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
|
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
|
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
*/ |
|
function normalizeColor(color) { |
|
var match; |
|
|
|
if (typeof color === 'number') { |
|
return color >>> 0 === color && color >= 0 && color <= 0xffffffff ? color : null; |
|
} // Ordered based on occurrences on Facebook codebase |
|
|
|
|
|
if (match = hex6.exec(color)) return parseInt(match[1] + 'ff', 16) >>> 0; |
|
if (colors.hasOwnProperty(color)) return colors[color]; |
|
|
|
if (match = rgb.exec(color)) { |
|
return (parse255(match[1]) << 24 | // r |
|
parse255(match[2]) << 16 | // g |
|
parse255(match[3]) << 8 | // b |
|
0x000000ff) >>> // a |
|
0; |
|
} |
|
|
|
if (match = rgba.exec(color)) { |
|
return (parse255(match[1]) << 24 | // r |
|
parse255(match[2]) << 16 | // g |
|
parse255(match[3]) << 8 | // b |
|
parse1(match[4])) >>> // a |
|
0; |
|
} |
|
|
|
if (match = hex3.exec(color)) { |
|
return parseInt(match[1] + match[1] + // r |
|
match[2] + match[2] + // g |
|
match[3] + match[3] + // b |
|
'ff', // a |
|
16) >>> 0; |
|
} // https://drafts.csswg.org/css-color-4/#hex-notation |
|
|
|
|
|
if (match = hex8.exec(color)) return parseInt(match[1], 16) >>> 0; |
|
|
|
if (match = hex4.exec(color)) { |
|
return parseInt(match[1] + match[1] + // r |
|
match[2] + match[2] + // g |
|
match[3] + match[3] + // b |
|
match[4] + match[4], // a |
|
16) >>> 0; |
|
} |
|
|
|
if (match = hsl.exec(color)) { |
|
return (hslToRgb(parse360(match[1]), // h |
|
parsePercentage(match[2]), // s |
|
parsePercentage(match[3]) // l |
|
) | 0x000000ff) >>> // a |
|
0; |
|
} |
|
|
|
if (match = hsla.exec(color)) { |
|
return (hslToRgb(parse360(match[1]), // h |
|
parsePercentage(match[2]), // s |
|
parsePercentage(match[3]) // l |
|
) | parse1(match[4])) >>> // a |
|
0; |
|
} |
|
|
|
return null; |
|
} |
|
|
|
function hue2rgb(p, q, t) { |
|
if (t < 0) t += 1; |
|
if (t > 1) t -= 1; |
|
if (t < 1 / 6) return p + (q - p) * 6 * t; |
|
if (t < 1 / 2) return q; |
|
if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6; |
|
return p; |
|
} |
|
|
|
function hslToRgb(h, s, l) { |
|
var q = l < 0.5 ? l * (1 + s) : l + s - l * s; |
|
var p = 2 * l - q; |
|
var r = hue2rgb(p, q, h + 1 / 3); |
|
var g = hue2rgb(p, q, h); |
|
var b = hue2rgb(p, q, h - 1 / 3); |
|
return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8; |
|
} |
|
|
|
function parse255(str) { |
|
var int = parseInt(str, 10); |
|
if (int < 0) return 0; |
|
if (int > 255) return 255; |
|
return int; |
|
} |
|
|
|
function parse360(str) { |
|
var int = parseFloat(str); |
|
return (int % 360 + 360) % 360 / 360; |
|
} |
|
|
|
function parse1(str) { |
|
var num = parseFloat(str); |
|
if (num < 0) return 0; |
|
if (num > 1) return 255; |
|
return Math.round(num * 255); |
|
} |
|
|
|
function parsePercentage(str) { |
|
// parseFloat conveniently ignores the final % |
|
var int = parseFloat(str); |
|
if (int < 0) return 0; |
|
if (int > 100) return 1; |
|
return int / 100; |
|
} |
|
|
|
function colorToRgba(input) { |
|
var int32Color = normalizeColor(input); |
|
if (int32Color === null) return input; |
|
int32Color = int32Color || 0; |
|
var r = (int32Color & 0xff000000) >>> 24; |
|
var g = (int32Color & 0x00ff0000) >>> 16; |
|
var b = (int32Color & 0x0000ff00) >>> 8; |
|
var a = (int32Color & 0x000000ff) / 255; |
|
return "rgba(" + r + ", " + g + ", " + b + ", " + a + ")"; |
|
} // Problem: https://github.com/animatedjs/animated/pull/102 |
|
// Solution: https://stackoverflow.com/questions/638565/parsing-scientific-notation-sensibly/658662 |
|
|
|
|
|
var stringShapeRegex = /[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g; // Covers rgb, rgba, hsl, hsla |
|
// Taken from https://gist.github.com/olmokramer/82ccce673f86db7cda5e |
|
|
|
var colorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi; // Covers color names (transparent, blue, etc.) |
|
|
|
var colorNamesRegex = new RegExp("(" + Object.keys(colors).join('|') + ")", 'g'); |
|
/** |
|
* Supports string shapes by extracting numbers so new values can be computed, |
|
* and recombines those values into new strings of the same shape. Supports |
|
* things like: |
|
* |
|
* rgba(123, 42, 99, 0.36) // colors |
|
* -45deg // values with units |
|
* 0 2px 2px 0px rgba(0, 0, 0, 0.12) // box shadows |
|
*/ |
|
|
|
var createStringInterpolator = function createStringInterpolator(config) { |
|
// Replace colors with rgba |
|
var outputRange = config.output.map(function (rangeValue) { |
|
return rangeValue.replace(colorRegex, colorToRgba); |
|
}).map(function (rangeValue) { |
|
return rangeValue.replace(colorNamesRegex, colorToRgba); |
|
}); |
|
var outputRanges = outputRange[0].match(stringShapeRegex).map(function () { |
|
return []; |
|
}); |
|
outputRange.forEach(function (value) { |
|
value.match(stringShapeRegex).forEach(function (number, i) { |
|
return outputRanges[i].push(+number); |
|
}); |
|
}); |
|
var interpolations = outputRange[0].match(stringShapeRegex).map(function (_value, i) { |
|
return createInterpolator(_extends({}, config, { |
|
output: outputRanges[i] |
|
})); |
|
}); |
|
return function (input) { |
|
var i = 0; |
|
return outputRange[0] // 'rgba(0, 100, 200, 0)' |
|
// -> |
|
// 'rgba(${interpolations[0](input)}, ${interpolations[1](input)}, ...' |
|
.replace(stringShapeRegex, function () { |
|
return interpolations[i++](input); |
|
}) // rgba requires that the r,g,b are integers.... so we want to round them, but we *dont* want to |
|
// round the opacity (4th column). |
|
.replace(/rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi, function (_, p1, p2, p3, p4) { |
|
return "rgba(" + Math.round(p1) + ", " + Math.round(p2) + ", " + Math.round(p3) + ", " + p4 + ")"; |
|
}); |
|
}; |
|
}; |
|
|
|
var isUnitlessNumber = { |
|
animationIterationCount: true, |
|
borderImageOutset: true, |
|
borderImageSlice: true, |
|
borderImageWidth: true, |
|
boxFlex: true, |
|
boxFlexGroup: true, |
|
boxOrdinalGroup: true, |
|
columnCount: true, |
|
columns: true, |
|
flex: true, |
|
flexGrow: true, |
|
flexPositive: true, |
|
flexShrink: true, |
|
flexNegative: true, |
|
flexOrder: true, |
|
gridRow: true, |
|
gridRowEnd: true, |
|
gridRowSpan: true, |
|
gridRowStart: true, |
|
gridColumn: true, |
|
gridColumnEnd: true, |
|
gridColumnSpan: true, |
|
gridColumnStart: true, |
|
fontWeight: true, |
|
lineClamp: true, |
|
lineHeight: true, |
|
opacity: true, |
|
order: true, |
|
orphans: true, |
|
tabSize: true, |
|
widows: true, |
|
zIndex: true, |
|
zoom: true, |
|
// SVG-related properties |
|
fillOpacity: true, |
|
floodOpacity: true, |
|
stopOpacity: true, |
|
strokeDasharray: true, |
|
strokeDashoffset: true, |
|
strokeMiterlimit: true, |
|
strokeOpacity: true, |
|
strokeWidth: true |
|
}; |
|
|
|
var prefixKey = function prefixKey(prefix, key) { |
|
return prefix + key.charAt(0).toUpperCase() + key.substring(1); |
|
}; |
|
|
|
var prefixes = ['Webkit', 'Ms', 'Moz', 'O']; |
|
isUnitlessNumber = Object.keys(isUnitlessNumber).reduce(function (acc, prop) { |
|
prefixes.forEach(function (prefix) { |
|
return acc[prefixKey(prefix, prop)] = acc[prop]; |
|
}); |
|
return acc; |
|
}, isUnitlessNumber); |
|
|
|
function dangerousStyleValue(name, value, isCustomProperty) { |
|
if (value == null || typeof value === 'boolean' || value === '') return ''; |
|
if (!isCustomProperty && typeof value === 'number' && value !== 0 && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) return value + 'px'; // Presumes implicit 'px' suffix for unitless numbers |
|
|
|
return ('' + value).trim(); |
|
} |
|
|
|
var attributeCache = {}; |
|
injectCreateAnimatedStyle(function (style) { |
|
return new AnimatedStyle(style); |
|
}); |
|
injectDefaultElement('div'); |
|
injectStringInterpolator(createStringInterpolator); |
|
injectColorNames(colors); |
|
injectApplyAnimatedValues(function (instance, props) { |
|
if (instance.nodeType && instance.setAttribute !== undefined) { |
|
var style = props.style, |
|
children = props.children, |
|
scrollTop = props.scrollTop, |
|
scrollLeft = props.scrollLeft, |
|
attributes = _objectWithoutPropertiesLoose(props, ["style", "children", "scrollTop", "scrollLeft"]); |
|
|
|
var filter = instance.nodeName === 'filter' || instance.parentNode && instance.parentNode.nodeName === 'filter'; |
|
if (scrollTop !== void 0) instance.scrollTop = scrollTop; |
|
if (scrollLeft !== void 0) instance.scrollLeft = scrollLeft; // Set textContent, if children is an animatable value |
|
|
|
if (children !== void 0) instance.textContent = children; // Set styles ... |
|
|
|
for (var styleName in style) { |
|
if (!style.hasOwnProperty(styleName)) continue; |
|
var isCustomProperty = styleName.indexOf('--') === 0; |
|
var styleValue = dangerousStyleValue(styleName, style[styleName], isCustomProperty); |
|
if (styleName === 'float') styleName = 'cssFloat'; |
|
if (isCustomProperty) instance.style.setProperty(styleName, styleValue);else instance.style[styleName] = styleValue; |
|
} // Set attributes ... |
|
|
|
|
|
for (var name in attributes) { |
|
// Attributes are written in dash case |
|
var dashCase = filter ? name : attributeCache[name] || (attributeCache[name] = name.replace(/([A-Z])/g, function (n) { |
|
return '-' + n.toLowerCase(); |
|
})); |
|
if (typeof instance.getAttribute(dashCase) !== 'undefined') instance.setAttribute(dashCase, attributes[name]); |
|
} |
|
|
|
return; |
|
} else return false; |
|
}, function (style) { |
|
return style; |
|
}); |
|
|
|
var domElements = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', // SVG |
|
'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan']; |
|
// Extend animated with all the available THREE elements |
|
var apply = merge(createAnimatedComponent, false); |
|
var extendedAnimated = apply(domElements); |
|
|
|
exports.apply = apply; |
|
exports.config = config; |
|
exports.update = update; |
|
exports.animated = extendedAnimated; |
|
exports.a = extendedAnimated; |
|
exports.interpolate = interpolate$1; |
|
exports.Globals = Globals; |
|
exports.useSpring = useSpring; |
|
exports.useTrail = useTrail; |
|
exports.useTransition = useTransition; |
|
exports.useChain = useChain; |
|
exports.useSprings = useSprings; |
|
|
|
|
|
/***/ }), |
|
/* 65 */ |
|
/***/ (function(module, exports) { |
|
|
|
var g; |
|
|
|
// This works in non-strict mode |
|
g = (function() { |
|
return this; |
|
})(); |
|
|
|
try { |
|
// This works if eval is allowed (see CSP) |
|
g = g || new Function("return this")(); |
|
} catch (e) { |
|
// This works if the window reference is available |
|
if (typeof window === "object") g = window; |
|
} |
|
|
|
// g can still be undefined, but nothing to do about it... |
|
// We return undefined, instead of nothing here, so it's |
|
// easier to handle this case. if(!global) { ...} |
|
|
|
module.exports = g; |
|
|
|
|
|
/***/ }), |
|
/* 66 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var moment = __webpack_require__(29); |
|
var momentValidationWrapper = __webpack_require__(269); |
|
var core = __webpack_require__(270); |
|
|
|
module.exports = { |
|
|
|
momentObj : core.createMomentChecker( |
|
'object', |
|
function(obj) { |
|
return typeof obj === 'object'; |
|
}, |
|
function isValid(value) { |
|
return momentValidationWrapper.isValidMoment(value); |
|
}, |
|
'Moment' |
|
), |
|
|
|
momentString : core.createMomentChecker( |
|
'string', |
|
function(str) { |
|
return typeof str === 'string'; |
|
}, |
|
function isValid(value) { |
|
return momentValidationWrapper.isValidMoment(moment(value)); |
|
}, |
|
'Moment' |
|
), |
|
|
|
momentDurationObj : core.createMomentChecker( |
|
'object', |
|
function(obj) { |
|
return typeof obj === 'object'; |
|
}, |
|
function isValid(value) { |
|
return moment.isDuration(value); |
|
}, |
|
'Duration' |
|
), |
|
|
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 67 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var rng = __webpack_require__(85); |
|
var bytesToUuid = __webpack_require__(86); |
|
|
|
function v4(options, buf, offset) { |
|
var i = buf && offset || 0; |
|
|
|
if (typeof(options) == 'string') { |
|
buf = options === 'binary' ? new Array(16) : null; |
|
options = null; |
|
} |
|
options = options || {}; |
|
|
|
var rnds = options.random || (options.rng || rng)(); |
|
|
|
// Per 4.4, set bits for version and `clock_seq_hi_and_reserved` |
|
rnds[6] = (rnds[6] & 0x0f) | 0x40; |
|
rnds[8] = (rnds[8] & 0x3f) | 0x80; |
|
|
|
// Copy bytes to buffer, if provided |
|
if (buf) { |
|
for (var ii = 0; ii < 16; ++ii) { |
|
buf[i + ii] = rnds[ii]; |
|
} |
|
} |
|
|
|
return buf || bytesToUuid(rnds); |
|
} |
|
|
|
module.exports = v4; |
|
|
|
|
|
/***/ }), |
|
/* 68 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
module.exports = __webpack_require__(113); |
|
|
|
/***/ }), |
|
/* 69 */, |
|
/* 70 */, |
|
/* 71 */, |
|
/* 72 */, |
|
/* 73 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
exports['default'] = _propTypes2['default'].oneOf(_constants.WEEKDAYS); |
|
|
|
/***/ }), |
|
/* 74 */, |
|
/* 75 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var GetIntrinsic = __webpack_require__(60); |
|
|
|
var callBind = __webpack_require__(102); |
|
|
|
var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf')); |
|
|
|
module.exports = function callBoundIntrinsic(name, allowMissing) { |
|
var intrinsic = GetIntrinsic(name, !!allowMissing); |
|
if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.')) { |
|
return callBind(intrinsic); |
|
} |
|
return intrinsic; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 76 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
/** |
|
* Copyright (c) 2013-present, Facebook, Inc. |
|
* |
|
* This source code is licensed under the MIT license found in the |
|
* LICENSE file in the root directory of this source tree. |
|
* |
|
* @providesModule shallowCompare |
|
*/ |
|
|
|
|
|
|
|
var shallowEqual = __webpack_require__(268); |
|
|
|
/** |
|
* Does a shallow comparison for props and state. |
|
* See ReactComponentWithPureRenderMixin |
|
* See also https://facebook.github.io/react/docs/shallow-compare.html |
|
*/ |
|
function shallowCompare(instance, nextProps, nextState) { |
|
return ( |
|
!shallowEqual(instance.props, nextProps) || |
|
!shallowEqual(instance.state, nextState) |
|
); |
|
} |
|
|
|
module.exports = shallowCompare; |
|
|
|
|
|
/***/ }), |
|
/* 77 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = isSameDay; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function isSameDay(a, b) { |
|
if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false; |
|
// Compare least significant, most likely to change units first |
|
// Moment's isSame clones moment inputs and is a tad slow |
|
return a.date() === b.date() && a.month() === b.month() && a.year() === b.year(); |
|
} |
|
|
|
/***/ }), |
|
/* 78 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = toMomentObject; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function toMomentObject(dateString, customFormat) { |
|
var dateFormats = customFormat ? [customFormat, _constants.DISPLAY_FORMAT, _constants.ISO_FORMAT] : [_constants.DISPLAY_FORMAT, _constants.ISO_FORMAT]; |
|
|
|
var date = (0, _moment2['default'])(dateString, dateFormats, true); |
|
return date.isValid() ? date.hour(12) : null; |
|
} |
|
|
|
/***/ }), |
|
/* 79 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
exports['default'] = _propTypes2['default'].oneOf([_constants.HORIZONTAL_ORIENTATION, _constants.VERTICAL_ORIENTATION, _constants.VERTICAL_SCROLLABLE]); |
|
|
|
/***/ }), |
|
/* 80 */ |
|
/***/ (function(module, exports) { |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = isTouchDevice; |
|
function isTouchDevice() { |
|
return !!(typeof window !== 'undefined' && ('ontouchstart' in window || window.DocumentTouch && typeof document !== 'undefined' && document instanceof window.DocumentTouch)) || !!(typeof navigator !== 'undefined' && (navigator.maxTouchPoints || navigator.msMaxTouchPoints)); |
|
} |
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 81 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
exports['default'] = _propTypes2['default'].oneOf([_constants.OPEN_DOWN, _constants.OPEN_UP]); |
|
|
|
/***/ }), |
|
/* 82 */, |
|
/* 83 */, |
|
/* 84 */, |
|
/* 85 */ |
|
/***/ (function(module, exports) { |
|
|
|
// Unique ID creation requires a high quality random # generator. In the |
|
// browser this is a little complicated due to unknown quality of Math.random() |
|
// and inconsistent support for the `crypto` API. We do the best we can via |
|
// feature-detection |
|
|
|
// getRandomValues needs to be invoked in a context where "this" is a Crypto |
|
// implementation. Also, find the complete implementation of crypto on IE11. |
|
var getRandomValues = (typeof(crypto) != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto)) || |
|
(typeof(msCrypto) != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto)); |
|
|
|
if (getRandomValues) { |
|
// WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto |
|
var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef |
|
|
|
module.exports = function whatwgRNG() { |
|
getRandomValues(rnds8); |
|
return rnds8; |
|
}; |
|
} else { |
|
// Math.random()-based (RNG) |
|
// |
|
// If all else fails, use Math.random(). It's fast, but is of unspecified |
|
// quality. |
|
var rnds = new Array(16); |
|
|
|
module.exports = function mathRNG() { |
|
for (var i = 0, r; i < 16; i++) { |
|
if ((i & 0x03) === 0) r = Math.random() * 0x100000000; |
|
rnds[i] = r >>> ((i & 0x03) << 3) & 0xff; |
|
} |
|
|
|
return rnds; |
|
}; |
|
} |
|
|
|
|
|
/***/ }), |
|
/* 86 */ |
|
/***/ (function(module, exports) { |
|
|
|
/** |
|
* Convert array of 16 byte values to UUID string format of the form: |
|
* XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX |
|
*/ |
|
var byteToHex = []; |
|
for (var i = 0; i < 256; ++i) { |
|
byteToHex[i] = (i + 0x100).toString(16).substr(1); |
|
} |
|
|
|
function bytesToUuid(buf, offset) { |
|
var i = offset || 0; |
|
var bth = byteToHex; |
|
// join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4 |
|
return ([bth[buf[i++]], bth[buf[i++]], |
|
bth[buf[i++]], bth[buf[i++]], '-', |
|
bth[buf[i++]], bth[buf[i++]], '-', |
|
bth[buf[i++]], bth[buf[i++]], '-', |
|
bth[buf[i++]], bth[buf[i++]], '-', |
|
bth[buf[i++]], bth[buf[i++]], |
|
bth[buf[i++]], bth[buf[i++]], |
|
bth[buf[i++]], bth[buf[i++]]]).join(''); |
|
} |
|
|
|
module.exports = bytesToUuid; |
|
|
|
|
|
/***/ }), |
|
/* 87 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
/** |
|
* Copyright (c) 2013-present, Facebook, Inc. |
|
* |
|
* This source code is licensed under the MIT license found in the |
|
* LICENSE file in the root directory of this source tree. |
|
*/ |
|
|
|
|
|
|
|
var ReactPropTypesSecret = __webpack_require__(88); |
|
|
|
function emptyFunction() {} |
|
function emptyFunctionWithReset() {} |
|
emptyFunctionWithReset.resetWarningCache = emptyFunction; |
|
|
|
module.exports = function() { |
|
function shim(props, propName, componentName, location, propFullName, secret) { |
|
if (secret === ReactPropTypesSecret) { |
|
// It is still safe when called from React. |
|
return; |
|
} |
|
var err = new Error( |
|
'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + |
|
'Use PropTypes.checkPropTypes() to call them. ' + |
|
'Read more at http://fb.me/use-check-prop-types' |
|
); |
|
err.name = 'Invariant Violation'; |
|
throw err; |
|
}; |
|
shim.isRequired = shim; |
|
function getShim() { |
|
return shim; |
|
}; |
|
// Important! |
|
// Keep this list in sync with production version in `./factoryWithTypeCheckers.js`. |
|
var ReactPropTypes = { |
|
array: shim, |
|
bool: shim, |
|
func: shim, |
|
number: shim, |
|
object: shim, |
|
string: shim, |
|
symbol: shim, |
|
|
|
any: shim, |
|
arrayOf: getShim, |
|
element: shim, |
|
elementType: shim, |
|
instanceOf: getShim, |
|
node: shim, |
|
objectOf: getShim, |
|
oneOf: getShim, |
|
oneOfType: getShim, |
|
shape: getShim, |
|
exact: getShim, |
|
|
|
checkPropTypes: emptyFunctionWithReset, |
|
resetWarningCache: emptyFunction |
|
}; |
|
|
|
ReactPropTypes.PropTypes = ReactPropTypes; |
|
|
|
return ReactPropTypes; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 88 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
/** |
|
* Copyright (c) 2013-present, Facebook, Inc. |
|
* |
|
* This source code is licensed under the MIT license found in the |
|
* LICENSE file in the root directory of this source tree. |
|
*/ |
|
|
|
|
|
|
|
var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; |
|
|
|
module.exports = ReactPropTypesSecret; |
|
|
|
|
|
/***/ }), |
|
/* 89 */, |
|
/* 90 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var slice = Array.prototype.slice; |
|
var isArgs = __webpack_require__(147); |
|
|
|
var origKeys = Object.keys; |
|
var keysShim = origKeys ? function keys(o) { return origKeys(o); } : __webpack_require__(243); |
|
|
|
var originalKeys = Object.keys; |
|
|
|
keysShim.shim = function shimObjectKeys() { |
|
if (Object.keys) { |
|
var keysWorksWithArguments = (function () { |
|
// Safari 5.0 bug |
|
var args = Object.keys(arguments); |
|
return args && args.length === arguments.length; |
|
}(1, 2)); |
|
if (!keysWorksWithArguments) { |
|
Object.keys = function keys(object) { // eslint-disable-line func-name-matching |
|
if (isArgs(object)) { |
|
return originalKeys(slice.call(object)); |
|
} |
|
return originalKeys(object); |
|
}; |
|
} |
|
} else { |
|
Object.keys = keysShim; |
|
} |
|
return Object.keys || keysShim; |
|
}; |
|
|
|
module.exports = keysShim; |
|
|
|
|
|
/***/ }), |
|
/* 91 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var GetIntrinsic = __webpack_require__(60); |
|
|
|
var has = __webpack_require__(63); |
|
|
|
var $assign = GetIntrinsic('%Object%').assign; |
|
|
|
module.exports = function assign(target, source) { |
|
if ($assign) { |
|
return $assign(target, source); |
|
} |
|
|
|
// eslint-disable-next-line no-restricted-syntax |
|
for (var key in source) { |
|
if (has(source, key)) { |
|
target[key] = source[key]; |
|
} |
|
} |
|
return target; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 92 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
exports['default'] = _propTypes2['default'].oneOf([_constants.ICON_BEFORE_POSITION, _constants.ICON_AFTER_POSITION]); |
|
|
|
/***/ }), |
|
/* 93 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
exports['default'] = _propTypes2['default'].oneOf([_constants.INFO_POSITION_TOP, _constants.INFO_POSITION_BOTTOM, _constants.INFO_POSITION_BEFORE, _constants.INFO_POSITION_AFTER]); |
|
|
|
/***/ }), |
|
/* 94 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = isInclusivelyAfterDay; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _isBeforeDay = __webpack_require__(95); |
|
|
|
var _isBeforeDay2 = _interopRequireDefault(_isBeforeDay); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function isInclusivelyAfterDay(a, b) { |
|
if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false; |
|
return !(0, _isBeforeDay2['default'])(a, b); |
|
} |
|
|
|
/***/ }), |
|
/* 95 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = isBeforeDay; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function isBeforeDay(a, b) { |
|
if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false; |
|
|
|
var aYear = a.year(); |
|
var aMonth = a.month(); |
|
|
|
var bYear = b.year(); |
|
var bMonth = b.month(); |
|
|
|
var isSameYear = aYear === bYear; |
|
var isSameMonth = aMonth === bMonth; |
|
|
|
if (isSameYear && isSameMonth) return a.date() < b.date(); |
|
if (isSameYear) return aMonth < bMonth; |
|
return aYear < bYear; |
|
} |
|
|
|
/***/ }), |
|
/* 96 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
var CloseButton = function () { |
|
function CloseButton(props) { |
|
return _react2['default'].createElement( |
|
'svg', |
|
props, |
|
_react2['default'].createElement('path', { |
|
fillRule: 'evenodd', |
|
d: 'M11.53.47a.75.75 0 0 0-1.061 0l-4.47 4.47L1.529.47A.75.75 0 1 0 .468 1.531l4.47 4.47-4.47 4.47a.75.75 0 1 0 1.061 1.061l4.47-4.47 4.47 4.47a.75.75 0 1 0 1.061-1.061l-4.47-4.47 4.47-4.47a.75.75 0 0 0 0-1.061z' |
|
}) |
|
); |
|
} |
|
|
|
return CloseButton; |
|
}(); |
|
|
|
CloseButton.defaultProps = { |
|
viewBox: '0 0 12 12' |
|
}; |
|
exports['default'] = CloseButton; |
|
|
|
/***/ }), |
|
/* 97 */, |
|
/* 98 */, |
|
/* 99 */, |
|
/* 100 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* WEBPACK VAR INJECTION */(function(global) { |
|
|
|
var origSymbol = global.Symbol; |
|
var hasSymbolSham = __webpack_require__(153); |
|
|
|
module.exports = function hasNativeSymbols() { |
|
if (typeof origSymbol !== 'function') { return false; } |
|
if (typeof Symbol !== 'function') { return false; } |
|
if (typeof origSymbol('foo') !== 'symbol') { return false; } |
|
if (typeof Symbol('bar') !== 'symbol') { return false; } |
|
|
|
return hasSymbolSham(); |
|
}; |
|
|
|
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(65))) |
|
|
|
/***/ }), |
|
/* 101 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var fnToStr = Function.prototype.toString; |
|
|
|
var constructorRegex = /^\s*class\b/; |
|
var isES6ClassFn = function isES6ClassFunction(value) { |
|
try { |
|
var fnStr = fnToStr.call(value); |
|
return constructorRegex.test(fnStr); |
|
} catch (e) { |
|
return false; // not a function |
|
} |
|
}; |
|
|
|
var tryFunctionObject = function tryFunctionToStr(value) { |
|
try { |
|
if (isES6ClassFn(value)) { return false; } |
|
fnToStr.call(value); |
|
return true; |
|
} catch (e) { |
|
return false; |
|
} |
|
}; |
|
var toStr = Object.prototype.toString; |
|
var fnClass = '[object Function]'; |
|
var genClass = '[object GeneratorFunction]'; |
|
var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol'; |
|
|
|
module.exports = function isCallable(value) { |
|
if (!value) { return false; } |
|
if (typeof value !== 'function' && typeof value !== 'object') { return false; } |
|
if (typeof value === 'function' && !value.prototype) { return true; } |
|
if (hasToStringTag) { return tryFunctionObject(value); } |
|
if (isES6ClassFn(value)) { return false; } |
|
var strClass = toStr.call(value); |
|
return strClass === fnClass || strClass === genClass; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 102 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var bind = __webpack_require__(59); |
|
|
|
var GetIntrinsic = __webpack_require__(60); |
|
|
|
var $Function = GetIntrinsic('%Function%'); |
|
var $apply = $Function.apply; |
|
var $call = $Function.call; |
|
|
|
module.exports = function callBind() { |
|
return bind.apply($call, arguments); |
|
}; |
|
|
|
module.exports.apply = function applyBind() { |
|
return bind.apply($apply, arguments); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 103 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } |
|
|
|
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } |
|
|
|
exports['default'] = (0, _airbnbPropTypes.and)([_propTypes2['default'].instanceOf(Set), function () { |
|
function modifiers(props, propName) { |
|
for (var _len = arguments.length, rest = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { |
|
rest[_key - 2] = arguments[_key]; |
|
} |
|
|
|
var propValue = props[propName]; |
|
|
|
var firstError = void 0; |
|
[].concat(_toConsumableArray(propValue)).some(function (v, i) { |
|
var _PropTypes$string; |
|
|
|
var fakePropName = String(propName) + ': index ' + String(i); |
|
firstError = (_PropTypes$string = _propTypes2['default'].string).isRequired.apply(_PropTypes$string, [_defineProperty({}, fakePropName, v), fakePropName].concat(rest)); |
|
return firstError != null; |
|
}); |
|
return firstError == null ? null : firstError; |
|
} |
|
|
|
return modifiers; |
|
}()], 'Modifiers (Set of Strings)'); |
|
|
|
/***/ }), |
|
/* 104 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = toISODateString; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _toMomentObject = __webpack_require__(78); |
|
|
|
var _toMomentObject2 = _interopRequireDefault(_toMomentObject); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function toISODateString(date, currentFormat) { |
|
var dateObj = _moment2['default'].isMoment(date) ? date : (0, _toMomentObject2['default'])(date, currentFormat); |
|
if (!dateObj) return null; |
|
|
|
return dateObj.format(_constants.ISO_FORMAT); |
|
} |
|
|
|
/***/ }), |
|
/* 105 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
__webpack_require__.r(__webpack_exports__); |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "addEventListener", function() { return addEventListener; }); |
|
var CAN_USE_DOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement); |
|
|
|
// Adapted from Modernizr |
|
// https://github.com/Modernizr/Modernizr/blob/acb3f0d9/feature-detects/dom/passiveeventlisteners.js#L26-L37 |
|
function testPassiveEventListeners() { |
|
if (!CAN_USE_DOM) { |
|
return false; |
|
} |
|
|
|
if (!window.addEventListener || !window.removeEventListener || !Object.defineProperty) { |
|
return false; |
|
} |
|
|
|
var supportsPassiveOption = false; |
|
try { |
|
var opts = Object.defineProperty({}, 'passive', { |
|
// eslint-disable-next-line getter-return |
|
get: function () { |
|
function get() { |
|
supportsPassiveOption = true; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
var noop = function noop() {}; |
|
window.addEventListener('testPassiveEventSupport', noop, opts); |
|
window.removeEventListener('testPassiveEventSupport', noop, opts); |
|
} catch (e) { |
|
// do nothing |
|
} |
|
|
|
return supportsPassiveOption; |
|
} |
|
|
|
var memoized = void 0; |
|
|
|
function canUsePassiveEventListeners() { |
|
if (memoized === undefined) { |
|
memoized = testPassiveEventListeners(); |
|
} |
|
return memoized; |
|
} |
|
|
|
function normalizeEventOptions(eventOptions) { |
|
if (!eventOptions) { |
|
return undefined; |
|
} |
|
|
|
if (!canUsePassiveEventListeners()) { |
|
// If the browser does not support the passive option, then it is expecting |
|
// a boolean for the options argument to specify whether it should use |
|
// capture or not. In more modern browsers, this is passed via the `capture` |
|
// option, so let's just hoist that value up. |
|
return !!eventOptions.capture; |
|
} |
|
|
|
return eventOptions; |
|
} |
|
|
|
/* eslint-disable no-bitwise */ |
|
|
|
/** |
|
* Generate a unique key for any set of event options |
|
*/ |
|
function eventOptionsKey(normalizedEventOptions) { |
|
if (!normalizedEventOptions) { |
|
return 0; |
|
} |
|
|
|
// If the browser does not support passive event listeners, the normalized |
|
// event options will be a boolean. |
|
if (normalizedEventOptions === true) { |
|
return 100; |
|
} |
|
|
|
// At this point, the browser supports passive event listeners, so we expect |
|
// the event options to be an object with possible properties of capture, |
|
// passive, and once. |
|
// |
|
// We want to consistently return the same value, regardless of the order of |
|
// these properties, so let's use binary maths to assign each property to a |
|
// bit, and then add those together (with an offset to account for the |
|
// booleans at the beginning of this function). |
|
var capture = normalizedEventOptions.capture << 0; |
|
var passive = normalizedEventOptions.passive << 1; |
|
var once = normalizedEventOptions.once << 2; |
|
return capture + passive + once; |
|
} |
|
|
|
function ensureCanMutateNextEventHandlers(eventHandlers) { |
|
if (eventHandlers.handlers === eventHandlers.nextHandlers) { |
|
// eslint-disable-next-line no-param-reassign |
|
eventHandlers.nextHandlers = eventHandlers.handlers.slice(); |
|
} |
|
} |
|
|
|
function TargetEventHandlers(target) { |
|
this.target = target; |
|
this.events = {}; |
|
} |
|
|
|
TargetEventHandlers.prototype.getEventHandlers = function () { |
|
function getEventHandlers(eventName, options) { |
|
var key = String(eventName) + ' ' + String(eventOptionsKey(options)); |
|
|
|
if (!this.events[key]) { |
|
this.events[key] = { |
|
handlers: [], |
|
handleEvent: undefined |
|
}; |
|
this.events[key].nextHandlers = this.events[key].handlers; |
|
} |
|
|
|
return this.events[key]; |
|
} |
|
|
|
return getEventHandlers; |
|
}(); |
|
|
|
TargetEventHandlers.prototype.handleEvent = function () { |
|
function handleEvent(eventName, options, event) { |
|
var eventHandlers = this.getEventHandlers(eventName, options); |
|
eventHandlers.handlers = eventHandlers.nextHandlers; |
|
eventHandlers.handlers.forEach(function (handler) { |
|
if (handler) { |
|
// We need to check for presence here because a handler function may |
|
// cause later handlers to get removed. This can happen if you for |
|
// instance have a waypoint that unmounts another waypoint as part of an |
|
// onEnter/onLeave handler. |
|
handler(event); |
|
} |
|
}); |
|
} |
|
|
|
return handleEvent; |
|
}(); |
|
|
|
TargetEventHandlers.prototype.add = function () { |
|
function add(eventName, listener, options) { |
|
var _this = this; |
|
|
|
// options has already been normalized at this point. |
|
var eventHandlers = this.getEventHandlers(eventName, options); |
|
|
|
ensureCanMutateNextEventHandlers(eventHandlers); |
|
|
|
if (eventHandlers.nextHandlers.length === 0) { |
|
eventHandlers.handleEvent = this.handleEvent.bind(this, eventName, options); |
|
|
|
this.target.addEventListener(eventName, eventHandlers.handleEvent, options); |
|
} |
|
|
|
eventHandlers.nextHandlers.push(listener); |
|
|
|
var isSubscribed = true; |
|
var unsubscribe = function () { |
|
function unsubscribe() { |
|
if (!isSubscribed) { |
|
return; |
|
} |
|
|
|
isSubscribed = false; |
|
|
|
ensureCanMutateNextEventHandlers(eventHandlers); |
|
var index = eventHandlers.nextHandlers.indexOf(listener); |
|
eventHandlers.nextHandlers.splice(index, 1); |
|
|
|
if (eventHandlers.nextHandlers.length === 0) { |
|
// All event handlers have been removed, so we want to remove the event |
|
// listener from the target node. |
|
|
|
if (_this.target) { |
|
// There can be a race condition where the target may no longer exist |
|
// when this function is called, e.g. when a React component is |
|
// unmounting. Guarding against this prevents the following error: |
|
// |
|
// Cannot read property 'removeEventListener' of undefined |
|
_this.target.removeEventListener(eventName, eventHandlers.handleEvent, options); |
|
} |
|
|
|
eventHandlers.handleEvent = undefined; |
|
} |
|
} |
|
|
|
return unsubscribe; |
|
}(); |
|
return unsubscribe; |
|
} |
|
|
|
return add; |
|
}(); |
|
|
|
var EVENT_HANDLERS_KEY = '__consolidated_events_handlers__'; |
|
|
|
// eslint-disable-next-line import/prefer-default-export |
|
function addEventListener(target, eventName, listener, options) { |
|
if (!target[EVENT_HANDLERS_KEY]) { |
|
// eslint-disable-next-line no-param-reassign |
|
target[EVENT_HANDLERS_KEY] = new TargetEventHandlers(target); |
|
} |
|
var normalizedEventOptions = normalizeEventOptions(options); |
|
return target[EVENT_HANDLERS_KEY].add(eventName, listener, normalizedEventOptions); |
|
} |
|
|
|
|
|
|
|
|
|
/***/ }), |
|
/* 106 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = toISOMonthString; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _toMomentObject = __webpack_require__(78); |
|
|
|
var _toMomentObject2 = _interopRequireDefault(_toMomentObject); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function toISOMonthString(date, currentFormat) { |
|
var dateObj = _moment2['default'].isMoment(date) ? date : (0, _toMomentObject2['default'])(date, currentFormat); |
|
if (!dateObj) return null; |
|
|
|
return dateObj.format(_constants.ISO_MONTH_FORMAT); |
|
} |
|
|
|
/***/ }), |
|
/* 107 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
exports['default'] = _propTypes2['default'].oneOfType([_propTypes2['default'].bool, _propTypes2['default'].oneOf([_constants.START_DATE, _constants.END_DATE])]); |
|
|
|
/***/ }), |
|
/* 108 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = isAfterDay; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _isBeforeDay = __webpack_require__(95); |
|
|
|
var _isBeforeDay2 = _interopRequireDefault(_isBeforeDay); |
|
|
|
var _isSameDay = __webpack_require__(77); |
|
|
|
var _isSameDay2 = _interopRequireDefault(_isSameDay); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function isAfterDay(a, b) { |
|
if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false; |
|
return !(0, _isBeforeDay2['default'])(a, b) && !(0, _isSameDay2['default'])(a, b); |
|
} |
|
|
|
/***/ }), |
|
/* 109 */, |
|
/* 110 */, |
|
/* 111 */, |
|
/* 112 */, |
|
/* 113 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var util = __webpack_require__(114); |
|
|
|
function scrollIntoView(elem, container, config) { |
|
config = config || {}; |
|
// document 归一化到 window |
|
if (container.nodeType === 9) { |
|
container = util.getWindow(container); |
|
} |
|
|
|
var allowHorizontalScroll = config.allowHorizontalScroll; |
|
var onlyScrollIfNeeded = config.onlyScrollIfNeeded; |
|
var alignWithTop = config.alignWithTop; |
|
var alignWithLeft = config.alignWithLeft; |
|
var offsetTop = config.offsetTop || 0; |
|
var offsetLeft = config.offsetLeft || 0; |
|
var offsetBottom = config.offsetBottom || 0; |
|
var offsetRight = config.offsetRight || 0; |
|
|
|
allowHorizontalScroll = allowHorizontalScroll === undefined ? true : allowHorizontalScroll; |
|
|
|
var isWin = util.isWindow(container); |
|
var elemOffset = util.offset(elem); |
|
var eh = util.outerHeight(elem); |
|
var ew = util.outerWidth(elem); |
|
var containerOffset = undefined; |
|
var ch = undefined; |
|
var cw = undefined; |
|
var containerScroll = undefined; |
|
var diffTop = undefined; |
|
var diffBottom = undefined; |
|
var win = undefined; |
|
var winScroll = undefined; |
|
var ww = undefined; |
|
var wh = undefined; |
|
|
|
if (isWin) { |
|
win = container; |
|
wh = util.height(win); |
|
ww = util.width(win); |
|
winScroll = { |
|
left: util.scrollLeft(win), |
|
top: util.scrollTop(win) |
|
}; |
|
// elem 相对 container 可视视窗的距离 |
|
diffTop = { |
|
left: elemOffset.left - winScroll.left - offsetLeft, |
|
top: elemOffset.top - winScroll.top - offsetTop |
|
}; |
|
diffBottom = { |
|
left: elemOffset.left + ew - (winScroll.left + ww) + offsetRight, |
|
top: elemOffset.top + eh - (winScroll.top + wh) + offsetBottom |
|
}; |
|
containerScroll = winScroll; |
|
} else { |
|
containerOffset = util.offset(container); |
|
ch = container.clientHeight; |
|
cw = container.clientWidth; |
|
containerScroll = { |
|
left: container.scrollLeft, |
|
top: container.scrollTop |
|
}; |
|
// elem 相对 container 可视视窗的距离 |
|
// 注意边框, offset 是边框到根节点 |
|
diffTop = { |
|
left: elemOffset.left - (containerOffset.left + (parseFloat(util.css(container, 'borderLeftWidth')) || 0)) - offsetLeft, |
|
top: elemOffset.top - (containerOffset.top + (parseFloat(util.css(container, 'borderTopWidth')) || 0)) - offsetTop |
|
}; |
|
diffBottom = { |
|
left: elemOffset.left + ew - (containerOffset.left + cw + (parseFloat(util.css(container, 'borderRightWidth')) || 0)) + offsetRight, |
|
top: elemOffset.top + eh - (containerOffset.top + ch + (parseFloat(util.css(container, 'borderBottomWidth')) || 0)) + offsetBottom |
|
}; |
|
} |
|
|
|
if (diffTop.top < 0 || diffBottom.top > 0) { |
|
// 强制向上 |
|
if (alignWithTop === true) { |
|
util.scrollTop(container, containerScroll.top + diffTop.top); |
|
} else if (alignWithTop === false) { |
|
util.scrollTop(container, containerScroll.top + diffBottom.top); |
|
} else { |
|
// 自动调整 |
|
if (diffTop.top < 0) { |
|
util.scrollTop(container, containerScroll.top + diffTop.top); |
|
} else { |
|
util.scrollTop(container, containerScroll.top + diffBottom.top); |
|
} |
|
} |
|
} else { |
|
if (!onlyScrollIfNeeded) { |
|
alignWithTop = alignWithTop === undefined ? true : !!alignWithTop; |
|
if (alignWithTop) { |
|
util.scrollTop(container, containerScroll.top + diffTop.top); |
|
} else { |
|
util.scrollTop(container, containerScroll.top + diffBottom.top); |
|
} |
|
} |
|
} |
|
|
|
if (allowHorizontalScroll) { |
|
if (diffTop.left < 0 || diffBottom.left > 0) { |
|
// 强制向上 |
|
if (alignWithLeft === true) { |
|
util.scrollLeft(container, containerScroll.left + diffTop.left); |
|
} else if (alignWithLeft === false) { |
|
util.scrollLeft(container, containerScroll.left + diffBottom.left); |
|
} else { |
|
// 自动调整 |
|
if (diffTop.left < 0) { |
|
util.scrollLeft(container, containerScroll.left + diffTop.left); |
|
} else { |
|
util.scrollLeft(container, containerScroll.left + diffBottom.left); |
|
} |
|
} |
|
} else { |
|
if (!onlyScrollIfNeeded) { |
|
alignWithLeft = alignWithLeft === undefined ? true : !!alignWithLeft; |
|
if (alignWithLeft) { |
|
util.scrollLeft(container, containerScroll.left + diffTop.left); |
|
} else { |
|
util.scrollLeft(container, containerScroll.left + diffBottom.left); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
module.exports = scrollIntoView; |
|
|
|
/***/ }), |
|
/* 114 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; |
|
|
|
var RE_NUM = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source; |
|
|
|
function getClientPosition(elem) { |
|
var box = undefined; |
|
var x = undefined; |
|
var y = undefined; |
|
var doc = elem.ownerDocument; |
|
var body = doc.body; |
|
var docElem = doc && doc.documentElement; |
|
// 根据 GBS 最新数据,A-Grade Browsers 都已支持 getBoundingClientRect 方法,不用再考虑传统的实现方式 |
|
box = elem.getBoundingClientRect(); |
|
|
|
// 注:jQuery 还考虑减去 docElem.clientLeft/clientTop |
|
// 但测试发现,这样反而会导致当 html 和 body 有边距/边框样式时,获取的值不正确 |
|
// 此外,ie6 会忽略 html 的 margin 值,幸运地是没有谁会去设置 html 的 margin |
|
|
|
x = box.left; |
|
y = box.top; |
|
|
|
// In IE, most of the time, 2 extra pixels are added to the top and left |
|
// due to the implicit 2-pixel inset border. In IE6/7 quirks mode and |
|
// IE6 standards mode, this border can be overridden by setting the |
|
// document element's border to zero -- thus, we cannot rely on the |
|
// offset always being 2 pixels. |
|
|
|
// In quirks mode, the offset can be determined by querying the body's |
|
// clientLeft/clientTop, but in standards mode, it is found by querying |
|
// the document element's clientLeft/clientTop. Since we already called |
|
// getClientBoundingRect we have already forced a reflow, so it is not |
|
// too expensive just to query them all. |
|
|
|
// ie 下应该减去窗口的边框吧,毕竟默认 absolute 都是相对窗口定位的 |
|
// 窗口边框标准是设 documentElement ,quirks 时设置 body |
|
// 最好禁止在 body 和 html 上边框 ,但 ie < 9 html 默认有 2px ,减去 |
|
// 但是非 ie 不可能设置窗口边框,body html 也不是窗口 ,ie 可以通过 html,body 设置 |
|
// 标准 ie 下 docElem.clientTop 就是 border-top |
|
// ie7 html 即窗口边框改变不了。永远为 2 |
|
// 但标准 firefox/chrome/ie9 下 docElem.clientTop 是窗口边框,即使设了 border-top 也为 0 |
|
|
|
x -= docElem.clientLeft || body.clientLeft || 0; |
|
y -= docElem.clientTop || body.clientTop || 0; |
|
|
|
return { |
|
left: x, |
|
top: y |
|
}; |
|
} |
|
|
|
function getScroll(w, top) { |
|
var ret = w['page' + (top ? 'Y' : 'X') + 'Offset']; |
|
var method = 'scroll' + (top ? 'Top' : 'Left'); |
|
if (typeof ret !== 'number') { |
|
var d = w.document; |
|
// ie6,7,8 standard mode |
|
ret = d.documentElement[method]; |
|
if (typeof ret !== 'number') { |
|
// quirks mode |
|
ret = d.body[method]; |
|
} |
|
} |
|
return ret; |
|
} |
|
|
|
function getScrollLeft(w) { |
|
return getScroll(w); |
|
} |
|
|
|
function getScrollTop(w) { |
|
return getScroll(w, true); |
|
} |
|
|
|
function getOffset(el) { |
|
var pos = getClientPosition(el); |
|
var doc = el.ownerDocument; |
|
var w = doc.defaultView || doc.parentWindow; |
|
pos.left += getScrollLeft(w); |
|
pos.top += getScrollTop(w); |
|
return pos; |
|
} |
|
function _getComputedStyle(elem, name, computedStyle_) { |
|
var val = ''; |
|
var d = elem.ownerDocument; |
|
var computedStyle = computedStyle_ || d.defaultView.getComputedStyle(elem, null); |
|
|
|
// https://github.com/kissyteam/kissy/issues/61 |
|
if (computedStyle) { |
|
val = computedStyle.getPropertyValue(name) || computedStyle[name]; |
|
} |
|
|
|
return val; |
|
} |
|
|
|
var _RE_NUM_NO_PX = new RegExp('^(' + RE_NUM + ')(?!px)[a-z%]+$', 'i'); |
|
var RE_POS = /^(top|right|bottom|left)$/; |
|
var CURRENT_STYLE = 'currentStyle'; |
|
var RUNTIME_STYLE = 'runtimeStyle'; |
|
var LEFT = 'left'; |
|
var PX = 'px'; |
|
|
|
function _getComputedStyleIE(elem, name) { |
|
// currentStyle maybe null |
|
// http://msdn.microsoft.com/en-us/library/ms535231.aspx |
|
var ret = elem[CURRENT_STYLE] && elem[CURRENT_STYLE][name]; |
|
|
|
// 当 width/height 设置为百分比时,通过 pixelLeft 方式转换的 width/height 值 |
|
// 一开始就处理了! CUSTOM_STYLE.height,CUSTOM_STYLE.width ,cssHook 解决@2011-08-19 |
|
// 在 ie 下不对,需要直接用 offset 方式 |
|
// borderWidth 等值也有问题,但考虑到 borderWidth 设为百分比的概率很小,这里就不考虑了 |
|
|
|
// From the awesome hack by Dean Edwards |
|
// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291 |
|
// If we're not dealing with a regular pixel number |
|
// but a number that has a weird ending, we need to convert it to pixels |
|
// exclude left right for relativity |
|
if (_RE_NUM_NO_PX.test(ret) && !RE_POS.test(name)) { |
|
// Remember the original values |
|
var style = elem.style; |
|
var left = style[LEFT]; |
|
var rsLeft = elem[RUNTIME_STYLE][LEFT]; |
|
|
|
// prevent flashing of content |
|
elem[RUNTIME_STYLE][LEFT] = elem[CURRENT_STYLE][LEFT]; |
|
|
|
// Put in the new values to get a computed value out |
|
style[LEFT] = name === 'fontSize' ? '1em' : ret || 0; |
|
ret = style.pixelLeft + PX; |
|
|
|
// Revert the changed values |
|
style[LEFT] = left; |
|
|
|
elem[RUNTIME_STYLE][LEFT] = rsLeft; |
|
} |
|
return ret === '' ? 'auto' : ret; |
|
} |
|
|
|
var getComputedStyleX = undefined; |
|
if (typeof window !== 'undefined') { |
|
getComputedStyleX = window.getComputedStyle ? _getComputedStyle : _getComputedStyleIE; |
|
} |
|
|
|
function each(arr, fn) { |
|
for (var i = 0; i < arr.length; i++) { |
|
fn(arr[i]); |
|
} |
|
} |
|
|
|
function isBorderBoxFn(elem) { |
|
return getComputedStyleX(elem, 'boxSizing') === 'border-box'; |
|
} |
|
|
|
var BOX_MODELS = ['margin', 'border', 'padding']; |
|
var CONTENT_INDEX = -1; |
|
var PADDING_INDEX = 2; |
|
var BORDER_INDEX = 1; |
|
var MARGIN_INDEX = 0; |
|
|
|
function swap(elem, options, callback) { |
|
var old = {}; |
|
var style = elem.style; |
|
var name = undefined; |
|
|
|
// Remember the old values, and insert the new ones |
|
for (name in options) { |
|
if (options.hasOwnProperty(name)) { |
|
old[name] = style[name]; |
|
style[name] = options[name]; |
|
} |
|
} |
|
|
|
callback.call(elem); |
|
|
|
// Revert the old values |
|
for (name in options) { |
|
if (options.hasOwnProperty(name)) { |
|
style[name] = old[name]; |
|
} |
|
} |
|
} |
|
|
|
function getPBMWidth(elem, props, which) { |
|
var value = 0; |
|
var prop = undefined; |
|
var j = undefined; |
|
var i = undefined; |
|
for (j = 0; j < props.length; j++) { |
|
prop = props[j]; |
|
if (prop) { |
|
for (i = 0; i < which.length; i++) { |
|
var cssProp = undefined; |
|
if (prop === 'border') { |
|
cssProp = prop + which[i] + 'Width'; |
|
} else { |
|
cssProp = prop + which[i]; |
|
} |
|
value += parseFloat(getComputedStyleX(elem, cssProp)) || 0; |
|
} |
|
} |
|
} |
|
return value; |
|
} |
|
|
|
/** |
|
* A crude way of determining if an object is a window |
|
* @member util |
|
*/ |
|
function isWindow(obj) { |
|
// must use == for ie8 |
|
/* eslint eqeqeq:0 */ |
|
return obj != null && obj == obj.window; |
|
} |
|
|
|
var domUtils = {}; |
|
|
|
each(['Width', 'Height'], function (name) { |
|
domUtils['doc' + name] = function (refWin) { |
|
var d = refWin.document; |
|
return Math.max( |
|
// firefox chrome documentElement.scrollHeight< body.scrollHeight |
|
// ie standard mode : documentElement.scrollHeight> body.scrollHeight |
|
d.documentElement['scroll' + name], |
|
// quirks : documentElement.scrollHeight 最大等于可视窗口多一点? |
|
d.body['scroll' + name], domUtils['viewport' + name](d)); |
|
}; |
|
|
|
domUtils['viewport' + name] = function (win) { |
|
// pc browser includes scrollbar in window.innerWidth |
|
var prop = 'client' + name; |
|
var doc = win.document; |
|
var body = doc.body; |
|
var documentElement = doc.documentElement; |
|
var documentElementProp = documentElement[prop]; |
|
// 标准模式取 documentElement |
|
// backcompat 取 body |
|
return doc.compatMode === 'CSS1Compat' && documentElementProp || body && body[prop] || documentElementProp; |
|
}; |
|
}); |
|
|
|
/* |
|
得到元素的大小信息 |
|
@param elem |
|
@param name |
|
@param {String} [extra] 'padding' : (css width) + padding |
|
'border' : (css width) + padding + border |
|
'margin' : (css width) + padding + border + margin |
|
*/ |
|
function getWH(elem, name, extra) { |
|
if (isWindow(elem)) { |
|
return name === 'width' ? domUtils.viewportWidth(elem) : domUtils.viewportHeight(elem); |
|
} else if (elem.nodeType === 9) { |
|
return name === 'width' ? domUtils.docWidth(elem) : domUtils.docHeight(elem); |
|
} |
|
var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom']; |
|
var borderBoxValue = name === 'width' ? elem.offsetWidth : elem.offsetHeight; |
|
var computedStyle = getComputedStyleX(elem); |
|
var isBorderBox = isBorderBoxFn(elem, computedStyle); |
|
var cssBoxValue = 0; |
|
if (borderBoxValue == null || borderBoxValue <= 0) { |
|
borderBoxValue = undefined; |
|
// Fall back to computed then un computed css if necessary |
|
cssBoxValue = getComputedStyleX(elem, name); |
|
if (cssBoxValue == null || Number(cssBoxValue) < 0) { |
|
cssBoxValue = elem.style[name] || 0; |
|
} |
|
// Normalize '', auto, and prepare for extra |
|
cssBoxValue = parseFloat(cssBoxValue) || 0; |
|
} |
|
if (extra === undefined) { |
|
extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX; |
|
} |
|
var borderBoxValueOrIsBorderBox = borderBoxValue !== undefined || isBorderBox; |
|
var val = borderBoxValue || cssBoxValue; |
|
if (extra === CONTENT_INDEX) { |
|
if (borderBoxValueOrIsBorderBox) { |
|
return val - getPBMWidth(elem, ['border', 'padding'], which, computedStyle); |
|
} |
|
return cssBoxValue; |
|
} |
|
if (borderBoxValueOrIsBorderBox) { |
|
var padding = extra === PADDING_INDEX ? -getPBMWidth(elem, ['border'], which, computedStyle) : getPBMWidth(elem, ['margin'], which, computedStyle); |
|
return val + (extra === BORDER_INDEX ? 0 : padding); |
|
} |
|
return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which, computedStyle); |
|
} |
|
|
|
var cssShow = { |
|
position: 'absolute', |
|
visibility: 'hidden', |
|
display: 'block' |
|
}; |
|
|
|
// fix #119 : https://github.com/kissyteam/kissy/issues/119 |
|
function getWHIgnoreDisplay(elem) { |
|
var val = undefined; |
|
var args = arguments; |
|
// in case elem is window |
|
// elem.offsetWidth === undefined |
|
if (elem.offsetWidth !== 0) { |
|
val = getWH.apply(undefined, args); |
|
} else { |
|
swap(elem, cssShow, function () { |
|
val = getWH.apply(undefined, args); |
|
}); |
|
} |
|
return val; |
|
} |
|
|
|
function css(el, name, v) { |
|
var value = v; |
|
if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') { |
|
for (var i in name) { |
|
if (name.hasOwnProperty(i)) { |
|
css(el, i, name[i]); |
|
} |
|
} |
|
return undefined; |
|
} |
|
if (typeof value !== 'undefined') { |
|
if (typeof value === 'number') { |
|
value += 'px'; |
|
} |
|
el.style[name] = value; |
|
return undefined; |
|
} |
|
return getComputedStyleX(el, name); |
|
} |
|
|
|
each(['width', 'height'], function (name) { |
|
var first = name.charAt(0).toUpperCase() + name.slice(1); |
|
domUtils['outer' + first] = function (el, includeMargin) { |
|
return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX); |
|
}; |
|
var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom']; |
|
|
|
domUtils[name] = function (elem, val) { |
|
if (val !== undefined) { |
|
if (elem) { |
|
var computedStyle = getComputedStyleX(elem); |
|
var isBorderBox = isBorderBoxFn(elem); |
|
if (isBorderBox) { |
|
val += getPBMWidth(elem, ['padding', 'border'], which, computedStyle); |
|
} |
|
return css(elem, name, val); |
|
} |
|
return undefined; |
|
} |
|
return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX); |
|
}; |
|
}); |
|
|
|
// 设置 elem 相对 elem.ownerDocument 的坐标 |
|
function setOffset(elem, offset) { |
|
// set position first, in-case top/left are set even on static elem |
|
if (css(elem, 'position') === 'static') { |
|
elem.style.position = 'relative'; |
|
} |
|
|
|
var old = getOffset(elem); |
|
var ret = {}; |
|
var current = undefined; |
|
var key = undefined; |
|
|
|
for (key in offset) { |
|
if (offset.hasOwnProperty(key)) { |
|
current = parseFloat(css(elem, key)) || 0; |
|
ret[key] = current + offset[key] - old[key]; |
|
} |
|
} |
|
css(elem, ret); |
|
} |
|
|
|
module.exports = _extends({ |
|
getWindow: function getWindow(node) { |
|
var doc = node.ownerDocument || node; |
|
return doc.defaultView || doc.parentWindow; |
|
}, |
|
offset: function offset(el, value) { |
|
if (typeof value !== 'undefined') { |
|
setOffset(el, value); |
|
} else { |
|
return getOffset(el); |
|
} |
|
}, |
|
|
|
isWindow: isWindow, |
|
each: each, |
|
css: css, |
|
clone: function clone(obj) { |
|
var ret = {}; |
|
for (var i in obj) { |
|
if (obj.hasOwnProperty(i)) { |
|
ret[i] = obj[i]; |
|
} |
|
} |
|
var overflow = obj.overflow; |
|
if (overflow) { |
|
for (var i in obj) { |
|
if (obj.hasOwnProperty(i)) { |
|
ret.overflow[i] = obj.overflow[i]; |
|
} |
|
} |
|
} |
|
return ret; |
|
}, |
|
scrollLeft: function scrollLeft(w, v) { |
|
if (isWindow(w)) { |
|
if (v === undefined) { |
|
return getScrollLeft(w); |
|
} |
|
window.scrollTo(v, getScrollTop(w)); |
|
} else { |
|
if (v === undefined) { |
|
return w.scrollLeft; |
|
} |
|
w.scrollLeft = v; |
|
} |
|
}, |
|
scrollTop: function scrollTop(w, v) { |
|
if (isWindow(w)) { |
|
if (v === undefined) { |
|
return getScrollTop(w); |
|
} |
|
window.scrollTo(getScrollLeft(w), v); |
|
} else { |
|
if (v === undefined) { |
|
return w.scrollTop; |
|
} |
|
w.scrollTop = v; |
|
} |
|
}, |
|
|
|
viewportWidth: 0, |
|
viewportHeight: 0 |
|
}, domUtils); |
|
|
|
/***/ }), |
|
/* 115 */, |
|
/* 116 */, |
|
/* 117 */, |
|
/* 118 */, |
|
/* 119 */ |
|
/***/ (function(module, exports) { |
|
|
|
function _extends() { |
|
module.exports = _extends = Object.assign || function (target) { |
|
for (var i = 1; i < arguments.length; i++) { |
|
var source = arguments[i]; |
|
|
|
for (var key in source) { |
|
if (Object.prototype.hasOwnProperty.call(source, key)) { |
|
target[key] = source[key]; |
|
} |
|
} |
|
} |
|
|
|
return target; |
|
}; |
|
|
|
return _extends.apply(this, arguments); |
|
} |
|
|
|
module.exports = _extends; |
|
|
|
/***/ }), |
|
/* 120 */ |
|
/***/ (function(module, exports) { |
|
|
|
function _objectWithoutPropertiesLoose(source, excluded) { |
|
if (source == null) return {}; |
|
var target = {}; |
|
var sourceKeys = Object.keys(source); |
|
var key, i; |
|
|
|
for (i = 0; i < sourceKeys.length; i++) { |
|
key = sourceKeys[i]; |
|
if (excluded.indexOf(key) >= 0) continue; |
|
target[key] = source[key]; |
|
} |
|
|
|
return target; |
|
} |
|
|
|
module.exports = _objectWithoutPropertiesLoose; |
|
|
|
/***/ }), |
|
/* 121 */ |
|
/***/ (function(module, exports) { |
|
|
|
function _inheritsLoose(subClass, superClass) { |
|
subClass.prototype = Object.create(superClass.prototype); |
|
subClass.prototype.constructor = subClass; |
|
subClass.__proto__ = superClass; |
|
} |
|
|
|
module.exports = _inheritsLoose; |
|
|
|
/***/ }), |
|
/* 122 */ |
|
/***/ (function(module, exports) { |
|
|
|
function _assertThisInitialized(self) { |
|
if (self === void 0) { |
|
throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); |
|
} |
|
|
|
return self; |
|
} |
|
|
|
module.exports = _assertThisInitialized; |
|
|
|
/***/ }), |
|
/* 123 */, |
|
/* 124 */, |
|
/* 125 */, |
|
/* 126 */, |
|
/* 127 */, |
|
/* 128 */, |
|
/* 129 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var hasMap = typeof Map === 'function' && Map.prototype; |
|
var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null; |
|
var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null; |
|
var mapForEach = hasMap && Map.prototype.forEach; |
|
var hasSet = typeof Set === 'function' && Set.prototype; |
|
var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null; |
|
var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null; |
|
var setForEach = hasSet && Set.prototype.forEach; |
|
var booleanValueOf = Boolean.prototype.valueOf; |
|
var objectToString = Object.prototype.toString; |
|
var bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null; |
|
|
|
var inspectCustom = __webpack_require__(250).custom; |
|
var inspectSymbol = (inspectCustom && isSymbol(inspectCustom)) ? inspectCustom : null; |
|
|
|
module.exports = function inspect_ (obj, opts, depth, seen) { |
|
if (!opts) opts = {}; |
|
|
|
if (has(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle !== 'double')) { |
|
throw new TypeError('option "quoteStyle" must be "single" or "double"'); |
|
} |
|
|
|
if (typeof obj === 'undefined') { |
|
return 'undefined'; |
|
} |
|
if (obj === null) { |
|
return 'null'; |
|
} |
|
if (typeof obj === 'boolean') { |
|
return obj ? 'true' : 'false'; |
|
} |
|
|
|
if (typeof obj === 'string') { |
|
return inspectString(obj, opts); |
|
} |
|
if (typeof obj === 'number') { |
|
if (obj === 0) { |
|
return Infinity / obj > 0 ? '0' : '-0'; |
|
} |
|
return String(obj); |
|
} |
|
if (typeof obj === 'bigint') { |
|
return String(obj) + 'n'; |
|
} |
|
|
|
var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth; |
|
if (typeof depth === 'undefined') depth = 0; |
|
if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') { |
|
return '[Object]'; |
|
} |
|
|
|
if (typeof seen === 'undefined') seen = []; |
|
else if (indexOf(seen, obj) >= 0) { |
|
return '[Circular]'; |
|
} |
|
|
|
function inspect (value, from) { |
|
if (from) { |
|
seen = seen.slice(); |
|
seen.push(from); |
|
} |
|
return inspect_(value, opts, depth + 1, seen); |
|
} |
|
|
|
if (typeof obj === 'function') { |
|
var name = nameOf(obj); |
|
return '[Function' + (name ? ': ' + name : '') + ']'; |
|
} |
|
if (isSymbol(obj)) { |
|
var symString = Symbol.prototype.toString.call(obj); |
|
return typeof obj === 'object' ? markBoxed(symString) : symString; |
|
} |
|
if (isElement(obj)) { |
|
var s = '<' + String(obj.nodeName).toLowerCase(); |
|
var attrs = obj.attributes || []; |
|
for (var i = 0; i < attrs.length; i++) { |
|
s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts); |
|
} |
|
s += '>'; |
|
if (obj.childNodes && obj.childNodes.length) s += '...'; |
|
s += '</' + String(obj.nodeName).toLowerCase() + '>'; |
|
return s; |
|
} |
|
if (isArray(obj)) { |
|
if (obj.length === 0) return '[]'; |
|
return '[ ' + arrObjKeys(obj, inspect).join(', ') + ' ]'; |
|
} |
|
if (isError(obj)) { |
|
var parts = arrObjKeys(obj, inspect); |
|
if (parts.length === 0) return '[' + String(obj) + ']'; |
|
return '{ [' + String(obj) + '] ' + parts.join(', ') + ' }'; |
|
} |
|
if (typeof obj === 'object') { |
|
if (inspectSymbol && typeof obj[inspectSymbol] === 'function') { |
|
return obj[inspectSymbol](); |
|
} else if (typeof obj.inspect === 'function') { |
|
return obj.inspect(); |
|
} |
|
} |
|
if (isMap(obj)) { |
|
var parts = []; |
|
mapForEach.call(obj, function (value, key) { |
|
parts.push(inspect(key, obj) + ' => ' + inspect(value, obj)); |
|
}); |
|
return collectionOf('Map', mapSize.call(obj), parts); |
|
} |
|
if (isSet(obj)) { |
|
var parts = []; |
|
setForEach.call(obj, function (value ) { |
|
parts.push(inspect(value, obj)); |
|
}); |
|
return collectionOf('Set', setSize.call(obj), parts); |
|
} |
|
if (isNumber(obj)) { |
|
return markBoxed(inspect(Number(obj))); |
|
} |
|
if (isBigInt(obj)) { |
|
return markBoxed(inspect(bigIntValueOf.call(obj))); |
|
} |
|
if (isBoolean(obj)) { |
|
return markBoxed(booleanValueOf.call(obj)); |
|
} |
|
if (isString(obj)) { |
|
return markBoxed(inspect(String(obj))); |
|
} |
|
if (!isDate(obj) && !isRegExp(obj)) { |
|
var xs = arrObjKeys(obj, inspect); |
|
if (xs.length === 0) return '{}'; |
|
return '{ ' + xs.join(', ') + ' }'; |
|
} |
|
return String(obj); |
|
}; |
|
|
|
function wrapQuotes (s, defaultStyle, opts) { |
|
var quoteChar = (opts.quoteStyle || defaultStyle) === 'double' ? '"' : "'"; |
|
return quoteChar + s + quoteChar; |
|
} |
|
|
|
function quote (s) { |
|
return String(s).replace(/"/g, '"'); |
|
} |
|
|
|
function isArray (obj) { return toStr(obj) === '[object Array]'; } |
|
function isDate (obj) { return toStr(obj) === '[object Date]'; } |
|
function isRegExp (obj) { return toStr(obj) === '[object RegExp]'; } |
|
function isError (obj) { return toStr(obj) === '[object Error]'; } |
|
function isSymbol (obj) { return toStr(obj) === '[object Symbol]'; } |
|
function isString (obj) { return toStr(obj) === '[object String]'; } |
|
function isNumber (obj) { return toStr(obj) === '[object Number]'; } |
|
function isBigInt (obj) { return toStr(obj) === '[object BigInt]'; } |
|
function isBoolean (obj) { return toStr(obj) === '[object Boolean]'; } |
|
|
|
var hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; }; |
|
function has (obj, key) { |
|
return hasOwn.call(obj, key); |
|
} |
|
|
|
function toStr (obj) { |
|
return objectToString.call(obj); |
|
} |
|
|
|
function nameOf (f) { |
|
if (f.name) return f.name; |
|
var m = String(f).match(/^function\s*([\w$]+)/); |
|
if (m) return m[1]; |
|
} |
|
|
|
function indexOf (xs, x) { |
|
if (xs.indexOf) return xs.indexOf(x); |
|
for (var i = 0, l = xs.length; i < l; i++) { |
|
if (xs[i] === x) return i; |
|
} |
|
return -1; |
|
} |
|
|
|
function isMap (x) { |
|
if (!mapSize) { |
|
return false; |
|
} |
|
try { |
|
mapSize.call(x); |
|
try { |
|
setSize.call(x); |
|
} catch (s) { |
|
return true; |
|
} |
|
return x instanceof Map; // core-js workaround, pre-v2.5.0 |
|
} catch (e) {} |
|
return false; |
|
} |
|
|
|
function isSet (x) { |
|
if (!setSize) { |
|
return false; |
|
} |
|
try { |
|
setSize.call(x); |
|
try { |
|
mapSize.call(x); |
|
} catch (m) { |
|
return true; |
|
} |
|
return x instanceof Set; // core-js workaround, pre-v2.5.0 |
|
} catch (e) {} |
|
return false; |
|
} |
|
|
|
function isElement (x) { |
|
if (!x || typeof x !== 'object') return false; |
|
if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) { |
|
return true; |
|
} |
|
return typeof x.nodeName === 'string' |
|
&& typeof x.getAttribute === 'function' |
|
; |
|
} |
|
|
|
function inspectString (str, opts) { |
|
var s = str.replace(/(['\\])/g, '\\$1').replace(/[\x00-\x1f]/g, lowbyte); |
|
return wrapQuotes(s, 'single', opts); |
|
} |
|
|
|
function lowbyte (c) { |
|
var n = c.charCodeAt(0); |
|
var x = { 8: 'b', 9: 't', 10: 'n', 12: 'f', 13: 'r' }[n]; |
|
if (x) return '\\' + x; |
|
return '\\x' + (n < 0x10 ? '0' : '') + n.toString(16); |
|
} |
|
|
|
function markBoxed (str) { |
|
return 'Object(' + str + ')'; |
|
} |
|
|
|
function collectionOf (type, size, entries) { |
|
return type + ' (' + size + ') {' + entries.join(', ') + '}'; |
|
} |
|
|
|
function arrObjKeys (obj, inspect) { |
|
var isArr = isArray(obj); |
|
var xs = []; |
|
if (isArr) { |
|
xs.length = obj.length; |
|
for (var i = 0; i < obj.length; i++) { |
|
xs[i] = has(obj, i) ? inspect(obj[i], obj) : ''; |
|
} |
|
} |
|
for (var key in obj) { |
|
if (!has(obj, key)) continue; |
|
if (isArr && String(Number(key)) === key && key < obj.length) continue; |
|
if (/[^\w$]/.test(key)) { |
|
xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj)); |
|
} else { |
|
xs.push(key + ': ' + inspect(obj[key], obj)); |
|
} |
|
} |
|
return xs; |
|
} |
|
|
|
|
|
/***/ }), |
|
/* 130 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
module.exports = Number.isNaN || function isNaN(a) { |
|
return a !== a; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 131 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
module.exports = function forEach(array, callback) { |
|
for (var i = 0; i < array.length; i += 1) { |
|
callback(array[i], i, array); // eslint-disable-line callback-return |
|
} |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 132 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
module.exports = function every(array, predicate) { |
|
for (var i = 0; i < array.length; i += 1) { |
|
if (!predicate(array[i], i, array)) { |
|
return false; |
|
} |
|
} |
|
return true; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 133 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.PureCalendarDay = undefined; |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _reactAddonsShallowCompare = __webpack_require__(76); |
|
|
|
var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); |
|
|
|
var _reactMomentProptypes = __webpack_require__(66); |
|
|
|
var _reactMomentProptypes2 = _interopRequireDefault(_reactMomentProptypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _getCalendarDaySettings = __webpack_require__(172); |
|
|
|
var _getCalendarDaySettings2 = _interopRequireDefault(_getCalendarDaySettings); |
|
|
|
var _ModifiersShape = __webpack_require__(103); |
|
|
|
var _ModifiersShape2 = _interopRequireDefault(_ModifiersShape); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, { |
|
day: _reactMomentProptypes2['default'].momentObj, |
|
daySize: _airbnbPropTypes.nonNegativeInteger, |
|
isOutsideDay: _propTypes2['default'].bool, |
|
modifiers: _ModifiersShape2['default'], |
|
isFocused: _propTypes2['default'].bool, |
|
tabIndex: _propTypes2['default'].oneOf([0, -1]), |
|
onDayClick: _propTypes2['default'].func, |
|
onDayMouseEnter: _propTypes2['default'].func, |
|
onDayMouseLeave: _propTypes2['default'].func, |
|
renderDayContents: _propTypes2['default'].func, |
|
ariaLabelFormat: _propTypes2['default'].string, |
|
|
|
// internationalization |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.CalendarDayPhrases)) |
|
})); |
|
|
|
var defaultProps = { |
|
day: (0, _moment2['default'])(), |
|
daySize: _constants.DAY_SIZE, |
|
isOutsideDay: false, |
|
modifiers: new Set(), |
|
isFocused: false, |
|
tabIndex: -1, |
|
onDayClick: function () { |
|
function onDayClick() {} |
|
|
|
return onDayClick; |
|
}(), |
|
onDayMouseEnter: function () { |
|
function onDayMouseEnter() {} |
|
|
|
return onDayMouseEnter; |
|
}(), |
|
onDayMouseLeave: function () { |
|
function onDayMouseLeave() {} |
|
|
|
return onDayMouseLeave; |
|
}(), |
|
|
|
renderDayContents: null, |
|
ariaLabelFormat: 'dddd, LL', |
|
|
|
// internationalization |
|
phrases: _defaultPhrases.CalendarDayPhrases |
|
}; |
|
|
|
var CalendarDay = function (_React$Component) { |
|
_inherits(CalendarDay, _React$Component); |
|
|
|
function CalendarDay() { |
|
var _ref; |
|
|
|
_classCallCheck(this, CalendarDay); |
|
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { |
|
args[_key] = arguments[_key]; |
|
} |
|
|
|
var _this = _possibleConstructorReturn(this, (_ref = CalendarDay.__proto__ || Object.getPrototypeOf(CalendarDay)).call.apply(_ref, [this].concat(args))); |
|
|
|
_this.setButtonRef = _this.setButtonRef.bind(_this); |
|
return _this; |
|
} |
|
|
|
_createClass(CalendarDay, [{ |
|
key: 'shouldComponentUpdate', |
|
value: function () { |
|
function shouldComponentUpdate(nextProps, nextState) { |
|
return (0, _reactAddonsShallowCompare2['default'])(this, nextProps, nextState); |
|
} |
|
|
|
return shouldComponentUpdate; |
|
}() |
|
}, { |
|
key: 'componentDidUpdate', |
|
value: function () { |
|
function componentDidUpdate(prevProps) { |
|
var _props = this.props, |
|
isFocused = _props.isFocused, |
|
tabIndex = _props.tabIndex; |
|
|
|
if (tabIndex === 0) { |
|
if (isFocused || tabIndex !== prevProps.tabIndex) { |
|
this.buttonRef.focus(); |
|
} |
|
} |
|
} |
|
|
|
return componentDidUpdate; |
|
}() |
|
}, { |
|
key: 'onDayClick', |
|
value: function () { |
|
function onDayClick(day, e) { |
|
var onDayClick = this.props.onDayClick; |
|
|
|
onDayClick(day, e); |
|
} |
|
|
|
return onDayClick; |
|
}() |
|
}, { |
|
key: 'onDayMouseEnter', |
|
value: function () { |
|
function onDayMouseEnter(day, e) { |
|
var onDayMouseEnter = this.props.onDayMouseEnter; |
|
|
|
onDayMouseEnter(day, e); |
|
} |
|
|
|
return onDayMouseEnter; |
|
}() |
|
}, { |
|
key: 'onDayMouseLeave', |
|
value: function () { |
|
function onDayMouseLeave(day, e) { |
|
var onDayMouseLeave = this.props.onDayMouseLeave; |
|
|
|
onDayMouseLeave(day, e); |
|
} |
|
|
|
return onDayMouseLeave; |
|
}() |
|
}, { |
|
key: 'onKeyDown', |
|
value: function () { |
|
function onKeyDown(day, e) { |
|
var onDayClick = this.props.onDayClick; |
|
var key = e.key; |
|
|
|
if (key === 'Enter' || key === ' ') { |
|
onDayClick(day, e); |
|
} |
|
} |
|
|
|
return onKeyDown; |
|
}() |
|
}, { |
|
key: 'setButtonRef', |
|
value: function () { |
|
function setButtonRef(ref) { |
|
this.buttonRef = ref; |
|
} |
|
|
|
return setButtonRef; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _this2 = this; |
|
|
|
var _props2 = this.props, |
|
day = _props2.day, |
|
ariaLabelFormat = _props2.ariaLabelFormat, |
|
daySize = _props2.daySize, |
|
isOutsideDay = _props2.isOutsideDay, |
|
modifiers = _props2.modifiers, |
|
renderDayContents = _props2.renderDayContents, |
|
tabIndex = _props2.tabIndex, |
|
styles = _props2.styles, |
|
phrases = _props2.phrases; |
|
|
|
|
|
if (!day) return _react2['default'].createElement('td', null); |
|
|
|
var _getCalendarDaySettin = (0, _getCalendarDaySettings2['default'])(day, ariaLabelFormat, daySize, modifiers, phrases), |
|
daySizeStyles = _getCalendarDaySettin.daySizeStyles, |
|
useDefaultCursor = _getCalendarDaySettin.useDefaultCursor, |
|
selected = _getCalendarDaySettin.selected, |
|
hoveredSpan = _getCalendarDaySettin.hoveredSpan, |
|
isOutsideRange = _getCalendarDaySettin.isOutsideRange, |
|
ariaLabel = _getCalendarDaySettin.ariaLabel; |
|
|
|
return _react2['default'].createElement( |
|
'td', |
|
_extends({}, (0, _reactWithStyles.css)(styles.CalendarDay, useDefaultCursor && styles.CalendarDay__defaultCursor, styles.CalendarDay__default, isOutsideDay && styles.CalendarDay__outside, modifiers.has('today') && styles.CalendarDay__today, modifiers.has('first-day-of-week') && styles.CalendarDay__firstDayOfWeek, modifiers.has('last-day-of-week') && styles.CalendarDay__lastDayOfWeek, modifiers.has('hovered-offset') && styles.CalendarDay__hovered_offset, modifiers.has('highlighted-calendar') && styles.CalendarDay__highlighted_calendar, modifiers.has('blocked-minimum-nights') && styles.CalendarDay__blocked_minimum_nights, modifiers.has('blocked-calendar') && styles.CalendarDay__blocked_calendar, hoveredSpan && styles.CalendarDay__hovered_span, modifiers.has('selected-span') && styles.CalendarDay__selected_span, modifiers.has('last-in-range') && styles.CalendarDay__last_in_range, modifiers.has('selected-start') && styles.CalendarDay__selected_start, modifiers.has('selected-end') && styles.CalendarDay__selected_end, selected && styles.CalendarDay__selected, isOutsideRange && styles.CalendarDay__blocked_out_of_range, daySizeStyles), { |
|
role: 'button' // eslint-disable-line jsx-a11y/no-noninteractive-element-to-interactive-role |
|
, ref: this.setButtonRef, |
|
'aria-label': ariaLabel, |
|
onMouseEnter: function () { |
|
function onMouseEnter(e) { |
|
_this2.onDayMouseEnter(day, e); |
|
} |
|
|
|
return onMouseEnter; |
|
}(), |
|
onMouseLeave: function () { |
|
function onMouseLeave(e) { |
|
_this2.onDayMouseLeave(day, e); |
|
} |
|
|
|
return onMouseLeave; |
|
}(), |
|
onMouseUp: function () { |
|
function onMouseUp(e) { |
|
e.currentTarget.blur(); |
|
} |
|
|
|
return onMouseUp; |
|
}(), |
|
onClick: function () { |
|
function onClick(e) { |
|
_this2.onDayClick(day, e); |
|
} |
|
|
|
return onClick; |
|
}(), |
|
onKeyDown: function () { |
|
function onKeyDown(e) { |
|
_this2.onKeyDown(day, e); |
|
} |
|
|
|
return onKeyDown; |
|
}(), |
|
tabIndex: tabIndex |
|
}), |
|
renderDayContents ? renderDayContents(day, modifiers) : day.format('D') |
|
); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return CalendarDay; |
|
}(_react2['default'].Component); |
|
|
|
CalendarDay.propTypes = propTypes; |
|
CalendarDay.defaultProps = defaultProps; |
|
|
|
exports.PureCalendarDay = CalendarDay; |
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref2) { |
|
var _ref2$reactDates = _ref2.reactDates, |
|
color = _ref2$reactDates.color, |
|
font = _ref2$reactDates.font; |
|
return { |
|
CalendarDay: { |
|
boxSizing: 'border-box', |
|
cursor: 'pointer', |
|
fontSize: font.size, |
|
textAlign: 'center', |
|
|
|
':active': { |
|
outline: 0 |
|
} |
|
}, |
|
|
|
CalendarDay__defaultCursor: { |
|
cursor: 'default' |
|
}, |
|
|
|
CalendarDay__default: { |
|
border: '1px solid ' + String(color.core.borderLight), |
|
color: color.text, |
|
background: color.background, |
|
|
|
':hover': { |
|
background: color.core.borderLight, |
|
border: '1px double ' + String(color.core.borderLight), |
|
color: 'inherit' |
|
} |
|
}, |
|
|
|
CalendarDay__hovered_offset: { |
|
background: color.core.borderBright, |
|
border: '1px double ' + String(color.core.borderLight), |
|
color: 'inherit' |
|
}, |
|
|
|
CalendarDay__outside: { |
|
border: 0, |
|
background: color.outside.backgroundColor, |
|
color: color.outside.color, |
|
|
|
':hover': { |
|
border: 0 |
|
} |
|
}, |
|
|
|
CalendarDay__blocked_minimum_nights: { |
|
background: color.minimumNights.backgroundColor, |
|
border: '1px solid ' + String(color.minimumNights.borderColor), |
|
color: color.minimumNights.color, |
|
|
|
':hover': { |
|
background: color.minimumNights.backgroundColor_hover, |
|
color: color.minimumNights.color_active |
|
}, |
|
|
|
':active': { |
|
background: color.minimumNights.backgroundColor_active, |
|
color: color.minimumNights.color_active |
|
} |
|
}, |
|
|
|
CalendarDay__highlighted_calendar: { |
|
background: color.highlighted.backgroundColor, |
|
color: color.highlighted.color, |
|
|
|
':hover': { |
|
background: color.highlighted.backgroundColor_hover, |
|
color: color.highlighted.color_active |
|
}, |
|
|
|
':active': { |
|
background: color.highlighted.backgroundColor_active, |
|
color: color.highlighted.color_active |
|
} |
|
}, |
|
|
|
CalendarDay__selected_span: { |
|
background: color.selectedSpan.backgroundColor, |
|
border: '1px solid ' + String(color.selectedSpan.borderColor), |
|
color: color.selectedSpan.color, |
|
|
|
':hover': { |
|
background: color.selectedSpan.backgroundColor_hover, |
|
border: '1px solid ' + String(color.selectedSpan.borderColor), |
|
color: color.selectedSpan.color_active |
|
}, |
|
|
|
':active': { |
|
background: color.selectedSpan.backgroundColor_active, |
|
border: '1px solid ' + String(color.selectedSpan.borderColor), |
|
color: color.selectedSpan.color_active |
|
} |
|
}, |
|
|
|
CalendarDay__last_in_range: { |
|
borderRight: color.core.primary |
|
}, |
|
|
|
CalendarDay__selected: { |
|
background: color.selected.backgroundColor, |
|
border: '1px solid ' + String(color.selected.borderColor), |
|
color: color.selected.color, |
|
|
|
':hover': { |
|
background: color.selected.backgroundColor_hover, |
|
border: '1px solid ' + String(color.selected.borderColor), |
|
color: color.selected.color_active |
|
}, |
|
|
|
':active': { |
|
background: color.selected.backgroundColor_active, |
|
border: '1px solid ' + String(color.selected.borderColor), |
|
color: color.selected.color_active |
|
} |
|
}, |
|
|
|
CalendarDay__hovered_span: { |
|
background: color.hoveredSpan.backgroundColor, |
|
border: '1px solid ' + String(color.hoveredSpan.borderColor), |
|
color: color.hoveredSpan.color, |
|
|
|
':hover': { |
|
background: color.hoveredSpan.backgroundColor_hover, |
|
border: '1px solid ' + String(color.hoveredSpan.borderColor), |
|
color: color.hoveredSpan.color_active |
|
}, |
|
|
|
':active': { |
|
background: color.hoveredSpan.backgroundColor_active, |
|
border: '1px solid ' + String(color.hoveredSpan.borderColor), |
|
color: color.hoveredSpan.color_active |
|
} |
|
}, |
|
|
|
CalendarDay__blocked_calendar: { |
|
background: color.blocked_calendar.backgroundColor, |
|
border: '1px solid ' + String(color.blocked_calendar.borderColor), |
|
color: color.blocked_calendar.color, |
|
|
|
':hover': { |
|
background: color.blocked_calendar.backgroundColor_hover, |
|
border: '1px solid ' + String(color.blocked_calendar.borderColor), |
|
color: color.blocked_calendar.color_active |
|
}, |
|
|
|
':active': { |
|
background: color.blocked_calendar.backgroundColor_active, |
|
border: '1px solid ' + String(color.blocked_calendar.borderColor), |
|
color: color.blocked_calendar.color_active |
|
} |
|
}, |
|
|
|
CalendarDay__blocked_out_of_range: { |
|
background: color.blocked_out_of_range.backgroundColor, |
|
border: '1px solid ' + String(color.blocked_out_of_range.borderColor), |
|
color: color.blocked_out_of_range.color, |
|
|
|
':hover': { |
|
background: color.blocked_out_of_range.backgroundColor_hover, |
|
border: '1px solid ' + String(color.blocked_out_of_range.borderColor), |
|
color: color.blocked_out_of_range.color_active |
|
}, |
|
|
|
':active': { |
|
background: color.blocked_out_of_range.backgroundColor_active, |
|
border: '1px solid ' + String(color.blocked_out_of_range.borderColor), |
|
color: color.blocked_out_of_range.color_active |
|
} |
|
}, |
|
|
|
CalendarDay__selected_start: {}, |
|
CalendarDay__selected_end: {}, |
|
CalendarDay__today: {}, |
|
CalendarDay__firstDayOfWeek: {}, |
|
CalendarDay__lastDayOfWeek: {} |
|
}; |
|
})(CalendarDay); |
|
|
|
/***/ }), |
|
/* 134 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
// eslint-disable-next-line import/no-unresolved |
|
module.exports = __webpack_require__(286); |
|
|
|
|
|
/***/ }), |
|
/* 135 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var define = __webpack_require__(55); |
|
|
|
var implementation = __webpack_require__(178); |
|
var getPolyfill = __webpack_require__(185); |
|
var shim = __webpack_require__(292); |
|
|
|
var polyfill = getPolyfill(); |
|
|
|
define(polyfill, { |
|
getPolyfill: getPolyfill, |
|
implementation: implementation, |
|
shim: shim |
|
}); |
|
|
|
module.exports = polyfill; |
|
|
|
|
|
/***/ }), |
|
/* 136 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
/* globals |
|
Set, |
|
Map, |
|
WeakSet, |
|
WeakMap, |
|
|
|
Promise, |
|
|
|
Symbol, |
|
Proxy, |
|
|
|
Atomics, |
|
SharedArrayBuffer, |
|
|
|
ArrayBuffer, |
|
DataView, |
|
Uint8Array, |
|
Float32Array, |
|
Float64Array, |
|
Int8Array, |
|
Int16Array, |
|
Int32Array, |
|
Uint8ClampedArray, |
|
Uint16Array, |
|
Uint32Array, |
|
*/ |
|
|
|
var undefined; // eslint-disable-line no-shadow-restricted-names |
|
|
|
var ThrowTypeError = Object.getOwnPropertyDescriptor |
|
? (function () { return Object.getOwnPropertyDescriptor(arguments, 'callee').get; }()) |
|
: function () { throw new TypeError(); }; |
|
|
|
var hasSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol'; |
|
|
|
var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto |
|
|
|
var generator; // = function * () {}; |
|
var generatorFunction = generator ? getProto(generator) : undefined; |
|
var asyncFn; // async function() {}; |
|
var asyncFunction = asyncFn ? asyncFn.constructor : undefined; |
|
var asyncGen; // async function * () {}; |
|
var asyncGenFunction = asyncGen ? getProto(asyncGen) : undefined; |
|
var asyncGenIterator = asyncGen ? asyncGen() : undefined; |
|
|
|
var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array); |
|
|
|
var INTRINSICS = { |
|
'$ %Array%': Array, |
|
'$ %ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer, |
|
'$ %ArrayBufferPrototype%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer.prototype, |
|
'$ %ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined, |
|
'$ %ArrayPrototype%': Array.prototype, |
|
'$ %ArrayProto_entries%': Array.prototype.entries, |
|
'$ %ArrayProto_forEach%': Array.prototype.forEach, |
|
'$ %ArrayProto_keys%': Array.prototype.keys, |
|
'$ %ArrayProto_values%': Array.prototype.values, |
|
'$ %AsyncFromSyncIteratorPrototype%': undefined, |
|
'$ %AsyncFunction%': asyncFunction, |
|
'$ %AsyncFunctionPrototype%': asyncFunction ? asyncFunction.prototype : undefined, |
|
'$ %AsyncGenerator%': asyncGen ? getProto(asyncGenIterator) : undefined, |
|
'$ %AsyncGeneratorFunction%': asyncGenFunction, |
|
'$ %AsyncGeneratorPrototype%': asyncGenFunction ? asyncGenFunction.prototype : undefined, |
|
'$ %AsyncIteratorPrototype%': asyncGenIterator && hasSymbols && Symbol.asyncIterator ? asyncGenIterator[Symbol.asyncIterator]() : undefined, |
|
'$ %Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics, |
|
'$ %Boolean%': Boolean, |
|
'$ %BooleanPrototype%': Boolean.prototype, |
|
'$ %DataView%': typeof DataView === 'undefined' ? undefined : DataView, |
|
'$ %DataViewPrototype%': typeof DataView === 'undefined' ? undefined : DataView.prototype, |
|
'$ %Date%': Date, |
|
'$ %DatePrototype%': Date.prototype, |
|
'$ %decodeURI%': decodeURI, |
|
'$ %decodeURIComponent%': decodeURIComponent, |
|
'$ %encodeURI%': encodeURI, |
|
'$ %encodeURIComponent%': encodeURIComponent, |
|
'$ %Error%': Error, |
|
'$ %ErrorPrototype%': Error.prototype, |
|
'$ %eval%': eval, // eslint-disable-line no-eval |
|
'$ %EvalError%': EvalError, |
|
'$ %EvalErrorPrototype%': EvalError.prototype, |
|
'$ %Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array, |
|
'$ %Float32ArrayPrototype%': typeof Float32Array === 'undefined' ? undefined : Float32Array.prototype, |
|
'$ %Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array, |
|
'$ %Float64ArrayPrototype%': typeof Float64Array === 'undefined' ? undefined : Float64Array.prototype, |
|
'$ %Function%': Function, |
|
'$ %FunctionPrototype%': Function.prototype, |
|
'$ %Generator%': generator ? getProto(generator()) : undefined, |
|
'$ %GeneratorFunction%': generatorFunction, |
|
'$ %GeneratorPrototype%': generatorFunction ? generatorFunction.prototype : undefined, |
|
'$ %Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array, |
|
'$ %Int8ArrayPrototype%': typeof Int8Array === 'undefined' ? undefined : Int8Array.prototype, |
|
'$ %Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array, |
|
'$ %Int16ArrayPrototype%': typeof Int16Array === 'undefined' ? undefined : Int8Array.prototype, |
|
'$ %Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array, |
|
'$ %Int32ArrayPrototype%': typeof Int32Array === 'undefined' ? undefined : Int32Array.prototype, |
|
'$ %isFinite%': isFinite, |
|
'$ %isNaN%': isNaN, |
|
'$ %IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined, |
|
'$ %JSON%': JSON, |
|
'$ %JSONParse%': JSON.parse, |
|
'$ %Map%': typeof Map === 'undefined' ? undefined : Map, |
|
'$ %MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()), |
|
'$ %MapPrototype%': typeof Map === 'undefined' ? undefined : Map.prototype, |
|
'$ %Math%': Math, |
|
'$ %Number%': Number, |
|
'$ %NumberPrototype%': Number.prototype, |
|
'$ %Object%': Object, |
|
'$ %ObjectPrototype%': Object.prototype, |
|
'$ %ObjProto_toString%': Object.prototype.toString, |
|
'$ %ObjProto_valueOf%': Object.prototype.valueOf, |
|
'$ %parseFloat%': parseFloat, |
|
'$ %parseInt%': parseInt, |
|
'$ %Promise%': typeof Promise === 'undefined' ? undefined : Promise, |
|
'$ %PromisePrototype%': typeof Promise === 'undefined' ? undefined : Promise.prototype, |
|
'$ %PromiseProto_then%': typeof Promise === 'undefined' ? undefined : Promise.prototype.then, |
|
'$ %Promise_all%': typeof Promise === 'undefined' ? undefined : Promise.all, |
|
'$ %Promise_reject%': typeof Promise === 'undefined' ? undefined : Promise.reject, |
|
'$ %Promise_resolve%': typeof Promise === 'undefined' ? undefined : Promise.resolve, |
|
'$ %Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy, |
|
'$ %RangeError%': RangeError, |
|
'$ %RangeErrorPrototype%': RangeError.prototype, |
|
'$ %ReferenceError%': ReferenceError, |
|
'$ %ReferenceErrorPrototype%': ReferenceError.prototype, |
|
'$ %Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect, |
|
'$ %RegExp%': RegExp, |
|
'$ %RegExpPrototype%': RegExp.prototype, |
|
'$ %Set%': typeof Set === 'undefined' ? undefined : Set, |
|
'$ %SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()), |
|
'$ %SetPrototype%': typeof Set === 'undefined' ? undefined : Set.prototype, |
|
'$ %SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer, |
|
'$ %SharedArrayBufferPrototype%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer.prototype, |
|
'$ %String%': String, |
|
'$ %StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined, |
|
'$ %StringPrototype%': String.prototype, |
|
'$ %Symbol%': hasSymbols ? Symbol : undefined, |
|
'$ %SymbolPrototype%': hasSymbols ? Symbol.prototype : undefined, |
|
'$ %SyntaxError%': SyntaxError, |
|
'$ %SyntaxErrorPrototype%': SyntaxError.prototype, |
|
'$ %ThrowTypeError%': ThrowTypeError, |
|
'$ %TypedArray%': TypedArray, |
|
'$ %TypedArrayPrototype%': TypedArray ? TypedArray.prototype : undefined, |
|
'$ %TypeError%': TypeError, |
|
'$ %TypeErrorPrototype%': TypeError.prototype, |
|
'$ %Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array, |
|
'$ %Uint8ArrayPrototype%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array.prototype, |
|
'$ %Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray, |
|
'$ %Uint8ClampedArrayPrototype%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray.prototype, |
|
'$ %Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array, |
|
'$ %Uint16ArrayPrototype%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array.prototype, |
|
'$ %Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array, |
|
'$ %Uint32ArrayPrototype%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array.prototype, |
|
'$ %URIError%': URIError, |
|
'$ %URIErrorPrototype%': URIError.prototype, |
|
'$ %WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap, |
|
'$ %WeakMapPrototype%': typeof WeakMap === 'undefined' ? undefined : WeakMap.prototype, |
|
'$ %WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet, |
|
'$ %WeakSetPrototype%': typeof WeakSet === 'undefined' ? undefined : WeakSet.prototype |
|
}; |
|
|
|
module.exports = function GetIntrinsic(name, allowMissing) { |
|
if (arguments.length > 1 && typeof allowMissing !== 'boolean') { |
|
throw new TypeError('"allowMissing" argument must be a boolean'); |
|
} |
|
|
|
var key = '$ ' + name; |
|
if (!(key in INTRINSICS)) { |
|
throw new SyntaxError('intrinsic ' + name + ' does not exist!'); |
|
} |
|
|
|
// istanbul ignore if // hopefully this is impossible to test :-) |
|
if (typeof INTRINSICS[key] === 'undefined' && !allowMissing) { |
|
throw new TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!'); |
|
} |
|
return INTRINSICS[key]; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 137 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = getInputHeight; |
|
/* eslint-disable camelcase */ |
|
|
|
function getPadding(vertical, top, bottom) { |
|
var isTopDefined = typeof top === 'number'; |
|
var isBottomDefined = typeof bottom === 'number'; |
|
var isVerticalDefined = typeof vertical === 'number'; |
|
|
|
if (isTopDefined && isBottomDefined) { |
|
return top + bottom; |
|
} |
|
|
|
if (isTopDefined && isVerticalDefined) { |
|
return top + vertical; |
|
} |
|
|
|
if (isTopDefined) { |
|
return top; |
|
} |
|
|
|
if (isBottomDefined && isVerticalDefined) { |
|
return bottom + vertical; |
|
} |
|
|
|
if (isBottomDefined) { |
|
return bottom; |
|
} |
|
|
|
if (isVerticalDefined) { |
|
return 2 * vertical; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
function getInputHeight(_ref, small) { |
|
var _ref$font$input = _ref.font.input, |
|
lineHeight = _ref$font$input.lineHeight, |
|
lineHeight_small = _ref$font$input.lineHeight_small, |
|
_ref$spacing = _ref.spacing, |
|
inputPadding = _ref$spacing.inputPadding, |
|
displayTextPaddingVertical = _ref$spacing.displayTextPaddingVertical, |
|
displayTextPaddingTop = _ref$spacing.displayTextPaddingTop, |
|
displayTextPaddingBottom = _ref$spacing.displayTextPaddingBottom, |
|
displayTextPaddingVertical_small = _ref$spacing.displayTextPaddingVertical_small, |
|
displayTextPaddingTop_small = _ref$spacing.displayTextPaddingTop_small, |
|
displayTextPaddingBottom_small = _ref$spacing.displayTextPaddingBottom_small; |
|
|
|
var calcLineHeight = small ? lineHeight_small : lineHeight; |
|
|
|
var padding = small ? getPadding(displayTextPaddingVertical_small, displayTextPaddingTop_small, displayTextPaddingBottom_small) : getPadding(displayTextPaddingVertical, displayTextPaddingTop, displayTextPaddingBottom); |
|
|
|
return parseInt(calcLineHeight, 10) + 2 * inputPadding + padding; |
|
} |
|
|
|
/***/ }), |
|
/* 138 */ |
|
/***/ (function(module, exports) { |
|
|
|
/** |
|
* Checks if `value` is the |
|
* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) |
|
* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @since 0.1.0 |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is an object, else `false`. |
|
* @example |
|
* |
|
* _.isObject({}); |
|
* // => true |
|
* |
|
* _.isObject([1, 2, 3]); |
|
* // => true |
|
* |
|
* _.isObject(_.noop); |
|
* // => true |
|
* |
|
* _.isObject(null); |
|
* // => false |
|
*/ |
|
function isObject(value) { |
|
var type = typeof value; |
|
return value != null && (type == 'object' || type == 'function'); |
|
} |
|
|
|
module.exports = isObject; |
|
|
|
|
|
/***/ }), |
|
/* 139 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = toLocalizedDateString; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _toMomentObject = __webpack_require__(78); |
|
|
|
var _toMomentObject2 = _interopRequireDefault(_toMomentObject); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function toLocalizedDateString(date, currentFormat) { |
|
var dateObj = _moment2['default'].isMoment(date) ? date : (0, _toMomentObject2['default'])(date, currentFormat); |
|
if (!dateObj) return null; |
|
|
|
return dateObj.format(_constants.DISPLAY_FORMAT); |
|
} |
|
|
|
/***/ }), |
|
/* 140 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = isDayVisible; |
|
|
|
var _isBeforeDay = __webpack_require__(95); |
|
|
|
var _isBeforeDay2 = _interopRequireDefault(_isBeforeDay); |
|
|
|
var _isAfterDay = __webpack_require__(108); |
|
|
|
var _isAfterDay2 = _interopRequireDefault(_isAfterDay); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function isDayVisible(day, month, numberOfMonths, enableOutsideDays) { |
|
var firstDayOfFirstMonth = month.clone().startOf('month'); |
|
if (enableOutsideDays) firstDayOfFirstMonth = firstDayOfFirstMonth.startOf('week'); |
|
if ((0, _isBeforeDay2['default'])(day, firstDayOfFirstMonth)) return false; |
|
|
|
var lastDayOfLastMonth = month.clone().add(numberOfMonths - 1, 'months').endOf('month'); |
|
if (enableOutsideDays) lastDayOfLastMonth = lastDayOfLastMonth.endOf('week'); |
|
return !(0, _isAfterDay2['default'])(day, lastDayOfLastMonth); |
|
} |
|
|
|
/***/ }), |
|
/* 141 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.PureDayPicker = exports.defaultProps = undefined; |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _reactAddonsShallowCompare = __webpack_require__(76); |
|
|
|
var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _throttle = __webpack_require__(198); |
|
|
|
var _throttle2 = _interopRequireDefault(_throttle); |
|
|
|
var _isTouchDevice = __webpack_require__(80); |
|
|
|
var _isTouchDevice2 = _interopRequireDefault(_isTouchDevice); |
|
|
|
var _reactOutsideClickHandler = __webpack_require__(134); |
|
|
|
var _reactOutsideClickHandler2 = _interopRequireDefault(_reactOutsideClickHandler); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _CalendarMonthGrid = __webpack_require__(175); |
|
|
|
var _CalendarMonthGrid2 = _interopRequireDefault(_CalendarMonthGrid); |
|
|
|
var _DayPickerNavigation = __webpack_require__(305); |
|
|
|
var _DayPickerNavigation2 = _interopRequireDefault(_DayPickerNavigation); |
|
|
|
var _DayPickerKeyboardShortcuts = __webpack_require__(308); |
|
|
|
var _DayPickerKeyboardShortcuts2 = _interopRequireDefault(_DayPickerKeyboardShortcuts); |
|
|
|
var _getNumberOfCalendarMonthWeeks = __webpack_require__(310); |
|
|
|
var _getNumberOfCalendarMonthWeeks2 = _interopRequireDefault(_getNumberOfCalendarMonthWeeks); |
|
|
|
var _getCalendarMonthWidth = __webpack_require__(176); |
|
|
|
var _getCalendarMonthWidth2 = _interopRequireDefault(_getCalendarMonthWidth); |
|
|
|
var _calculateDimension = __webpack_require__(174); |
|
|
|
var _calculateDimension2 = _interopRequireDefault(_calculateDimension); |
|
|
|
var _getActiveElement = __webpack_require__(311); |
|
|
|
var _getActiveElement2 = _interopRequireDefault(_getActiveElement); |
|
|
|
var _isDayVisible = __webpack_require__(140); |
|
|
|
var _isDayVisible2 = _interopRequireDefault(_isDayVisible); |
|
|
|
var _ModifiersShape = __webpack_require__(103); |
|
|
|
var _ModifiersShape2 = _interopRequireDefault(_ModifiersShape); |
|
|
|
var _ScrollableOrientationShape = __webpack_require__(79); |
|
|
|
var _ScrollableOrientationShape2 = _interopRequireDefault(_ScrollableOrientationShape); |
|
|
|
var _DayOfWeekShape = __webpack_require__(73); |
|
|
|
var _DayOfWeekShape2 = _interopRequireDefault(_DayOfWeekShape); |
|
|
|
var _CalendarInfoPositionShape = __webpack_require__(93); |
|
|
|
var _CalendarInfoPositionShape2 = _interopRequireDefault(_CalendarInfoPositionShape); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
var MONTH_PADDING = 23; |
|
var PREV_TRANSITION = 'prev'; |
|
var NEXT_TRANSITION = 'next'; |
|
var MONTH_SELECTION_TRANSITION = 'month_selection'; |
|
var YEAR_SELECTION_TRANSITION = 'year_selection'; |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, { |
|
|
|
// calendar presentation props |
|
enableOutsideDays: _propTypes2['default'].bool, |
|
numberOfMonths: _propTypes2['default'].number, |
|
orientation: _ScrollableOrientationShape2['default'], |
|
withPortal: _propTypes2['default'].bool, |
|
onOutsideClick: _propTypes2['default'].func, |
|
hidden: _propTypes2['default'].bool, |
|
initialVisibleMonth: _propTypes2['default'].func, |
|
firstDayOfWeek: _DayOfWeekShape2['default'], |
|
renderCalendarInfo: _propTypes2['default'].func, |
|
calendarInfoPosition: _CalendarInfoPositionShape2['default'], |
|
hideKeyboardShortcutsPanel: _propTypes2['default'].bool, |
|
daySize: _airbnbPropTypes.nonNegativeInteger, |
|
isRTL: _propTypes2['default'].bool, |
|
verticalHeight: _airbnbPropTypes.nonNegativeInteger, |
|
noBorder: _propTypes2['default'].bool, |
|
transitionDuration: _airbnbPropTypes.nonNegativeInteger, |
|
verticalBorderSpacing: _airbnbPropTypes.nonNegativeInteger, |
|
horizontalMonthPadding: _airbnbPropTypes.nonNegativeInteger, |
|
|
|
// navigation props |
|
navPrev: _propTypes2['default'].node, |
|
navNext: _propTypes2['default'].node, |
|
noNavButtons: _propTypes2['default'].bool, |
|
onPrevMonthClick: _propTypes2['default'].func, |
|
onNextMonthClick: _propTypes2['default'].func, |
|
onMonthChange: _propTypes2['default'].func, |
|
onYearChange: _propTypes2['default'].func, |
|
onMultiplyScrollableMonths: _propTypes2['default'].func, // VERTICAL_SCROLLABLE daypickers only |
|
|
|
// month props |
|
renderMonthText: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
renderMonthElement: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
|
|
// day props |
|
modifiers: _propTypes2['default'].objectOf(_propTypes2['default'].objectOf(_ModifiersShape2['default'])), |
|
renderCalendarDay: _propTypes2['default'].func, |
|
renderDayContents: _propTypes2['default'].func, |
|
onDayClick: _propTypes2['default'].func, |
|
onDayMouseEnter: _propTypes2['default'].func, |
|
onDayMouseLeave: _propTypes2['default'].func, |
|
|
|
// accessibility props |
|
isFocused: _propTypes2['default'].bool, |
|
getFirstFocusableDay: _propTypes2['default'].func, |
|
onBlur: _propTypes2['default'].func, |
|
showKeyboardShortcuts: _propTypes2['default'].bool, |
|
|
|
// internationalization |
|
monthFormat: _propTypes2['default'].string, |
|
weekDayFormat: _propTypes2['default'].string, |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.DayPickerPhrases)), |
|
dayAriaLabelFormat: _propTypes2['default'].string |
|
})); |
|
|
|
var defaultProps = exports.defaultProps = { |
|
// calendar presentation props |
|
enableOutsideDays: false, |
|
numberOfMonths: 2, |
|
orientation: _constants.HORIZONTAL_ORIENTATION, |
|
withPortal: false, |
|
onOutsideClick: function () { |
|
function onOutsideClick() {} |
|
|
|
return onOutsideClick; |
|
}(), |
|
|
|
hidden: false, |
|
initialVisibleMonth: function () { |
|
function initialVisibleMonth() { |
|
return (0, _moment2['default'])(); |
|
} |
|
|
|
return initialVisibleMonth; |
|
}(), |
|
firstDayOfWeek: null, |
|
renderCalendarInfo: null, |
|
calendarInfoPosition: _constants.INFO_POSITION_BOTTOM, |
|
hideKeyboardShortcutsPanel: false, |
|
daySize: _constants.DAY_SIZE, |
|
isRTL: false, |
|
verticalHeight: null, |
|
noBorder: false, |
|
transitionDuration: undefined, |
|
verticalBorderSpacing: undefined, |
|
horizontalMonthPadding: 13, |
|
|
|
// navigation props |
|
navPrev: null, |
|
navNext: null, |
|
noNavButtons: false, |
|
onPrevMonthClick: function () { |
|
function onPrevMonthClick() {} |
|
|
|
return onPrevMonthClick; |
|
}(), |
|
onNextMonthClick: function () { |
|
function onNextMonthClick() {} |
|
|
|
return onNextMonthClick; |
|
}(), |
|
onMonthChange: function () { |
|
function onMonthChange() {} |
|
|
|
return onMonthChange; |
|
}(), |
|
onYearChange: function () { |
|
function onYearChange() {} |
|
|
|
return onYearChange; |
|
}(), |
|
onMultiplyScrollableMonths: function () { |
|
function onMultiplyScrollableMonths() {} |
|
|
|
return onMultiplyScrollableMonths; |
|
}(), |
|
|
|
|
|
// month props |
|
renderMonthText: null, |
|
renderMonthElement: null, |
|
|
|
// day props |
|
modifiers: {}, |
|
renderCalendarDay: undefined, |
|
renderDayContents: null, |
|
onDayClick: function () { |
|
function onDayClick() {} |
|
|
|
return onDayClick; |
|
}(), |
|
onDayMouseEnter: function () { |
|
function onDayMouseEnter() {} |
|
|
|
return onDayMouseEnter; |
|
}(), |
|
onDayMouseLeave: function () { |
|
function onDayMouseLeave() {} |
|
|
|
return onDayMouseLeave; |
|
}(), |
|
|
|
|
|
// accessibility props |
|
isFocused: false, |
|
getFirstFocusableDay: null, |
|
onBlur: function () { |
|
function onBlur() {} |
|
|
|
return onBlur; |
|
}(), |
|
|
|
showKeyboardShortcuts: false, |
|
|
|
// internationalization |
|
monthFormat: 'MMMM YYYY', |
|
weekDayFormat: 'dd', |
|
phrases: _defaultPhrases.DayPickerPhrases, |
|
dayAriaLabelFormat: undefined |
|
}; |
|
|
|
var DayPicker = function (_React$Component) { |
|
_inherits(DayPicker, _React$Component); |
|
|
|
function DayPicker(props) { |
|
_classCallCheck(this, DayPicker); |
|
|
|
var _this = _possibleConstructorReturn(this, (DayPicker.__proto__ || Object.getPrototypeOf(DayPicker)).call(this, props)); |
|
|
|
var currentMonth = props.hidden ? (0, _moment2['default'])() : props.initialVisibleMonth(); |
|
|
|
var focusedDate = currentMonth.clone().startOf('month'); |
|
if (props.getFirstFocusableDay) { |
|
focusedDate = props.getFirstFocusableDay(currentMonth); |
|
} |
|
|
|
var horizontalMonthPadding = props.horizontalMonthPadding; |
|
|
|
|
|
var translationValue = props.isRTL && _this.isHorizontal() ? -(0, _getCalendarMonthWidth2['default'])(props.daySize, horizontalMonthPadding) : 0; |
|
|
|
_this.hasSetInitialVisibleMonth = !props.hidden; |
|
_this.state = { |
|
currentMonth: currentMonth, |
|
monthTransition: null, |
|
translationValue: translationValue, |
|
scrollableMonthMultiple: 1, |
|
calendarMonthWidth: (0, _getCalendarMonthWidth2['default'])(props.daySize, horizontalMonthPadding), |
|
focusedDate: !props.hidden || props.isFocused ? focusedDate : null, |
|
nextFocusedDate: null, |
|
showKeyboardShortcuts: props.showKeyboardShortcuts, |
|
onKeyboardShortcutsPanelClose: function () { |
|
function onKeyboardShortcutsPanelClose() {} |
|
|
|
return onKeyboardShortcutsPanelClose; |
|
}(), |
|
|
|
isTouchDevice: (0, _isTouchDevice2['default'])(), |
|
withMouseInteractions: true, |
|
calendarInfoWidth: 0, |
|
monthTitleHeight: null, |
|
hasSetHeight: false |
|
}; |
|
|
|
_this.setCalendarMonthWeeks(currentMonth); |
|
|
|
_this.calendarMonthGridHeight = 0; |
|
_this.setCalendarInfoWidthTimeout = null; |
|
|
|
_this.onKeyDown = _this.onKeyDown.bind(_this); |
|
_this.throttledKeyDown = (0, _throttle2['default'])(_this.onFinalKeyDown, 200, { trailing: false }); |
|
_this.onPrevMonthClick = _this.onPrevMonthClick.bind(_this); |
|
_this.onNextMonthClick = _this.onNextMonthClick.bind(_this); |
|
_this.onMonthChange = _this.onMonthChange.bind(_this); |
|
_this.onYearChange = _this.onYearChange.bind(_this); |
|
|
|
_this.multiplyScrollableMonths = _this.multiplyScrollableMonths.bind(_this); |
|
_this.updateStateAfterMonthTransition = _this.updateStateAfterMonthTransition.bind(_this); |
|
|
|
_this.openKeyboardShortcutsPanel = _this.openKeyboardShortcutsPanel.bind(_this); |
|
_this.closeKeyboardShortcutsPanel = _this.closeKeyboardShortcutsPanel.bind(_this); |
|
|
|
_this.setCalendarInfoRef = _this.setCalendarInfoRef.bind(_this); |
|
_this.setContainerRef = _this.setContainerRef.bind(_this); |
|
_this.setTransitionContainerRef = _this.setTransitionContainerRef.bind(_this); |
|
_this.setMonthTitleHeight = _this.setMonthTitleHeight.bind(_this); |
|
return _this; |
|
} |
|
|
|
_createClass(DayPicker, [{ |
|
key: 'componentDidMount', |
|
value: function () { |
|
function componentDidMount() { |
|
var currentMonth = this.state.currentMonth; |
|
|
|
if (this.calendarInfo) { |
|
this.setState({ |
|
isTouchDevice: (0, _isTouchDevice2['default'])(), |
|
calendarInfoWidth: (0, _calculateDimension2['default'])(this.calendarInfo, 'width', true, true) |
|
}); |
|
} else { |
|
this.setState({ isTouchDevice: (0, _isTouchDevice2['default'])() }); |
|
} |
|
|
|
this.setCalendarMonthWeeks(currentMonth); |
|
} |
|
|
|
return componentDidMount; |
|
}() |
|
}, { |
|
key: 'componentWillReceiveProps', |
|
value: function () { |
|
function componentWillReceiveProps(nextProps) { |
|
var hidden = nextProps.hidden, |
|
isFocused = nextProps.isFocused, |
|
showKeyboardShortcuts = nextProps.showKeyboardShortcuts, |
|
onBlur = nextProps.onBlur, |
|
renderMonthText = nextProps.renderMonthText, |
|
horizontalMonthPadding = nextProps.horizontalMonthPadding; |
|
var currentMonth = this.state.currentMonth; |
|
|
|
|
|
if (!hidden) { |
|
if (!this.hasSetInitialVisibleMonth) { |
|
this.hasSetInitialVisibleMonth = true; |
|
this.setState({ |
|
currentMonth: nextProps.initialVisibleMonth() |
|
}); |
|
} |
|
} |
|
|
|
var _props = this.props, |
|
daySize = _props.daySize, |
|
prevIsFocused = _props.isFocused, |
|
prevRenderMonthText = _props.renderMonthText; |
|
|
|
|
|
if (nextProps.daySize !== daySize) { |
|
this.setState({ |
|
calendarMonthWidth: (0, _getCalendarMonthWidth2['default'])(nextProps.daySize, horizontalMonthPadding) |
|
}); |
|
} |
|
|
|
if (isFocused !== prevIsFocused) { |
|
if (isFocused) { |
|
var focusedDate = this.getFocusedDay(currentMonth); |
|
|
|
var onKeyboardShortcutsPanelClose = this.state.onKeyboardShortcutsPanelClose; |
|
|
|
if (nextProps.showKeyboardShortcuts) { |
|
// the ? shortcut came from the input and we should return input there once it is close |
|
onKeyboardShortcutsPanelClose = onBlur; |
|
} |
|
|
|
this.setState({ |
|
showKeyboardShortcuts: showKeyboardShortcuts, |
|
onKeyboardShortcutsPanelClose: onKeyboardShortcutsPanelClose, |
|
focusedDate: focusedDate, |
|
withMouseInteractions: false |
|
}); |
|
} else { |
|
this.setState({ focusedDate: null }); |
|
} |
|
} |
|
|
|
if (renderMonthText !== prevRenderMonthText) { |
|
this.setState({ |
|
monthTitleHeight: null |
|
}); |
|
} |
|
} |
|
|
|
return componentWillReceiveProps; |
|
}() |
|
}, { |
|
key: 'shouldComponentUpdate', |
|
value: function () { |
|
function shouldComponentUpdate(nextProps, nextState) { |
|
return (0, _reactAddonsShallowCompare2['default'])(this, nextProps, nextState); |
|
} |
|
|
|
return shouldComponentUpdate; |
|
}() |
|
}, { |
|
key: 'componentWillUpdate', |
|
value: function () { |
|
function componentWillUpdate() { |
|
var _this2 = this; |
|
|
|
var transitionDuration = this.props.transitionDuration; |
|
|
|
// Calculating the dimensions trigger a DOM repaint which |
|
// breaks the CSS transition. |
|
// The setTimeout will wait until the transition ends. |
|
|
|
if (this.calendarInfo) { |
|
this.setCalendarInfoWidthTimeout = setTimeout(function () { |
|
var calendarInfoWidth = _this2.state.calendarInfoWidth; |
|
|
|
var calendarInfoPanelWidth = (0, _calculateDimension2['default'])(_this2.calendarInfo, 'width', true, true); |
|
if (calendarInfoWidth !== calendarInfoPanelWidth) { |
|
_this2.setState({ |
|
calendarInfoWidth: calendarInfoPanelWidth |
|
}); |
|
} |
|
}, transitionDuration); |
|
} |
|
} |
|
|
|
return componentWillUpdate; |
|
}() |
|
}, { |
|
key: 'componentDidUpdate', |
|
value: function () { |
|
function componentDidUpdate(prevProps) { |
|
var _props2 = this.props, |
|
orientation = _props2.orientation, |
|
daySize = _props2.daySize, |
|
isFocused = _props2.isFocused, |
|
numberOfMonths = _props2.numberOfMonths; |
|
var _state = this.state, |
|
focusedDate = _state.focusedDate, |
|
monthTitleHeight = _state.monthTitleHeight; |
|
|
|
|
|
if (this.isHorizontal() && (orientation !== prevProps.orientation || daySize !== prevProps.daySize)) { |
|
var visibleCalendarWeeks = this.calendarMonthWeeks.slice(1, numberOfMonths + 1); |
|
var calendarMonthWeeksHeight = Math.max.apply(Math, [0].concat(_toConsumableArray(visibleCalendarWeeks))) * (daySize - 1); |
|
var newMonthHeight = monthTitleHeight + calendarMonthWeeksHeight + 1; |
|
this.adjustDayPickerHeight(newMonthHeight); |
|
} |
|
|
|
if (!prevProps.isFocused && isFocused && !focusedDate) { |
|
this.container.focus(); |
|
} |
|
} |
|
|
|
return componentDidUpdate; |
|
}() |
|
}, { |
|
key: 'componentWillUnmount', |
|
value: function () { |
|
function componentWillUnmount() { |
|
clearTimeout(this.setCalendarInfoWidthTimeout); |
|
} |
|
|
|
return componentWillUnmount; |
|
}() |
|
}, { |
|
key: 'onKeyDown', |
|
value: function () { |
|
function onKeyDown(e) { |
|
e.stopPropagation(); |
|
if (!_constants.MODIFIER_KEY_NAMES.has(e.key)) { |
|
this.throttledKeyDown(e); |
|
} |
|
} |
|
|
|
return onKeyDown; |
|
}() |
|
}, { |
|
key: 'onFinalKeyDown', |
|
value: function () { |
|
function onFinalKeyDown(e) { |
|
this.setState({ withMouseInteractions: false }); |
|
|
|
var _props3 = this.props, |
|
onBlur = _props3.onBlur, |
|
isRTL = _props3.isRTL; |
|
var _state2 = this.state, |
|
focusedDate = _state2.focusedDate, |
|
showKeyboardShortcuts = _state2.showKeyboardShortcuts; |
|
|
|
if (!focusedDate) return; |
|
|
|
var newFocusedDate = focusedDate.clone(); |
|
|
|
var didTransitionMonth = false; |
|
|
|
// focus might be anywhere when the keyboard shortcuts panel is opened so we want to |
|
// return it to wherever it was before when the panel was opened |
|
var activeElement = (0, _getActiveElement2['default'])(); |
|
var onKeyboardShortcutsPanelClose = function () { |
|
function onKeyboardShortcutsPanelClose() { |
|
if (activeElement) activeElement.focus(); |
|
} |
|
|
|
return onKeyboardShortcutsPanelClose; |
|
}(); |
|
|
|
switch (e.key) { |
|
case 'ArrowUp': |
|
e.preventDefault(); |
|
newFocusedDate.subtract(1, 'week'); |
|
didTransitionMonth = this.maybeTransitionPrevMonth(newFocusedDate); |
|
break; |
|
case 'ArrowLeft': |
|
e.preventDefault(); |
|
if (isRTL) { |
|
newFocusedDate.add(1, 'day'); |
|
} else { |
|
newFocusedDate.subtract(1, 'day'); |
|
} |
|
didTransitionMonth = this.maybeTransitionPrevMonth(newFocusedDate); |
|
break; |
|
case 'Home': |
|
e.preventDefault(); |
|
newFocusedDate.startOf('week'); |
|
didTransitionMonth = this.maybeTransitionPrevMonth(newFocusedDate); |
|
break; |
|
case 'PageUp': |
|
e.preventDefault(); |
|
newFocusedDate.subtract(1, 'month'); |
|
didTransitionMonth = this.maybeTransitionPrevMonth(newFocusedDate); |
|
break; |
|
|
|
case 'ArrowDown': |
|
e.preventDefault(); |
|
newFocusedDate.add(1, 'week'); |
|
didTransitionMonth = this.maybeTransitionNextMonth(newFocusedDate); |
|
break; |
|
case 'ArrowRight': |
|
e.preventDefault(); |
|
if (isRTL) { |
|
newFocusedDate.subtract(1, 'day'); |
|
} else { |
|
newFocusedDate.add(1, 'day'); |
|
} |
|
didTransitionMonth = this.maybeTransitionNextMonth(newFocusedDate); |
|
break; |
|
case 'End': |
|
e.preventDefault(); |
|
newFocusedDate.endOf('week'); |
|
didTransitionMonth = this.maybeTransitionNextMonth(newFocusedDate); |
|
break; |
|
case 'PageDown': |
|
e.preventDefault(); |
|
newFocusedDate.add(1, 'month'); |
|
didTransitionMonth = this.maybeTransitionNextMonth(newFocusedDate); |
|
break; |
|
|
|
case '?': |
|
this.openKeyboardShortcutsPanel(onKeyboardShortcutsPanelClose); |
|
break; |
|
|
|
case 'Escape': |
|
if (showKeyboardShortcuts) { |
|
this.closeKeyboardShortcutsPanel(); |
|
} else { |
|
onBlur(); |
|
} |
|
break; |
|
|
|
default: |
|
break; |
|
} |
|
|
|
// If there was a month transition, do not update the focused date until the transition has |
|
// completed. Otherwise, attempting to focus on a DOM node may interrupt the CSS animation. If |
|
// didTransitionMonth is true, the focusedDate gets updated in #updateStateAfterMonthTransition |
|
if (!didTransitionMonth) { |
|
this.setState({ |
|
focusedDate: newFocusedDate |
|
}); |
|
} |
|
} |
|
|
|
return onFinalKeyDown; |
|
}() |
|
}, { |
|
key: 'onPrevMonthClick', |
|
value: function () { |
|
function onPrevMonthClick(nextFocusedDate, e) { |
|
var _props4 = this.props, |
|
daySize = _props4.daySize, |
|
isRTL = _props4.isRTL, |
|
numberOfMonths = _props4.numberOfMonths; |
|
var _state3 = this.state, |
|
calendarMonthWidth = _state3.calendarMonthWidth, |
|
monthTitleHeight = _state3.monthTitleHeight; |
|
|
|
|
|
if (e) e.preventDefault(); |
|
|
|
var translationValue = void 0; |
|
if (this.isVertical()) { |
|
var calendarMonthWeeksHeight = this.calendarMonthWeeks[0] * (daySize - 1); |
|
translationValue = monthTitleHeight + calendarMonthWeeksHeight + 1; |
|
} else if (this.isHorizontal()) { |
|
translationValue = calendarMonthWidth; |
|
if (isRTL) { |
|
translationValue = -2 * calendarMonthWidth; |
|
} |
|
|
|
var visibleCalendarWeeks = this.calendarMonthWeeks.slice(0, numberOfMonths); |
|
var _calendarMonthWeeksHeight = Math.max.apply(Math, [0].concat(_toConsumableArray(visibleCalendarWeeks))) * (daySize - 1); |
|
var newMonthHeight = monthTitleHeight + _calendarMonthWeeksHeight + 1; |
|
this.adjustDayPickerHeight(newMonthHeight); |
|
} |
|
|
|
this.setState({ |
|
monthTransition: PREV_TRANSITION, |
|
translationValue: translationValue, |
|
focusedDate: null, |
|
nextFocusedDate: nextFocusedDate |
|
}); |
|
} |
|
|
|
return onPrevMonthClick; |
|
}() |
|
}, { |
|
key: 'onMonthChange', |
|
value: function () { |
|
function onMonthChange(currentMonth) { |
|
this.setCalendarMonthWeeks(currentMonth); |
|
this.calculateAndSetDayPickerHeight(); |
|
|
|
// Translation value is a hack to force an invisible transition that |
|
// properly rerenders the CalendarMonthGrid |
|
this.setState({ |
|
monthTransition: MONTH_SELECTION_TRANSITION, |
|
translationValue: 0.00001, |
|
focusedDate: null, |
|
nextFocusedDate: currentMonth, |
|
currentMonth: currentMonth |
|
}); |
|
} |
|
|
|
return onMonthChange; |
|
}() |
|
}, { |
|
key: 'onYearChange', |
|
value: function () { |
|
function onYearChange(currentMonth) { |
|
this.setCalendarMonthWeeks(currentMonth); |
|
this.calculateAndSetDayPickerHeight(); |
|
|
|
// Translation value is a hack to force an invisible transition that |
|
// properly rerenders the CalendarMonthGrid |
|
this.setState({ |
|
monthTransition: YEAR_SELECTION_TRANSITION, |
|
translationValue: 0.0001, |
|
focusedDate: null, |
|
nextFocusedDate: currentMonth, |
|
currentMonth: currentMonth |
|
}); |
|
} |
|
|
|
return onYearChange; |
|
}() |
|
}, { |
|
key: 'onNextMonthClick', |
|
value: function () { |
|
function onNextMonthClick(nextFocusedDate, e) { |
|
var _props5 = this.props, |
|
isRTL = _props5.isRTL, |
|
numberOfMonths = _props5.numberOfMonths, |
|
daySize = _props5.daySize; |
|
var _state4 = this.state, |
|
calendarMonthWidth = _state4.calendarMonthWidth, |
|
monthTitleHeight = _state4.monthTitleHeight; |
|
|
|
|
|
if (e) e.preventDefault(); |
|
|
|
var translationValue = void 0; |
|
|
|
if (this.isVertical()) { |
|
var firstVisibleMonthWeeks = this.calendarMonthWeeks[1]; |
|
var calendarMonthWeeksHeight = firstVisibleMonthWeeks * (daySize - 1); |
|
translationValue = -(monthTitleHeight + calendarMonthWeeksHeight + 1); |
|
} |
|
|
|
if (this.isHorizontal()) { |
|
translationValue = -calendarMonthWidth; |
|
if (isRTL) { |
|
translationValue = 0; |
|
} |
|
|
|
var visibleCalendarWeeks = this.calendarMonthWeeks.slice(2, numberOfMonths + 2); |
|
var _calendarMonthWeeksHeight2 = Math.max.apply(Math, [0].concat(_toConsumableArray(visibleCalendarWeeks))) * (daySize - 1); |
|
var newMonthHeight = monthTitleHeight + _calendarMonthWeeksHeight2 + 1; |
|
this.adjustDayPickerHeight(newMonthHeight); |
|
} |
|
|
|
this.setState({ |
|
monthTransition: NEXT_TRANSITION, |
|
translationValue: translationValue, |
|
focusedDate: null, |
|
nextFocusedDate: nextFocusedDate |
|
}); |
|
} |
|
|
|
return onNextMonthClick; |
|
}() |
|
}, { |
|
key: 'getFirstDayOfWeek', |
|
value: function () { |
|
function getFirstDayOfWeek() { |
|
var firstDayOfWeek = this.props.firstDayOfWeek; |
|
|
|
if (firstDayOfWeek == null) { |
|
return _moment2['default'].localeData().firstDayOfWeek(); |
|
} |
|
|
|
return firstDayOfWeek; |
|
} |
|
|
|
return getFirstDayOfWeek; |
|
}() |
|
}, { |
|
key: 'getFirstVisibleIndex', |
|
value: function () { |
|
function getFirstVisibleIndex() { |
|
var orientation = this.props.orientation; |
|
var monthTransition = this.state.monthTransition; |
|
|
|
|
|
if (orientation === _constants.VERTICAL_SCROLLABLE) return 0; |
|
|
|
var firstVisibleMonthIndex = 1; |
|
if (monthTransition === PREV_TRANSITION) { |
|
firstVisibleMonthIndex -= 1; |
|
} else if (monthTransition === NEXT_TRANSITION) { |
|
firstVisibleMonthIndex += 1; |
|
} |
|
|
|
return firstVisibleMonthIndex; |
|
} |
|
|
|
return getFirstVisibleIndex; |
|
}() |
|
}, { |
|
key: 'getFocusedDay', |
|
value: function () { |
|
function getFocusedDay(newMonth) { |
|
var _props6 = this.props, |
|
getFirstFocusableDay = _props6.getFirstFocusableDay, |
|
numberOfMonths = _props6.numberOfMonths; |
|
|
|
|
|
var focusedDate = void 0; |
|
if (getFirstFocusableDay) { |
|
focusedDate = getFirstFocusableDay(newMonth); |
|
} |
|
|
|
if (newMonth && (!focusedDate || !(0, _isDayVisible2['default'])(focusedDate, newMonth, numberOfMonths))) { |
|
focusedDate = newMonth.clone().startOf('month'); |
|
} |
|
|
|
return focusedDate; |
|
} |
|
|
|
return getFocusedDay; |
|
}() |
|
}, { |
|
key: 'setMonthTitleHeight', |
|
value: function () { |
|
function setMonthTitleHeight(monthTitleHeight) { |
|
var _this3 = this; |
|
|
|
this.setState({ |
|
monthTitleHeight: monthTitleHeight |
|
}, function () { |
|
_this3.calculateAndSetDayPickerHeight(); |
|
}); |
|
} |
|
|
|
return setMonthTitleHeight; |
|
}() |
|
}, { |
|
key: 'setCalendarMonthWeeks', |
|
value: function () { |
|
function setCalendarMonthWeeks(currentMonth) { |
|
var numberOfMonths = this.props.numberOfMonths; |
|
|
|
|
|
this.calendarMonthWeeks = []; |
|
var month = currentMonth.clone().subtract(1, 'months'); |
|
var firstDayOfWeek = this.getFirstDayOfWeek(); |
|
for (var i = 0; i < numberOfMonths + 2; i += 1) { |
|
var numberOfWeeks = (0, _getNumberOfCalendarMonthWeeks2['default'])(month, firstDayOfWeek); |
|
this.calendarMonthWeeks.push(numberOfWeeks); |
|
month = month.add(1, 'months'); |
|
} |
|
} |
|
|
|
return setCalendarMonthWeeks; |
|
}() |
|
}, { |
|
key: 'setContainerRef', |
|
value: function () { |
|
function setContainerRef(ref) { |
|
this.container = ref; |
|
} |
|
|
|
return setContainerRef; |
|
}() |
|
}, { |
|
key: 'setCalendarInfoRef', |
|
value: function () { |
|
function setCalendarInfoRef(ref) { |
|
this.calendarInfo = ref; |
|
} |
|
|
|
return setCalendarInfoRef; |
|
}() |
|
}, { |
|
key: 'setTransitionContainerRef', |
|
value: function () { |
|
function setTransitionContainerRef(ref) { |
|
this.transitionContainer = ref; |
|
} |
|
|
|
return setTransitionContainerRef; |
|
}() |
|
}, { |
|
key: 'maybeTransitionNextMonth', |
|
value: function () { |
|
function maybeTransitionNextMonth(newFocusedDate) { |
|
var numberOfMonths = this.props.numberOfMonths; |
|
var _state5 = this.state, |
|
currentMonth = _state5.currentMonth, |
|
focusedDate = _state5.focusedDate; |
|
|
|
|
|
var newFocusedDateMonth = newFocusedDate.month(); |
|
var focusedDateMonth = focusedDate.month(); |
|
var isNewFocusedDateVisible = (0, _isDayVisible2['default'])(newFocusedDate, currentMonth, numberOfMonths); |
|
if (newFocusedDateMonth !== focusedDateMonth && !isNewFocusedDateVisible) { |
|
this.onNextMonthClick(newFocusedDate); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
return maybeTransitionNextMonth; |
|
}() |
|
}, { |
|
key: 'maybeTransitionPrevMonth', |
|
value: function () { |
|
function maybeTransitionPrevMonth(newFocusedDate) { |
|
var numberOfMonths = this.props.numberOfMonths; |
|
var _state6 = this.state, |
|
currentMonth = _state6.currentMonth, |
|
focusedDate = _state6.focusedDate; |
|
|
|
|
|
var newFocusedDateMonth = newFocusedDate.month(); |
|
var focusedDateMonth = focusedDate.month(); |
|
var isNewFocusedDateVisible = (0, _isDayVisible2['default'])(newFocusedDate, currentMonth, numberOfMonths); |
|
if (newFocusedDateMonth !== focusedDateMonth && !isNewFocusedDateVisible) { |
|
this.onPrevMonthClick(newFocusedDate); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
return maybeTransitionPrevMonth; |
|
}() |
|
}, { |
|
key: 'multiplyScrollableMonths', |
|
value: function () { |
|
function multiplyScrollableMonths(e) { |
|
var onMultiplyScrollableMonths = this.props.onMultiplyScrollableMonths; |
|
|
|
if (e) e.preventDefault(); |
|
|
|
if (onMultiplyScrollableMonths) onMultiplyScrollableMonths(e); |
|
|
|
this.setState(function (_ref) { |
|
var scrollableMonthMultiple = _ref.scrollableMonthMultiple; |
|
return { |
|
scrollableMonthMultiple: scrollableMonthMultiple + 1 |
|
}; |
|
}); |
|
} |
|
|
|
return multiplyScrollableMonths; |
|
}() |
|
}, { |
|
key: 'isHorizontal', |
|
value: function () { |
|
function isHorizontal() { |
|
var orientation = this.props.orientation; |
|
|
|
return orientation === _constants.HORIZONTAL_ORIENTATION; |
|
} |
|
|
|
return isHorizontal; |
|
}() |
|
}, { |
|
key: 'isVertical', |
|
value: function () { |
|
function isVertical() { |
|
var orientation = this.props.orientation; |
|
|
|
return orientation === _constants.VERTICAL_ORIENTATION || orientation === _constants.VERTICAL_SCROLLABLE; |
|
} |
|
|
|
return isVertical; |
|
}() |
|
}, { |
|
key: 'updateStateAfterMonthTransition', |
|
value: function () { |
|
function updateStateAfterMonthTransition() { |
|
var _this4 = this; |
|
|
|
var _props7 = this.props, |
|
onPrevMonthClick = _props7.onPrevMonthClick, |
|
onNextMonthClick = _props7.onNextMonthClick, |
|
numberOfMonths = _props7.numberOfMonths, |
|
onMonthChange = _props7.onMonthChange, |
|
onYearChange = _props7.onYearChange, |
|
isRTL = _props7.isRTL; |
|
var _state7 = this.state, |
|
currentMonth = _state7.currentMonth, |
|
monthTransition = _state7.monthTransition, |
|
focusedDate = _state7.focusedDate, |
|
nextFocusedDate = _state7.nextFocusedDate, |
|
withMouseInteractions = _state7.withMouseInteractions, |
|
calendarMonthWidth = _state7.calendarMonthWidth; |
|
|
|
|
|
if (!monthTransition) return; |
|
|
|
var newMonth = currentMonth.clone(); |
|
var firstDayOfWeek = this.getFirstDayOfWeek(); |
|
if (monthTransition === PREV_TRANSITION) { |
|
newMonth.subtract(1, 'month'); |
|
if (onPrevMonthClick) onPrevMonthClick(newMonth); |
|
var newInvisibleMonth = newMonth.clone().subtract(1, 'month'); |
|
var numberOfWeeks = (0, _getNumberOfCalendarMonthWeeks2['default'])(newInvisibleMonth, firstDayOfWeek); |
|
this.calendarMonthWeeks = [numberOfWeeks].concat(_toConsumableArray(this.calendarMonthWeeks.slice(0, -1))); |
|
} else if (monthTransition === NEXT_TRANSITION) { |
|
newMonth.add(1, 'month'); |
|
if (onNextMonthClick) onNextMonthClick(newMonth); |
|
var _newInvisibleMonth = newMonth.clone().add(numberOfMonths, 'month'); |
|
var _numberOfWeeks = (0, _getNumberOfCalendarMonthWeeks2['default'])(_newInvisibleMonth, firstDayOfWeek); |
|
this.calendarMonthWeeks = [].concat(_toConsumableArray(this.calendarMonthWeeks.slice(1)), [_numberOfWeeks]); |
|
} else if (monthTransition === MONTH_SELECTION_TRANSITION) { |
|
if (onMonthChange) onMonthChange(newMonth); |
|
} else if (monthTransition === YEAR_SELECTION_TRANSITION) { |
|
if (onYearChange) onYearChange(newMonth); |
|
} |
|
|
|
var newFocusedDate = null; |
|
if (nextFocusedDate) { |
|
newFocusedDate = nextFocusedDate; |
|
} else if (!focusedDate && !withMouseInteractions) { |
|
newFocusedDate = this.getFocusedDay(newMonth); |
|
} |
|
|
|
this.setState({ |
|
currentMonth: newMonth, |
|
monthTransition: null, |
|
translationValue: isRTL && this.isHorizontal() ? -calendarMonthWidth : 0, |
|
nextFocusedDate: null, |
|
focusedDate: newFocusedDate |
|
}, function () { |
|
// we don't want to focus on the relevant calendar day after a month transition |
|
// if the user is navigating around using a mouse |
|
if (withMouseInteractions) { |
|
var activeElement = (0, _getActiveElement2['default'])(); |
|
if (activeElement && activeElement !== document.body && _this4.container.contains(activeElement)) { |
|
activeElement.blur(); |
|
} |
|
} |
|
}); |
|
} |
|
|
|
return updateStateAfterMonthTransition; |
|
}() |
|
}, { |
|
key: 'adjustDayPickerHeight', |
|
value: function () { |
|
function adjustDayPickerHeight(newMonthHeight) { |
|
var _this5 = this; |
|
|
|
var monthHeight = newMonthHeight + MONTH_PADDING; |
|
if (monthHeight !== this.calendarMonthGridHeight) { |
|
this.transitionContainer.style.height = String(monthHeight) + 'px'; |
|
if (!this.calendarMonthGridHeight) { |
|
setTimeout(function () { |
|
_this5.setState({ hasSetHeight: true }); |
|
}, 0); |
|
} |
|
this.calendarMonthGridHeight = monthHeight; |
|
} |
|
} |
|
|
|
return adjustDayPickerHeight; |
|
}() |
|
}, { |
|
key: 'calculateAndSetDayPickerHeight', |
|
value: function () { |
|
function calculateAndSetDayPickerHeight() { |
|
var _props8 = this.props, |
|
daySize = _props8.daySize, |
|
numberOfMonths = _props8.numberOfMonths; |
|
var monthTitleHeight = this.state.monthTitleHeight; |
|
|
|
|
|
var visibleCalendarWeeks = this.calendarMonthWeeks.slice(1, numberOfMonths + 1); |
|
var calendarMonthWeeksHeight = Math.max.apply(Math, [0].concat(_toConsumableArray(visibleCalendarWeeks))) * (daySize - 1); |
|
var newMonthHeight = monthTitleHeight + calendarMonthWeeksHeight + 1; |
|
|
|
if (this.isHorizontal()) { |
|
this.adjustDayPickerHeight(newMonthHeight); |
|
} |
|
} |
|
|
|
return calculateAndSetDayPickerHeight; |
|
}() |
|
}, { |
|
key: 'openKeyboardShortcutsPanel', |
|
value: function () { |
|
function openKeyboardShortcutsPanel(onCloseCallBack) { |
|
this.setState({ |
|
showKeyboardShortcuts: true, |
|
onKeyboardShortcutsPanelClose: onCloseCallBack |
|
}); |
|
} |
|
|
|
return openKeyboardShortcutsPanel; |
|
}() |
|
}, { |
|
key: 'closeKeyboardShortcutsPanel', |
|
value: function () { |
|
function closeKeyboardShortcutsPanel() { |
|
var onKeyboardShortcutsPanelClose = this.state.onKeyboardShortcutsPanelClose; |
|
|
|
|
|
if (onKeyboardShortcutsPanelClose) { |
|
onKeyboardShortcutsPanelClose(); |
|
} |
|
|
|
this.setState({ |
|
onKeyboardShortcutsPanelClose: null, |
|
showKeyboardShortcuts: false |
|
}); |
|
} |
|
|
|
return closeKeyboardShortcutsPanel; |
|
}() |
|
}, { |
|
key: 'renderNavigation', |
|
value: function () { |
|
function renderNavigation() { |
|
var _this6 = this; |
|
|
|
var _props9 = this.props, |
|
navPrev = _props9.navPrev, |
|
navNext = _props9.navNext, |
|
noNavButtons = _props9.noNavButtons, |
|
orientation = _props9.orientation, |
|
phrases = _props9.phrases, |
|
isRTL = _props9.isRTL; |
|
|
|
|
|
if (noNavButtons) { |
|
return null; |
|
} |
|
|
|
var onNextMonthClick = void 0; |
|
if (orientation === _constants.VERTICAL_SCROLLABLE) { |
|
onNextMonthClick = this.multiplyScrollableMonths; |
|
} else { |
|
onNextMonthClick = function () { |
|
function onNextMonthClick(e) { |
|
_this6.onNextMonthClick(null, e); |
|
} |
|
|
|
return onNextMonthClick; |
|
}(); |
|
} |
|
|
|
return _react2['default'].createElement(_DayPickerNavigation2['default'], { |
|
onPrevMonthClick: function () { |
|
function onPrevMonthClick(e) { |
|
_this6.onPrevMonthClick(null, e); |
|
} |
|
|
|
return onPrevMonthClick; |
|
}(), |
|
onNextMonthClick: onNextMonthClick, |
|
navPrev: navPrev, |
|
navNext: navNext, |
|
orientation: orientation, |
|
phrases: phrases, |
|
isRTL: isRTL |
|
}); |
|
} |
|
|
|
return renderNavigation; |
|
}() |
|
}, { |
|
key: 'renderWeekHeader', |
|
value: function () { |
|
function renderWeekHeader(index) { |
|
var _props10 = this.props, |
|
daySize = _props10.daySize, |
|
horizontalMonthPadding = _props10.horizontalMonthPadding, |
|
orientation = _props10.orientation, |
|
weekDayFormat = _props10.weekDayFormat, |
|
styles = _props10.styles; |
|
var calendarMonthWidth = this.state.calendarMonthWidth; |
|
|
|
var verticalScrollable = orientation === _constants.VERTICAL_SCROLLABLE; |
|
var horizontalStyle = { |
|
left: index * calendarMonthWidth |
|
}; |
|
var verticalStyle = { |
|
marginLeft: -calendarMonthWidth / 2 |
|
}; |
|
|
|
var weekHeaderStyle = {}; // no styles applied to the vertical-scrollable orientation |
|
if (this.isHorizontal()) { |
|
weekHeaderStyle = horizontalStyle; |
|
} else if (this.isVertical() && !verticalScrollable) { |
|
weekHeaderStyle = verticalStyle; |
|
} |
|
|
|
var firstDayOfWeek = this.getFirstDayOfWeek(); |
|
|
|
var header = []; |
|
for (var i = 0; i < 7; i += 1) { |
|
header.push(_react2['default'].createElement( |
|
'li', |
|
_extends({ key: i }, (0, _reactWithStyles.css)(styles.DayPicker_weekHeader_li, { width: daySize })), |
|
_react2['default'].createElement( |
|
'small', |
|
null, |
|
(0, _moment2['default'])().day((i + firstDayOfWeek) % 7).format(weekDayFormat) |
|
) |
|
)); |
|
} |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
_extends({}, (0, _reactWithStyles.css)(styles.DayPicker_weekHeader, this.isVertical() && styles.DayPicker_weekHeader__vertical, verticalScrollable && styles.DayPicker_weekHeader__verticalScrollable, weekHeaderStyle, { padding: '0 ' + String(horizontalMonthPadding) + 'px' }), { |
|
key: 'week-' + String(index) |
|
}), |
|
_react2['default'].createElement( |
|
'ul', |
|
(0, _reactWithStyles.css)(styles.DayPicker_weekHeader_ul), |
|
header |
|
) |
|
); |
|
} |
|
|
|
return renderWeekHeader; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _this7 = this; |
|
|
|
var _state8 = this.state, |
|
calendarMonthWidth = _state8.calendarMonthWidth, |
|
currentMonth = _state8.currentMonth, |
|
monthTransition = _state8.monthTransition, |
|
translationValue = _state8.translationValue, |
|
scrollableMonthMultiple = _state8.scrollableMonthMultiple, |
|
focusedDate = _state8.focusedDate, |
|
showKeyboardShortcuts = _state8.showKeyboardShortcuts, |
|
isTouch = _state8.isTouchDevice, |
|
hasSetHeight = _state8.hasSetHeight, |
|
calendarInfoWidth = _state8.calendarInfoWidth, |
|
monthTitleHeight = _state8.monthTitleHeight; |
|
var _props11 = this.props, |
|
enableOutsideDays = _props11.enableOutsideDays, |
|
numberOfMonths = _props11.numberOfMonths, |
|
orientation = _props11.orientation, |
|
modifiers = _props11.modifiers, |
|
withPortal = _props11.withPortal, |
|
onDayClick = _props11.onDayClick, |
|
onDayMouseEnter = _props11.onDayMouseEnter, |
|
onDayMouseLeave = _props11.onDayMouseLeave, |
|
firstDayOfWeek = _props11.firstDayOfWeek, |
|
renderMonthText = _props11.renderMonthText, |
|
renderCalendarDay = _props11.renderCalendarDay, |
|
renderDayContents = _props11.renderDayContents, |
|
renderCalendarInfo = _props11.renderCalendarInfo, |
|
renderMonthElement = _props11.renderMonthElement, |
|
calendarInfoPosition = _props11.calendarInfoPosition, |
|
hideKeyboardShortcutsPanel = _props11.hideKeyboardShortcutsPanel, |
|
onOutsideClick = _props11.onOutsideClick, |
|
monthFormat = _props11.monthFormat, |
|
daySize = _props11.daySize, |
|
isFocused = _props11.isFocused, |
|
isRTL = _props11.isRTL, |
|
styles = _props11.styles, |
|
theme = _props11.theme, |
|
phrases = _props11.phrases, |
|
verticalHeight = _props11.verticalHeight, |
|
dayAriaLabelFormat = _props11.dayAriaLabelFormat, |
|
noBorder = _props11.noBorder, |
|
transitionDuration = _props11.transitionDuration, |
|
verticalBorderSpacing = _props11.verticalBorderSpacing, |
|
horizontalMonthPadding = _props11.horizontalMonthPadding; |
|
var dayPickerHorizontalPadding = theme.reactDates.spacing.dayPickerHorizontalPadding; |
|
|
|
|
|
var isHorizontal = this.isHorizontal(); |
|
|
|
var numOfWeekHeaders = this.isVertical() ? 1 : numberOfMonths; |
|
var weekHeaders = []; |
|
for (var i = 0; i < numOfWeekHeaders; i += 1) { |
|
weekHeaders.push(this.renderWeekHeader(i)); |
|
} |
|
|
|
var verticalScrollable = orientation === _constants.VERTICAL_SCROLLABLE; |
|
var height = void 0; |
|
if (isHorizontal) { |
|
height = this.calendarMonthGridHeight; |
|
} else if (this.isVertical() && !verticalScrollable && !withPortal) { |
|
// If the user doesn't set a desired height, |
|
// we default back to this kind of made-up value that generally looks good |
|
height = verticalHeight || 1.75 * calendarMonthWidth; |
|
} |
|
|
|
var isCalendarMonthGridAnimating = monthTransition !== null; |
|
|
|
var shouldFocusDate = !isCalendarMonthGridAnimating && isFocused; |
|
|
|
var keyboardShortcutButtonLocation = _DayPickerKeyboardShortcuts.BOTTOM_RIGHT; |
|
if (this.isVertical()) { |
|
keyboardShortcutButtonLocation = withPortal ? _DayPickerKeyboardShortcuts.TOP_LEFT : _DayPickerKeyboardShortcuts.TOP_RIGHT; |
|
} |
|
|
|
var shouldAnimateHeight = isHorizontal && hasSetHeight; |
|
|
|
var calendarInfoPositionTop = calendarInfoPosition === _constants.INFO_POSITION_TOP; |
|
var calendarInfoPositionBottom = calendarInfoPosition === _constants.INFO_POSITION_BOTTOM; |
|
var calendarInfoPositionBefore = calendarInfoPosition === _constants.INFO_POSITION_BEFORE; |
|
var calendarInfoPositionAfter = calendarInfoPosition === _constants.INFO_POSITION_AFTER; |
|
var calendarInfoIsInline = calendarInfoPositionBefore || calendarInfoPositionAfter; |
|
|
|
var calendarInfo = renderCalendarInfo && _react2['default'].createElement( |
|
'div', |
|
_extends({ |
|
ref: this.setCalendarInfoRef |
|
}, (0, _reactWithStyles.css)(calendarInfoIsInline && styles.DayPicker_calendarInfo__horizontal)), |
|
renderCalendarInfo() |
|
); |
|
|
|
var calendarInfoPanelWidth = renderCalendarInfo && calendarInfoIsInline ? calendarInfoWidth : 0; |
|
|
|
var firstVisibleMonthIndex = this.getFirstVisibleIndex(); |
|
var wrapperHorizontalWidth = calendarMonthWidth * numberOfMonths + 2 * dayPickerHorizontalPadding; |
|
// Adding `1px` because of whitespace between 2 inline-block |
|
var fullHorizontalWidth = wrapperHorizontalWidth + calendarInfoPanelWidth + 1; |
|
|
|
var transitionContainerStyle = { |
|
width: isHorizontal && wrapperHorizontalWidth, |
|
height: height |
|
}; |
|
|
|
var dayPickerWrapperStyle = { |
|
width: isHorizontal && wrapperHorizontalWidth |
|
}; |
|
|
|
var dayPickerStyle = { |
|
width: isHorizontal && fullHorizontalWidth, |
|
|
|
// These values are to center the datepicker (approximately) on the page |
|
marginLeft: isHorizontal && withPortal ? -fullHorizontalWidth / 2 : null, |
|
marginTop: isHorizontal && withPortal ? -calendarMonthWidth / 2 : null |
|
}; |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
_extends({ |
|
role: 'application', |
|
'aria-label': phrases.calendarLabel |
|
}, (0, _reactWithStyles.css)(styles.DayPicker, isHorizontal && styles.DayPicker__horizontal, verticalScrollable && styles.DayPicker__verticalScrollable, isHorizontal && withPortal && styles.DayPicker_portal__horizontal, this.isVertical() && withPortal && styles.DayPicker_portal__vertical, dayPickerStyle, !monthTitleHeight && styles.DayPicker__hidden, !noBorder && styles.DayPicker__withBorder)), |
|
_react2['default'].createElement( |
|
_reactOutsideClickHandler2['default'], |
|
{ onOutsideClick: onOutsideClick }, |
|
(calendarInfoPositionTop || calendarInfoPositionBefore) && calendarInfo, |
|
_react2['default'].createElement( |
|
'div', |
|
(0, _reactWithStyles.css)(dayPickerWrapperStyle, calendarInfoIsInline && isHorizontal && styles.DayPicker_wrapper__horizontal), |
|
_react2['default'].createElement( |
|
'div', |
|
_extends({}, (0, _reactWithStyles.css)(styles.DayPicker_weekHeaders, isHorizontal && styles.DayPicker_weekHeaders__horizontal), { |
|
'aria-hidden': 'true', |
|
role: 'presentation' |
|
}), |
|
weekHeaders |
|
), |
|
_react2['default'].createElement( |
|
'div', |
|
_extends({}, (0, _reactWithStyles.css)(styles.DayPicker_focusRegion), { |
|
ref: this.setContainerRef, |
|
onClick: function () { |
|
function onClick(e) { |
|
e.stopPropagation(); |
|
} |
|
|
|
return onClick; |
|
}(), |
|
onKeyDown: this.onKeyDown, |
|
onMouseUp: function () { |
|
function onMouseUp() { |
|
_this7.setState({ withMouseInteractions: true }); |
|
} |
|
|
|
return onMouseUp; |
|
}(), |
|
role: 'region', |
|
tabIndex: -1 |
|
}), |
|
!verticalScrollable && this.renderNavigation(), |
|
_react2['default'].createElement( |
|
'div', |
|
_extends({}, (0, _reactWithStyles.css)(styles.DayPicker_transitionContainer, shouldAnimateHeight && styles.DayPicker_transitionContainer__horizontal, this.isVertical() && styles.DayPicker_transitionContainer__vertical, verticalScrollable && styles.DayPicker_transitionContainer__verticalScrollable, transitionContainerStyle), { |
|
ref: this.setTransitionContainerRef |
|
}), |
|
_react2['default'].createElement(_CalendarMonthGrid2['default'], { |
|
setMonthTitleHeight: !monthTitleHeight ? this.setMonthTitleHeight : undefined, |
|
translationValue: translationValue, |
|
enableOutsideDays: enableOutsideDays, |
|
firstVisibleMonthIndex: firstVisibleMonthIndex, |
|
initialMonth: currentMonth, |
|
isAnimating: isCalendarMonthGridAnimating, |
|
modifiers: modifiers, |
|
orientation: orientation, |
|
numberOfMonths: numberOfMonths * scrollableMonthMultiple, |
|
onDayClick: onDayClick, |
|
onDayMouseEnter: onDayMouseEnter, |
|
onDayMouseLeave: onDayMouseLeave, |
|
onMonthChange: this.onMonthChange, |
|
onYearChange: this.onYearChange, |
|
renderMonthText: renderMonthText, |
|
renderCalendarDay: renderCalendarDay, |
|
renderDayContents: renderDayContents, |
|
renderMonthElement: renderMonthElement, |
|
onMonthTransitionEnd: this.updateStateAfterMonthTransition, |
|
monthFormat: monthFormat, |
|
daySize: daySize, |
|
firstDayOfWeek: firstDayOfWeek, |
|
isFocused: shouldFocusDate, |
|
focusedDate: focusedDate, |
|
phrases: phrases, |
|
isRTL: isRTL, |
|
dayAriaLabelFormat: dayAriaLabelFormat, |
|
transitionDuration: transitionDuration, |
|
verticalBorderSpacing: verticalBorderSpacing, |
|
horizontalMonthPadding: horizontalMonthPadding |
|
}), |
|
verticalScrollable && this.renderNavigation() |
|
), |
|
!isTouch && !hideKeyboardShortcutsPanel && _react2['default'].createElement(_DayPickerKeyboardShortcuts2['default'], { |
|
block: this.isVertical() && !withPortal, |
|
buttonLocation: keyboardShortcutButtonLocation, |
|
showKeyboardShortcutsPanel: showKeyboardShortcuts, |
|
openKeyboardShortcutsPanel: this.openKeyboardShortcutsPanel, |
|
closeKeyboardShortcutsPanel: this.closeKeyboardShortcutsPanel, |
|
phrases: phrases |
|
}) |
|
) |
|
), |
|
(calendarInfoPositionBottom || calendarInfoPositionAfter) && calendarInfo |
|
) |
|
); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return DayPicker; |
|
}(_react2['default'].Component); |
|
|
|
DayPicker.propTypes = propTypes; |
|
DayPicker.defaultProps = defaultProps; |
|
|
|
exports.PureDayPicker = DayPicker; |
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref2) { |
|
var _ref2$reactDates = _ref2.reactDates, |
|
color = _ref2$reactDates.color, |
|
font = _ref2$reactDates.font, |
|
noScrollBarOnVerticalScrollable = _ref2$reactDates.noScrollBarOnVerticalScrollable, |
|
spacing = _ref2$reactDates.spacing, |
|
zIndex = _ref2$reactDates.zIndex; |
|
return { |
|
DayPicker: { |
|
background: color.background, |
|
position: 'relative', |
|
textAlign: 'left' |
|
}, |
|
|
|
DayPicker__horizontal: { |
|
background: color.background |
|
}, |
|
|
|
DayPicker__verticalScrollable: { |
|
height: '100%' |
|
}, |
|
|
|
DayPicker__hidden: { |
|
visibility: 'hidden' |
|
}, |
|
|
|
DayPicker__withBorder: { |
|
boxShadow: '0 2px 6px rgba(0, 0, 0, 0.05), 0 0 0 1px rgba(0, 0, 0, 0.07)', |
|
borderRadius: 3 |
|
}, |
|
|
|
DayPicker_portal__horizontal: { |
|
boxShadow: 'none', |
|
position: 'absolute', |
|
left: '50%', |
|
top: '50%' |
|
}, |
|
|
|
DayPicker_portal__vertical: { |
|
position: 'initial' |
|
}, |
|
|
|
DayPicker_focusRegion: { |
|
outline: 'none' |
|
}, |
|
|
|
DayPicker_calendarInfo__horizontal: { |
|
display: 'inline-block', |
|
verticalAlign: 'top' |
|
}, |
|
|
|
DayPicker_wrapper__horizontal: { |
|
display: 'inline-block', |
|
verticalAlign: 'top' |
|
}, |
|
|
|
DayPicker_weekHeaders: { |
|
position: 'relative' |
|
}, |
|
|
|
DayPicker_weekHeaders__horizontal: { |
|
marginLeft: spacing.dayPickerHorizontalPadding |
|
}, |
|
|
|
DayPicker_weekHeader: { |
|
color: color.placeholderText, |
|
position: 'absolute', |
|
top: 62, |
|
zIndex: zIndex + 2, |
|
textAlign: 'left' |
|
}, |
|
|
|
DayPicker_weekHeader__vertical: { |
|
left: '50%' |
|
}, |
|
|
|
DayPicker_weekHeader__verticalScrollable: { |
|
top: 0, |
|
display: 'table-row', |
|
borderBottom: '1px solid ' + String(color.core.border), |
|
background: color.background, |
|
marginLeft: 0, |
|
left: 0, |
|
width: '100%', |
|
textAlign: 'center' |
|
}, |
|
|
|
DayPicker_weekHeader_ul: { |
|
listStyle: 'none', |
|
margin: '1px 0', |
|
paddingLeft: 0, |
|
paddingRight: 0, |
|
fontSize: font.size |
|
}, |
|
|
|
DayPicker_weekHeader_li: { |
|
display: 'inline-block', |
|
textAlign: 'center' |
|
}, |
|
|
|
DayPicker_transitionContainer: { |
|
position: 'relative', |
|
overflow: 'hidden', |
|
borderRadius: 3 |
|
}, |
|
|
|
DayPicker_transitionContainer__horizontal: { |
|
transition: 'height 0.2s ease-in-out' |
|
}, |
|
|
|
DayPicker_transitionContainer__vertical: { |
|
width: '100%' |
|
}, |
|
|
|
DayPicker_transitionContainer__verticalScrollable: (0, _object2['default'])({ |
|
paddingTop: 20, |
|
height: '100%', |
|
position: 'absolute', |
|
top: 0, |
|
bottom: 0, |
|
right: 0, |
|
left: 0, |
|
overflowY: 'scroll' |
|
}, noScrollBarOnVerticalScrollable && { |
|
'-webkitOverflowScrolling': 'touch', |
|
'::-webkit-scrollbar': { |
|
'-webkit-appearance': 'none', |
|
display: 'none' |
|
} |
|
}) |
|
}; |
|
})(DayPicker); |
|
|
|
/***/ }), |
|
/* 142 */, |
|
/* 143 */, |
|
/* 144 */, |
|
/* 145 */, |
|
/* 146 */, |
|
/* 147 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var toStr = Object.prototype.toString; |
|
|
|
module.exports = function isArguments(value) { |
|
var str = toStr.call(value); |
|
var isArgs = str === '[object Arguments]'; |
|
if (!isArgs) { |
|
isArgs = str !== '[object Array]' && |
|
value !== null && |
|
typeof value === 'object' && |
|
typeof value.length === 'number' && |
|
value.length >= 0 && |
|
toStr.call(value.callee) === '[object Function]'; |
|
} |
|
return isArgs; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 148 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var ES = __webpack_require__(245); |
|
|
|
module.exports = function flat() { |
|
var O = ES.ToObject(this); |
|
var sourceLen = ES.ToLength(ES.Get(O, 'length')); |
|
|
|
var depthNum = 1; |
|
if (arguments.length > 0 && typeof arguments[0] !== 'undefined') { |
|
depthNum = ES.ToInteger(arguments[0]); |
|
} |
|
|
|
var A = ES.ArraySpeciesCreate(O, 0); |
|
ES.FlattenIntoArray(A, O, sourceLen, 0, depthNum); |
|
return A; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 149 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var bind = __webpack_require__(59); |
|
var replace = bind.call(Function.call, String.prototype.replace); |
|
|
|
/* eslint-disable no-control-regex */ |
|
var leftWhitespace = /^[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]*/; |
|
/* eslint-enable no-control-regex */ |
|
|
|
module.exports = function trimLeft() { |
|
return replace(this, leftWhitespace, ''); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 150 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var implementation = __webpack_require__(149); |
|
|
|
module.exports = function getPolyfill() { |
|
if (!String.prototype.trimLeft) { |
|
return implementation; |
|
} |
|
var zeroWidthSpace = '\u200b'; |
|
if (zeroWidthSpace.trimLeft() !== zeroWidthSpace) { |
|
return implementation; |
|
} |
|
return String.prototype.trimLeft; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 151 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var bind = __webpack_require__(59); |
|
var replace = bind.call(Function.call, String.prototype.replace); |
|
|
|
/* eslint-disable no-control-regex */ |
|
var rightWhitespace = /[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]*$/; |
|
/* eslint-enable no-control-regex */ |
|
|
|
module.exports = function trimRight() { |
|
return replace(this, rightWhitespace, ''); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 152 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var implementation = __webpack_require__(151); |
|
|
|
module.exports = function getPolyfill() { |
|
if (!String.prototype.trimRight) { |
|
return implementation; |
|
} |
|
var zeroWidthSpace = '\u200b'; |
|
if (zeroWidthSpace.trimRight() !== zeroWidthSpace) { |
|
return implementation; |
|
} |
|
return String.prototype.trimRight; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 153 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
/* eslint complexity: [2, 17], max-statements: [2, 33] */ |
|
module.exports = function hasSymbols() { |
|
if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; } |
|
if (typeof Symbol.iterator === 'symbol') { return true; } |
|
|
|
var obj = {}; |
|
var sym = Symbol('test'); |
|
var symObj = Object(sym); |
|
if (typeof sym === 'string') { return false; } |
|
|
|
if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; } |
|
if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; } |
|
|
|
// temp disabled per https://github.com/ljharb/object.assign/issues/17 |
|
// if (sym instanceof Symbol) { return false; } |
|
// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4 |
|
// if (!(symObj instanceof Symbol)) { return false; } |
|
|
|
// if (typeof Symbol.prototype.toString !== 'function') { return false; } |
|
// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; } |
|
|
|
var symVal = 42; |
|
obj[sym] = symVal; |
|
for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax |
|
if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; } |
|
|
|
if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; } |
|
|
|
var syms = Object.getOwnPropertySymbols(obj); |
|
if (syms.length !== 1 || syms[0] !== sym) { return false; } |
|
|
|
if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; } |
|
|
|
if (typeof Object.getOwnPropertyDescriptor === 'function') { |
|
var descriptor = Object.getOwnPropertyDescriptor(obj, sym); |
|
if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; } |
|
} |
|
|
|
return true; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 154 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
module.exports = __webpack_require__(255); |
|
|
|
|
|
/***/ }), |
|
/* 155 */ |
|
/***/ (function(module, exports) { |
|
|
|
module.exports = function isPrimitive(value) { |
|
return value === null || (typeof value !== 'function' && typeof value !== 'object'); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 156 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var toStr = Object.prototype.toString; |
|
var hasSymbols = __webpack_require__(100)(); |
|
|
|
if (hasSymbols) { |
|
var symToStr = Symbol.prototype.toString; |
|
var symStringRegex = /^Symbol\(.*\)$/; |
|
var isSymbolObject = function isRealSymbolObject(value) { |
|
if (typeof value.valueOf() !== 'symbol') { |
|
return false; |
|
} |
|
return symStringRegex.test(symToStr.call(value)); |
|
}; |
|
|
|
module.exports = function isSymbol(value) { |
|
if (typeof value === 'symbol') { |
|
return true; |
|
} |
|
if (toStr.call(value) !== '[object Symbol]') { |
|
return false; |
|
} |
|
try { |
|
return isSymbolObject(value); |
|
} catch (e) { |
|
return false; |
|
} |
|
}; |
|
} else { |
|
|
|
module.exports = function isSymbol(value) { |
|
// this environment does not support Symbols. |
|
return false && false; |
|
}; |
|
} |
|
|
|
|
|
/***/ }), |
|
/* 157 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var GetIntrinsic = __webpack_require__(60); |
|
|
|
var $TypeError = GetIntrinsic('%TypeError%'); |
|
var $SyntaxError = GetIntrinsic('%SyntaxError%'); |
|
|
|
var has = __webpack_require__(63); |
|
|
|
var predicates = { |
|
// https://ecma-international.org/ecma-262/6.0/#sec-property-descriptor-specification-type |
|
'Property Descriptor': function isPropertyDescriptor(ES, Desc) { |
|
if (ES.Type(Desc) !== 'Object') { |
|
return false; |
|
} |
|
var allowed = { |
|
'[[Configurable]]': true, |
|
'[[Enumerable]]': true, |
|
'[[Get]]': true, |
|
'[[Set]]': true, |
|
'[[Value]]': true, |
|
'[[Writable]]': true |
|
}; |
|
|
|
for (var key in Desc) { // eslint-disable-line |
|
if (has(Desc, key) && !allowed[key]) { |
|
return false; |
|
} |
|
} |
|
|
|
var isData = has(Desc, '[[Value]]'); |
|
var IsAccessor = has(Desc, '[[Get]]') || has(Desc, '[[Set]]'); |
|
if (isData && IsAccessor) { |
|
throw new $TypeError('Property Descriptors may not be both accessor and data descriptors'); |
|
} |
|
return true; |
|
} |
|
}; |
|
|
|
module.exports = function assertRecord(ES, recordType, argumentName, value) { |
|
var predicate = predicates[recordType]; |
|
if (typeof predicate !== 'function') { |
|
throw new $SyntaxError('unknown record type: ' + recordType); |
|
} |
|
if (!predicate(ES, value)) { |
|
throw new $TypeError(argumentName + ' must be a ' + recordType); |
|
} |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 158 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var $isNaN = Number.isNaN || function (a) { return a !== a; }; |
|
|
|
module.exports = Number.isFinite || function (x) { return typeof x === 'number' && !$isNaN(x) && x !== Infinity && x !== -Infinity; }; |
|
|
|
|
|
/***/ }), |
|
/* 159 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var GetIntrinsic = __webpack_require__(60); |
|
|
|
var $Math = GetIntrinsic('%Math%'); |
|
var $Number = GetIntrinsic('%Number%'); |
|
|
|
module.exports = $Number.MAX_SAFE_INTEGER || $Math.pow(2, 53) - 1; |
|
|
|
|
|
/***/ }), |
|
/* 160 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
module.exports = function sign(number) { |
|
return number >= 0 ? 1 : -1; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 161 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
module.exports = function mod(number, modulo) { |
|
var remain = number % modulo; |
|
return Math.floor(remain >= 0 ? remain : remain + modulo); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 162 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var GetIntrinsic = __webpack_require__(60); |
|
|
|
var has = __webpack_require__(63); |
|
var $TypeError = GetIntrinsic('%TypeError%'); |
|
|
|
module.exports = function IsPropertyDescriptor(ES, Desc) { |
|
if (ES.Type(Desc) !== 'Object') { |
|
return false; |
|
} |
|
var allowed = { |
|
'[[Configurable]]': true, |
|
'[[Enumerable]]': true, |
|
'[[Get]]': true, |
|
'[[Set]]': true, |
|
'[[Value]]': true, |
|
'[[Writable]]': true |
|
}; |
|
|
|
for (var key in Desc) { // eslint-disable-line |
|
if (has(Desc, key) && !allowed[key]) { |
|
return false; |
|
} |
|
} |
|
|
|
if (ES.IsDataDescriptor(Desc) && ES.IsAccessorDescriptor(Desc)) { |
|
throw new $TypeError('Property Descriptors may not be both accessor and data descriptors'); |
|
} |
|
return true; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 163 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var GetIntrinsic = __webpack_require__(60); |
|
|
|
var $test = GetIntrinsic('RegExp.prototype.test'); |
|
|
|
var callBind = __webpack_require__(102); |
|
|
|
module.exports = function regexTester(regex) { |
|
return callBind($test, regex); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 164 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var $strSlice = __webpack_require__(75)('String.prototype.slice'); |
|
|
|
module.exports = function isPrefixOf(prefix, string) { |
|
if (prefix === string) { |
|
return true; |
|
} |
|
if (prefix.length > string.length) { |
|
return false; |
|
} |
|
return $strSlice(string, 0, prefix.length) === prefix; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 165 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var toStr = Object.prototype.toString; |
|
|
|
var isPrimitive = __webpack_require__(155); |
|
|
|
var isCallable = __webpack_require__(101); |
|
|
|
// http://ecma-international.org/ecma-262/5.1/#sec-8.12.8 |
|
var ES5internalSlots = { |
|
'[[DefaultValue]]': function (O) { |
|
var actualHint; |
|
if (arguments.length > 1) { |
|
actualHint = arguments[1]; |
|
} else { |
|
actualHint = toStr.call(O) === '[object Date]' ? String : Number; |
|
} |
|
|
|
if (actualHint === String || actualHint === Number) { |
|
var methods = actualHint === String ? ['toString', 'valueOf'] : ['valueOf', 'toString']; |
|
var value, i; |
|
for (i = 0; i < methods.length; ++i) { |
|
if (isCallable(O[methods[i]])) { |
|
value = O[methods[i]](); |
|
if (isPrimitive(value)) { |
|
return value; |
|
} |
|
} |
|
} |
|
throw new TypeError('No default value'); |
|
} |
|
throw new TypeError('invalid [[DefaultValue]] hint supplied'); |
|
} |
|
}; |
|
|
|
// http://ecma-international.org/ecma-262/5.1/#sec-9.1 |
|
module.exports = function ToPrimitive(input) { |
|
if (isPrimitive(input)) { |
|
return input; |
|
} |
|
if (arguments.length > 1) { |
|
return ES5internalSlots['[[DefaultValue]]'](input, arguments[1]); |
|
} |
|
return ES5internalSlots['[[DefaultValue]]'](input); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 166 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var has = __webpack_require__(63); |
|
var regexExec = RegExp.prototype.exec; |
|
var gOPD = Object.getOwnPropertyDescriptor; |
|
|
|
var tryRegexExecCall = function tryRegexExec(value) { |
|
try { |
|
var lastIndex = value.lastIndex; |
|
value.lastIndex = 0; |
|
|
|
regexExec.call(value); |
|
return true; |
|
} catch (e) { |
|
return false; |
|
} finally { |
|
value.lastIndex = lastIndex; |
|
} |
|
}; |
|
var toStr = Object.prototype.toString; |
|
var regexClass = '[object RegExp]'; |
|
var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol'; |
|
|
|
module.exports = function isRegex(value) { |
|
if (!value || typeof value !== 'object') { |
|
return false; |
|
} |
|
if (!hasToStringTag) { |
|
return toStr.call(value) === regexClass; |
|
} |
|
|
|
var descriptor = gOPD(value, 'lastIndex'); |
|
var hasLastIndexDataProperty = descriptor && has(descriptor, 'value'); |
|
if (!hasLastIndexDataProperty) { |
|
return false; |
|
} |
|
|
|
return tryRegexExecCall(value); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 167 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var implementation = __webpack_require__(148); |
|
|
|
module.exports = function getPolyfill() { |
|
return Array.prototype.flat || implementation; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 168 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
var styleInterface = void 0; |
|
var styleTheme = void 0; |
|
|
|
var START_MARK = 'react-with-styles.resolve.start'; |
|
var END_MARK = 'react-with-styles.resolve.end'; |
|
var MEASURE_MARK = '\uD83D\uDC69\u200D\uD83C\uDFA8 [resolve]'; |
|
|
|
function registerTheme(theme) { |
|
styleTheme = theme; |
|
} |
|
|
|
function registerInterface(interfaceToRegister) { |
|
styleInterface = interfaceToRegister; |
|
} |
|
|
|
function create(makeFromTheme, createWithDirection) { |
|
var styles = createWithDirection(makeFromTheme(styleTheme)); |
|
return function () { |
|
return styles; |
|
}; |
|
} |
|
|
|
function createLTR(makeFromTheme) { |
|
return create(makeFromTheme, styleInterface.createLTR || styleInterface.create); |
|
} |
|
|
|
function createRTL(makeFromTheme) { |
|
return create(makeFromTheme, styleInterface.createRTL || styleInterface.create); |
|
} |
|
|
|
function get() { |
|
return styleTheme; |
|
} |
|
|
|
function resolve() { |
|
if (false) {} |
|
|
|
for (var _len = arguments.length, styles = Array(_len), _key = 0; _key < _len; _key++) { |
|
styles[_key] = arguments[_key]; |
|
} |
|
|
|
var result = styleInterface.resolve(styles); |
|
|
|
if (false) {} |
|
|
|
return result; |
|
} |
|
|
|
function resolveLTR() { |
|
for (var _len2 = arguments.length, styles = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { |
|
styles[_key2] = arguments[_key2]; |
|
} |
|
|
|
if (styleInterface.resolveLTR) { |
|
return styleInterface.resolveLTR(styles); |
|
} |
|
|
|
return resolve(styles); |
|
} |
|
|
|
function resolveRTL() { |
|
for (var _len3 = arguments.length, styles = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { |
|
styles[_key3] = arguments[_key3]; |
|
} |
|
|
|
if (styleInterface.resolveRTL) { |
|
return styleInterface.resolveRTL(styles); |
|
} |
|
|
|
return resolve(styles); |
|
} |
|
|
|
function flush() { |
|
if (styleInterface.flush) { |
|
styleInterface.flush(); |
|
} |
|
} |
|
|
|
exports['default'] = { |
|
registerTheme: registerTheme, |
|
registerInterface: registerInterface, |
|
create: createLTR, |
|
createLTR: createLTR, |
|
createRTL: createRTL, |
|
get: get, |
|
resolve: resolveLTR, |
|
resolveLTR: resolveLTR, |
|
resolveRTL: resolveRTL, |
|
flush: flush |
|
}; |
|
|
|
/***/ }), |
|
/* 169 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
var core = { |
|
white: '#fff', |
|
gray: '#484848', |
|
grayLight: '#82888a', |
|
grayLighter: '#cacccd', |
|
grayLightest: '#f2f2f2', |
|
|
|
borderMedium: '#c4c4c4', |
|
border: '#dbdbdb', |
|
borderLight: '#e4e7e7', |
|
borderLighter: '#eceeee', |
|
borderBright: '#f4f5f5', |
|
|
|
primary: '#00a699', |
|
primaryShade_1: '#33dacd', |
|
primaryShade_2: '#66e2da', |
|
primaryShade_3: '#80e8e0', |
|
primaryShade_4: '#b2f1ec', |
|
primary_dark: '#008489', |
|
|
|
secondary: '#007a87', |
|
|
|
yellow: '#ffe8bc', |
|
yellow_dark: '#ffce71' |
|
}; |
|
|
|
exports['default'] = { |
|
reactDates: { |
|
zIndex: 0, |
|
border: { |
|
input: { |
|
border: 0, |
|
borderTop: 0, |
|
borderRight: 0, |
|
borderBottom: '2px solid transparent', |
|
borderLeft: 0, |
|
outlineFocused: 0, |
|
borderFocused: 0, |
|
borderTopFocused: 0, |
|
borderLeftFocused: 0, |
|
borderBottomFocused: '2px solid ' + String(core.primary_dark), |
|
borderRightFocused: 0, |
|
borderRadius: 0 |
|
}, |
|
pickerInput: { |
|
borderWidth: 1, |
|
borderStyle: 'solid', |
|
borderRadius: 2 |
|
} |
|
}, |
|
|
|
color: { |
|
core: core, |
|
|
|
disabled: core.grayLightest, |
|
|
|
background: core.white, |
|
backgroundDark: '#f2f2f2', |
|
backgroundFocused: core.white, |
|
border: 'rgb(219, 219, 219)', |
|
text: core.gray, |
|
textDisabled: core.border, |
|
textFocused: '#007a87', |
|
placeholderText: '#757575', |
|
|
|
outside: { |
|
backgroundColor: core.white, |
|
backgroundColor_active: core.white, |
|
backgroundColor_hover: core.white, |
|
color: core.gray, |
|
color_active: core.gray, |
|
color_hover: core.gray |
|
}, |
|
|
|
highlighted: { |
|
backgroundColor: core.yellow, |
|
backgroundColor_active: core.yellow_dark, |
|
backgroundColor_hover: core.yellow_dark, |
|
color: core.gray, |
|
color_active: core.gray, |
|
color_hover: core.gray |
|
}, |
|
|
|
minimumNights: { |
|
backgroundColor: core.white, |
|
backgroundColor_active: core.white, |
|
backgroundColor_hover: core.white, |
|
borderColor: core.borderLighter, |
|
color: core.grayLighter, |
|
color_active: core.grayLighter, |
|
color_hover: core.grayLighter |
|
}, |
|
|
|
hoveredSpan: { |
|
backgroundColor: core.primaryShade_4, |
|
backgroundColor_active: core.primaryShade_3, |
|
backgroundColor_hover: core.primaryShade_4, |
|
borderColor: core.primaryShade_3, |
|
borderColor_active: core.primaryShade_3, |
|
borderColor_hover: core.primaryShade_3, |
|
color: core.secondary, |
|
color_active: core.secondary, |
|
color_hover: core.secondary |
|
}, |
|
|
|
selectedSpan: { |
|
backgroundColor: core.primaryShade_2, |
|
backgroundColor_active: core.primaryShade_1, |
|
backgroundColor_hover: core.primaryShade_1, |
|
borderColor: core.primaryShade_1, |
|
borderColor_active: core.primary, |
|
borderColor_hover: core.primary, |
|
color: core.white, |
|
color_active: core.white, |
|
color_hover: core.white |
|
}, |
|
|
|
selected: { |
|
backgroundColor: core.primary, |
|
backgroundColor_active: core.primary, |
|
backgroundColor_hover: core.primary, |
|
borderColor: core.primary, |
|
borderColor_active: core.primary, |
|
borderColor_hover: core.primary, |
|
color: core.white, |
|
color_active: core.white, |
|
color_hover: core.white |
|
}, |
|
|
|
blocked_calendar: { |
|
backgroundColor: core.grayLighter, |
|
backgroundColor_active: core.grayLighter, |
|
backgroundColor_hover: core.grayLighter, |
|
borderColor: core.grayLighter, |
|
borderColor_active: core.grayLighter, |
|
borderColor_hover: core.grayLighter, |
|
color: core.grayLight, |
|
color_active: core.grayLight, |
|
color_hover: core.grayLight |
|
}, |
|
|
|
blocked_out_of_range: { |
|
backgroundColor: core.white, |
|
backgroundColor_active: core.white, |
|
backgroundColor_hover: core.white, |
|
borderColor: core.borderLight, |
|
borderColor_active: core.borderLight, |
|
borderColor_hover: core.borderLight, |
|
color: core.grayLighter, |
|
color_active: core.grayLighter, |
|
color_hover: core.grayLighter |
|
} |
|
}, |
|
|
|
spacing: { |
|
dayPickerHorizontalPadding: 9, |
|
captionPaddingTop: 22, |
|
captionPaddingBottom: 37, |
|
inputPadding: 0, |
|
displayTextPaddingVertical: undefined, |
|
displayTextPaddingTop: 11, |
|
displayTextPaddingBottom: 9, |
|
displayTextPaddingHorizontal: undefined, |
|
displayTextPaddingLeft: 11, |
|
displayTextPaddingRight: 11, |
|
displayTextPaddingVertical_small: undefined, |
|
displayTextPaddingTop_small: 7, |
|
displayTextPaddingBottom_small: 5, |
|
displayTextPaddingHorizontal_small: undefined, |
|
displayTextPaddingLeft_small: 7, |
|
displayTextPaddingRight_small: 7 |
|
}, |
|
|
|
sizing: { |
|
inputWidth: 130, |
|
inputWidth_small: 97, |
|
arrowWidth: 24 |
|
}, |
|
|
|
noScrollBarOnVerticalScrollable: false, |
|
|
|
font: { |
|
size: 14, |
|
captionSize: 18, |
|
input: { |
|
size: 19, |
|
lineHeight: '24px', |
|
size_small: 15, |
|
lineHeight_small: '18px', |
|
letterSpacing_small: '0.2px', |
|
styleDisabled: 'italic' |
|
} |
|
} |
|
} |
|
}; |
|
|
|
/***/ }), |
|
/* 170 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
// modified from https://github.com/es-shims/es6-shim |
|
var keys = __webpack_require__(90); |
|
var bind = __webpack_require__(59); |
|
var canBeObject = function (obj) { |
|
return typeof obj !== 'undefined' && obj !== null; |
|
}; |
|
var hasSymbols = __webpack_require__(153)(); |
|
var toObject = Object; |
|
var push = bind.call(Function.call, Array.prototype.push); |
|
var propIsEnumerable = bind.call(Function.call, Object.prototype.propertyIsEnumerable); |
|
var originalGetSymbols = hasSymbols ? Object.getOwnPropertySymbols : null; |
|
|
|
module.exports = function assign(target, source1) { |
|
if (!canBeObject(target)) { throw new TypeError('target must be an object'); } |
|
var objTarget = toObject(target); |
|
var s, source, i, props, syms, value, key; |
|
for (s = 1; s < arguments.length; ++s) { |
|
source = toObject(arguments[s]); |
|
props = keys(source); |
|
var getSymbols = hasSymbols && (Object.getOwnPropertySymbols || originalGetSymbols); |
|
if (getSymbols) { |
|
syms = getSymbols(source); |
|
for (i = 0; i < syms.length; ++i) { |
|
key = syms[i]; |
|
if (propIsEnumerable(source, key)) { |
|
push(props, key); |
|
} |
|
} |
|
} |
|
for (i = 0; i < props.length; ++i) { |
|
key = props[i]; |
|
value = source[key]; |
|
if (propIsEnumerable(source, key)) { |
|
objTarget[key] = value; |
|
} |
|
} |
|
} |
|
return objTarget; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 171 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var implementation = __webpack_require__(170); |
|
|
|
var lacksProperEnumerationOrder = function () { |
|
if (!Object.assign) { |
|
return false; |
|
} |
|
// v8, specifically in node 4.x, has a bug with incorrect property enumeration order |
|
// note: this does not detect the bug unless there's 20 characters |
|
var str = 'abcdefghijklmnopqrst'; |
|
var letters = str.split(''); |
|
var map = {}; |
|
for (var i = 0; i < letters.length; ++i) { |
|
map[letters[i]] = letters[i]; |
|
} |
|
var obj = Object.assign({}, map); |
|
var actual = ''; |
|
for (var k in obj) { |
|
actual += k; |
|
} |
|
return str !== actual; |
|
}; |
|
|
|
var assignHasPendingExceptions = function () { |
|
if (!Object.assign || !Object.preventExtensions) { |
|
return false; |
|
} |
|
// Firefox 37 still has "pending exception" logic in its Object.assign implementation, |
|
// which is 72% slower than our shim, and Firefox 40's native implementation. |
|
var thrower = Object.preventExtensions({ 1: 2 }); |
|
try { |
|
Object.assign(thrower, 'xy'); |
|
} catch (e) { |
|
return thrower[1] === 'y'; |
|
} |
|
return false; |
|
}; |
|
|
|
module.exports = function getPolyfill() { |
|
if (!Object.assign) { |
|
return implementation; |
|
} |
|
if (lacksProperEnumerationOrder()) { |
|
return implementation; |
|
} |
|
if (assignHasPendingExceptions()) { |
|
return implementation; |
|
} |
|
return Object.assign; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 172 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = getCalendarDaySettings; |
|
|
|
var _getPhrase = __webpack_require__(277); |
|
|
|
var _getPhrase2 = _interopRequireDefault(_getPhrase); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function getCalendarDaySettings(day, ariaLabelFormat, daySize, modifiers, phrases) { |
|
var chooseAvailableDate = phrases.chooseAvailableDate, |
|
dateIsUnavailable = phrases.dateIsUnavailable, |
|
dateIsSelected = phrases.dateIsSelected; |
|
|
|
|
|
var daySizeStyles = { |
|
width: daySize, |
|
height: daySize - 1 |
|
}; |
|
|
|
var useDefaultCursor = modifiers.has('blocked-minimum-nights') || modifiers.has('blocked-calendar') || modifiers.has('blocked-out-of-range'); |
|
|
|
var selected = modifiers.has('selected') || modifiers.has('selected-start') || modifiers.has('selected-end'); |
|
|
|
var hoveredSpan = !selected && (modifiers.has('hovered-span') || modifiers.has('after-hovered-start')); |
|
|
|
var isOutsideRange = modifiers.has('blocked-out-of-range'); |
|
|
|
var formattedDate = { date: day.format(ariaLabelFormat) }; |
|
|
|
var ariaLabel = (0, _getPhrase2['default'])(chooseAvailableDate, formattedDate); |
|
if (modifiers.has(_constants.BLOCKED_MODIFIER)) { |
|
ariaLabel = (0, _getPhrase2['default'])(dateIsUnavailable, formattedDate); |
|
} else if (selected) { |
|
ariaLabel = (0, _getPhrase2['default'])(dateIsSelected, formattedDate); |
|
} |
|
|
|
return { |
|
daySizeStyles: daySizeStyles, |
|
useDefaultCursor: useDefaultCursor, |
|
selected: selected, |
|
hoveredSpan: hoveredSpan, |
|
isOutsideRange: isOutsideRange, |
|
ariaLabel: ariaLabel |
|
}; |
|
} |
|
|
|
/***/ }), |
|
/* 173 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _reactAddonsShallowCompare = __webpack_require__(76); |
|
|
|
var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); |
|
|
|
var _reactMomentProptypes = __webpack_require__(66); |
|
|
|
var _reactMomentProptypes2 = _interopRequireDefault(_reactMomentProptypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _CalendarWeek = __webpack_require__(278); |
|
|
|
var _CalendarWeek2 = _interopRequireDefault(_CalendarWeek); |
|
|
|
var _CalendarDay = __webpack_require__(133); |
|
|
|
var _CalendarDay2 = _interopRequireDefault(_CalendarDay); |
|
|
|
var _calculateDimension = __webpack_require__(174); |
|
|
|
var _calculateDimension2 = _interopRequireDefault(_calculateDimension); |
|
|
|
var _getCalendarMonthWeeks = __webpack_require__(280); |
|
|
|
var _getCalendarMonthWeeks2 = _interopRequireDefault(_getCalendarMonthWeeks); |
|
|
|
var _isSameDay = __webpack_require__(77); |
|
|
|
var _isSameDay2 = _interopRequireDefault(_isSameDay); |
|
|
|
var _toISODateString = __webpack_require__(104); |
|
|
|
var _toISODateString2 = _interopRequireDefault(_toISODateString); |
|
|
|
var _ModifiersShape = __webpack_require__(103); |
|
|
|
var _ModifiersShape2 = _interopRequireDefault(_ModifiersShape); |
|
|
|
var _ScrollableOrientationShape = __webpack_require__(79); |
|
|
|
var _ScrollableOrientationShape2 = _interopRequireDefault(_ScrollableOrientationShape); |
|
|
|
var _DayOfWeekShape = __webpack_require__(73); |
|
|
|
var _DayOfWeekShape2 = _interopRequireDefault(_DayOfWeekShape); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint react/no-array-index-key: 0 */ |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, { |
|
month: _reactMomentProptypes2['default'].momentObj, |
|
horizontalMonthPadding: _airbnbPropTypes.nonNegativeInteger, |
|
isVisible: _propTypes2['default'].bool, |
|
enableOutsideDays: _propTypes2['default'].bool, |
|
modifiers: _propTypes2['default'].objectOf(_ModifiersShape2['default']), |
|
orientation: _ScrollableOrientationShape2['default'], |
|
daySize: _airbnbPropTypes.nonNegativeInteger, |
|
onDayClick: _propTypes2['default'].func, |
|
onDayMouseEnter: _propTypes2['default'].func, |
|
onDayMouseLeave: _propTypes2['default'].func, |
|
onMonthSelect: _propTypes2['default'].func, |
|
onYearSelect: _propTypes2['default'].func, |
|
renderMonthText: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
renderCalendarDay: _propTypes2['default'].func, |
|
renderDayContents: _propTypes2['default'].func, |
|
renderMonthElement: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
firstDayOfWeek: _DayOfWeekShape2['default'], |
|
setMonthTitleHeight: _propTypes2['default'].func, |
|
verticalBorderSpacing: _airbnbPropTypes.nonNegativeInteger, |
|
|
|
focusedDate: _reactMomentProptypes2['default'].momentObj, // indicates focusable day |
|
isFocused: _propTypes2['default'].bool, // indicates whether or not to move focus to focusable day |
|
|
|
// i18n |
|
monthFormat: _propTypes2['default'].string, |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.CalendarDayPhrases)), |
|
dayAriaLabelFormat: _propTypes2['default'].string |
|
})); |
|
|
|
var defaultProps = { |
|
month: (0, _moment2['default'])(), |
|
horizontalMonthPadding: 13, |
|
isVisible: true, |
|
enableOutsideDays: false, |
|
modifiers: {}, |
|
orientation: _constants.HORIZONTAL_ORIENTATION, |
|
daySize: _constants.DAY_SIZE, |
|
onDayClick: function () { |
|
function onDayClick() {} |
|
|
|
return onDayClick; |
|
}(), |
|
onDayMouseEnter: function () { |
|
function onDayMouseEnter() {} |
|
|
|
return onDayMouseEnter; |
|
}(), |
|
onDayMouseLeave: function () { |
|
function onDayMouseLeave() {} |
|
|
|
return onDayMouseLeave; |
|
}(), |
|
onMonthSelect: function () { |
|
function onMonthSelect() {} |
|
|
|
return onMonthSelect; |
|
}(), |
|
onYearSelect: function () { |
|
function onYearSelect() {} |
|
|
|
return onYearSelect; |
|
}(), |
|
|
|
renderMonthText: null, |
|
renderCalendarDay: function () { |
|
function renderCalendarDay(props) { |
|
return _react2['default'].createElement(_CalendarDay2['default'], props); |
|
} |
|
|
|
return renderCalendarDay; |
|
}(), |
|
renderDayContents: null, |
|
renderMonthElement: null, |
|
firstDayOfWeek: null, |
|
setMonthTitleHeight: null, |
|
|
|
focusedDate: null, |
|
isFocused: false, |
|
|
|
// i18n |
|
monthFormat: 'MMMM YYYY', // english locale |
|
phrases: _defaultPhrases.CalendarDayPhrases, |
|
dayAriaLabelFormat: undefined, |
|
verticalBorderSpacing: undefined |
|
}; |
|
|
|
var CalendarMonth = function (_React$Component) { |
|
_inherits(CalendarMonth, _React$Component); |
|
|
|
function CalendarMonth(props) { |
|
_classCallCheck(this, CalendarMonth); |
|
|
|
var _this = _possibleConstructorReturn(this, (CalendarMonth.__proto__ || Object.getPrototypeOf(CalendarMonth)).call(this, props)); |
|
|
|
_this.state = { |
|
weeks: (0, _getCalendarMonthWeeks2['default'])(props.month, props.enableOutsideDays, props.firstDayOfWeek == null ? _moment2['default'].localeData().firstDayOfWeek() : props.firstDayOfWeek) |
|
}; |
|
|
|
_this.setCaptionRef = _this.setCaptionRef.bind(_this); |
|
_this.setMonthTitleHeight = _this.setMonthTitleHeight.bind(_this); |
|
return _this; |
|
} |
|
|
|
_createClass(CalendarMonth, [{ |
|
key: 'componentDidMount', |
|
value: function () { |
|
function componentDidMount() { |
|
this.setMonthTitleHeightTimeout = setTimeout(this.setMonthTitleHeight, 0); |
|
} |
|
|
|
return componentDidMount; |
|
}() |
|
}, { |
|
key: 'componentWillReceiveProps', |
|
value: function () { |
|
function componentWillReceiveProps(nextProps) { |
|
var month = nextProps.month, |
|
enableOutsideDays = nextProps.enableOutsideDays, |
|
firstDayOfWeek = nextProps.firstDayOfWeek; |
|
var _props = this.props, |
|
prevMonth = _props.month, |
|
prevEnableOutsideDays = _props.enableOutsideDays, |
|
prevFirstDayOfWeek = _props.firstDayOfWeek; |
|
|
|
if (!month.isSame(prevMonth) || enableOutsideDays !== prevEnableOutsideDays || firstDayOfWeek !== prevFirstDayOfWeek) { |
|
this.setState({ |
|
weeks: (0, _getCalendarMonthWeeks2['default'])(month, enableOutsideDays, firstDayOfWeek == null ? _moment2['default'].localeData().firstDayOfWeek() : firstDayOfWeek) |
|
}); |
|
} |
|
} |
|
|
|
return componentWillReceiveProps; |
|
}() |
|
}, { |
|
key: 'shouldComponentUpdate', |
|
value: function () { |
|
function shouldComponentUpdate(nextProps, nextState) { |
|
return (0, _reactAddonsShallowCompare2['default'])(this, nextProps, nextState); |
|
} |
|
|
|
return shouldComponentUpdate; |
|
}() |
|
}, { |
|
key: 'componentWillUnmount', |
|
value: function () { |
|
function componentWillUnmount() { |
|
if (this.setMonthTitleHeightTimeout) { |
|
clearTimeout(this.setMonthTitleHeightTimeout); |
|
} |
|
} |
|
|
|
return componentWillUnmount; |
|
}() |
|
}, { |
|
key: 'setMonthTitleHeight', |
|
value: function () { |
|
function setMonthTitleHeight() { |
|
var setMonthTitleHeight = this.props.setMonthTitleHeight; |
|
|
|
if (setMonthTitleHeight) { |
|
var captionHeight = (0, _calculateDimension2['default'])(this.captionRef, 'height', true, true); |
|
setMonthTitleHeight(captionHeight); |
|
} |
|
} |
|
|
|
return setMonthTitleHeight; |
|
}() |
|
}, { |
|
key: 'setCaptionRef', |
|
value: function () { |
|
function setCaptionRef(ref) { |
|
this.captionRef = ref; |
|
} |
|
|
|
return setCaptionRef; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _props2 = this.props, |
|
dayAriaLabelFormat = _props2.dayAriaLabelFormat, |
|
daySize = _props2.daySize, |
|
focusedDate = _props2.focusedDate, |
|
horizontalMonthPadding = _props2.horizontalMonthPadding, |
|
isFocused = _props2.isFocused, |
|
isVisible = _props2.isVisible, |
|
modifiers = _props2.modifiers, |
|
month = _props2.month, |
|
monthFormat = _props2.monthFormat, |
|
onDayClick = _props2.onDayClick, |
|
onDayMouseEnter = _props2.onDayMouseEnter, |
|
onDayMouseLeave = _props2.onDayMouseLeave, |
|
onMonthSelect = _props2.onMonthSelect, |
|
onYearSelect = _props2.onYearSelect, |
|
orientation = _props2.orientation, |
|
phrases = _props2.phrases, |
|
renderCalendarDay = _props2.renderCalendarDay, |
|
renderDayContents = _props2.renderDayContents, |
|
renderMonthElement = _props2.renderMonthElement, |
|
renderMonthText = _props2.renderMonthText, |
|
styles = _props2.styles, |
|
verticalBorderSpacing = _props2.verticalBorderSpacing; |
|
var weeks = this.state.weeks; |
|
|
|
var monthTitle = renderMonthText ? renderMonthText(month) : month.format(monthFormat); |
|
|
|
var verticalScrollable = orientation === _constants.VERTICAL_SCROLLABLE; |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
_extends({}, (0, _reactWithStyles.css)(styles.CalendarMonth, { padding: '0 ' + String(horizontalMonthPadding) + 'px' }), { |
|
'data-visible': isVisible |
|
}), |
|
_react2['default'].createElement( |
|
'div', |
|
_extends({ |
|
ref: this.setCaptionRef |
|
}, (0, _reactWithStyles.css)(styles.CalendarMonth_caption, verticalScrollable && styles.CalendarMonth_caption__verticalScrollable)), |
|
renderMonthElement ? renderMonthElement({ month: month, onMonthSelect: onMonthSelect, onYearSelect: onYearSelect }) : _react2['default'].createElement( |
|
'strong', |
|
null, |
|
monthTitle |
|
) |
|
), |
|
_react2['default'].createElement( |
|
'table', |
|
_extends({}, (0, _reactWithStyles.css)(!verticalBorderSpacing && styles.CalendarMonth_table, verticalBorderSpacing && styles.CalendarMonth_verticalSpacing, verticalBorderSpacing && { borderSpacing: '0px ' + String(verticalBorderSpacing) + 'px' }), { |
|
role: 'presentation' |
|
}), |
|
_react2['default'].createElement( |
|
'tbody', |
|
null, |
|
weeks.map(function (week, i) { |
|
return _react2['default'].createElement( |
|
_CalendarWeek2['default'], |
|
{ key: i }, |
|
week.map(function (day, dayOfWeek) { |
|
return renderCalendarDay({ |
|
key: dayOfWeek, |
|
day: day, |
|
daySize: daySize, |
|
isOutsideDay: !day || day.month() !== month.month(), |
|
tabIndex: isVisible && (0, _isSameDay2['default'])(day, focusedDate) ? 0 : -1, |
|
isFocused: isFocused, |
|
onDayMouseEnter: onDayMouseEnter, |
|
onDayMouseLeave: onDayMouseLeave, |
|
onDayClick: onDayClick, |
|
renderDayContents: renderDayContents, |
|
phrases: phrases, |
|
modifiers: modifiers[(0, _toISODateString2['default'])(day)], |
|
ariaLabelFormat: dayAriaLabelFormat |
|
}); |
|
}) |
|
); |
|
}) |
|
) |
|
) |
|
); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return CalendarMonth; |
|
}(_react2['default'].Component); |
|
|
|
CalendarMonth.propTypes = propTypes; |
|
CalendarMonth.defaultProps = defaultProps; |
|
|
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref) { |
|
var _ref$reactDates = _ref.reactDates, |
|
color = _ref$reactDates.color, |
|
font = _ref$reactDates.font, |
|
spacing = _ref$reactDates.spacing; |
|
return { |
|
CalendarMonth: { |
|
background: color.background, |
|
textAlign: 'center', |
|
verticalAlign: 'top', |
|
userSelect: 'none' |
|
}, |
|
|
|
CalendarMonth_table: { |
|
borderCollapse: 'collapse', |
|
borderSpacing: 0 |
|
}, |
|
|
|
CalendarMonth_verticalSpacing: { |
|
borderCollapse: 'separate' |
|
}, |
|
|
|
CalendarMonth_caption: { |
|
color: color.text, |
|
fontSize: font.captionSize, |
|
textAlign: 'center', |
|
paddingTop: spacing.captionPaddingTop, |
|
paddingBottom: spacing.captionPaddingBottom, |
|
captionSide: 'initial' |
|
}, |
|
|
|
CalendarMonth_caption__verticalScrollable: { |
|
paddingTop: 12, |
|
paddingBottom: 7 |
|
} |
|
}; |
|
})(CalendarMonth); |
|
|
|
/***/ }), |
|
/* 174 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = calculateDimension; |
|
function calculateDimension(el, axis) { |
|
var borderBox = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; |
|
var withMargin = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; |
|
|
|
if (!el) { |
|
return 0; |
|
} |
|
|
|
var axisStart = axis === 'width' ? 'Left' : 'Top'; |
|
var axisEnd = axis === 'width' ? 'Right' : 'Bottom'; |
|
|
|
// Only read styles if we need to |
|
var style = !borderBox || withMargin ? window.getComputedStyle(el) : null; |
|
|
|
// Offset includes border and padding |
|
var offsetWidth = el.offsetWidth, |
|
offsetHeight = el.offsetHeight; |
|
|
|
var size = axis === 'width' ? offsetWidth : offsetHeight; |
|
|
|
// Get the inner size |
|
if (!borderBox) { |
|
size -= parseFloat(style['padding' + axisStart]) + parseFloat(style['padding' + axisEnd]) + parseFloat(style['border' + axisStart + 'Width']) + parseFloat(style['border' + axisEnd + 'Width']); |
|
} |
|
|
|
// Apply margin |
|
if (withMargin) { |
|
size += parseFloat(style['margin' + axisStart]) + parseFloat(style['margin' + axisEnd]); |
|
} |
|
|
|
return size; |
|
} |
|
|
|
/***/ }), |
|
/* 175 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _reactAddonsShallowCompare = __webpack_require__(76); |
|
|
|
var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); |
|
|
|
var _reactMomentProptypes = __webpack_require__(66); |
|
|
|
var _reactMomentProptypes2 = _interopRequireDefault(_reactMomentProptypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _consolidatedEvents = __webpack_require__(105); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _CalendarMonth = __webpack_require__(173); |
|
|
|
var _CalendarMonth2 = _interopRequireDefault(_CalendarMonth); |
|
|
|
var _isTransitionEndSupported = __webpack_require__(281); |
|
|
|
var _isTransitionEndSupported2 = _interopRequireDefault(_isTransitionEndSupported); |
|
|
|
var _getTransformStyles = __webpack_require__(282); |
|
|
|
var _getTransformStyles2 = _interopRequireDefault(_getTransformStyles); |
|
|
|
var _getCalendarMonthWidth = __webpack_require__(176); |
|
|
|
var _getCalendarMonthWidth2 = _interopRequireDefault(_getCalendarMonthWidth); |
|
|
|
var _toISOMonthString = __webpack_require__(106); |
|
|
|
var _toISOMonthString2 = _interopRequireDefault(_toISOMonthString); |
|
|
|
var _isPrevMonth = __webpack_require__(283); |
|
|
|
var _isPrevMonth2 = _interopRequireDefault(_isPrevMonth); |
|
|
|
var _isNextMonth = __webpack_require__(284); |
|
|
|
var _isNextMonth2 = _interopRequireDefault(_isNextMonth); |
|
|
|
var _ModifiersShape = __webpack_require__(103); |
|
|
|
var _ModifiersShape2 = _interopRequireDefault(_ModifiersShape); |
|
|
|
var _ScrollableOrientationShape = __webpack_require__(79); |
|
|
|
var _ScrollableOrientationShape2 = _interopRequireDefault(_ScrollableOrientationShape); |
|
|
|
var _DayOfWeekShape = __webpack_require__(73); |
|
|
|
var _DayOfWeekShape2 = _interopRequireDefault(_DayOfWeekShape); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, { |
|
enableOutsideDays: _propTypes2['default'].bool, |
|
firstVisibleMonthIndex: _propTypes2['default'].number, |
|
horizontalMonthPadding: _airbnbPropTypes.nonNegativeInteger, |
|
initialMonth: _reactMomentProptypes2['default'].momentObj, |
|
isAnimating: _propTypes2['default'].bool, |
|
numberOfMonths: _propTypes2['default'].number, |
|
modifiers: _propTypes2['default'].objectOf(_propTypes2['default'].objectOf(_ModifiersShape2['default'])), |
|
orientation: _ScrollableOrientationShape2['default'], |
|
onDayClick: _propTypes2['default'].func, |
|
onDayMouseEnter: _propTypes2['default'].func, |
|
onDayMouseLeave: _propTypes2['default'].func, |
|
onMonthTransitionEnd: _propTypes2['default'].func, |
|
onMonthChange: _propTypes2['default'].func, |
|
onYearChange: _propTypes2['default'].func, |
|
renderMonthText: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
renderCalendarDay: _propTypes2['default'].func, |
|
renderDayContents: _propTypes2['default'].func, |
|
translationValue: _propTypes2['default'].number, |
|
renderMonthElement: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
daySize: _airbnbPropTypes.nonNegativeInteger, |
|
focusedDate: _reactMomentProptypes2['default'].momentObj, // indicates focusable day |
|
isFocused: _propTypes2['default'].bool, // indicates whether or not to move focus to focusable day |
|
firstDayOfWeek: _DayOfWeekShape2['default'], |
|
setMonthTitleHeight: _propTypes2['default'].func, |
|
isRTL: _propTypes2['default'].bool, |
|
transitionDuration: _airbnbPropTypes.nonNegativeInteger, |
|
verticalBorderSpacing: _airbnbPropTypes.nonNegativeInteger, |
|
|
|
// i18n |
|
monthFormat: _propTypes2['default'].string, |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.CalendarDayPhrases)), |
|
dayAriaLabelFormat: _propTypes2['default'].string |
|
})); |
|
|
|
var defaultProps = { |
|
enableOutsideDays: false, |
|
firstVisibleMonthIndex: 0, |
|
horizontalMonthPadding: 13, |
|
initialMonth: (0, _moment2['default'])(), |
|
isAnimating: false, |
|
numberOfMonths: 1, |
|
modifiers: {}, |
|
orientation: _constants.HORIZONTAL_ORIENTATION, |
|
onDayClick: function () { |
|
function onDayClick() {} |
|
|
|
return onDayClick; |
|
}(), |
|
onDayMouseEnter: function () { |
|
function onDayMouseEnter() {} |
|
|
|
return onDayMouseEnter; |
|
}(), |
|
onDayMouseLeave: function () { |
|
function onDayMouseLeave() {} |
|
|
|
return onDayMouseLeave; |
|
}(), |
|
onMonthChange: function () { |
|
function onMonthChange() {} |
|
|
|
return onMonthChange; |
|
}(), |
|
onYearChange: function () { |
|
function onYearChange() {} |
|
|
|
return onYearChange; |
|
}(), |
|
onMonthTransitionEnd: function () { |
|
function onMonthTransitionEnd() {} |
|
|
|
return onMonthTransitionEnd; |
|
}(), |
|
|
|
renderMonthText: null, |
|
renderCalendarDay: undefined, |
|
renderDayContents: null, |
|
translationValue: null, |
|
renderMonthElement: null, |
|
daySize: _constants.DAY_SIZE, |
|
focusedDate: null, |
|
isFocused: false, |
|
firstDayOfWeek: null, |
|
setMonthTitleHeight: null, |
|
isRTL: false, |
|
transitionDuration: 200, |
|
verticalBorderSpacing: undefined, |
|
|
|
// i18n |
|
monthFormat: 'MMMM YYYY', // english locale |
|
phrases: _defaultPhrases.CalendarDayPhrases, |
|
dayAriaLabelFormat: undefined |
|
}; |
|
|
|
function getMonths(initialMonth, numberOfMonths, withoutTransitionMonths) { |
|
var month = initialMonth.clone(); |
|
if (!withoutTransitionMonths) month = month.subtract(1, 'month'); |
|
|
|
var months = []; |
|
for (var i = 0; i < (withoutTransitionMonths ? numberOfMonths : numberOfMonths + 2); i += 1) { |
|
months.push(month); |
|
month = month.clone().add(1, 'month'); |
|
} |
|
|
|
return months; |
|
} |
|
|
|
var CalendarMonthGrid = function (_React$Component) { |
|
_inherits(CalendarMonthGrid, _React$Component); |
|
|
|
function CalendarMonthGrid(props) { |
|
_classCallCheck(this, CalendarMonthGrid); |
|
|
|
var _this = _possibleConstructorReturn(this, (CalendarMonthGrid.__proto__ || Object.getPrototypeOf(CalendarMonthGrid)).call(this, props)); |
|
|
|
var withoutTransitionMonths = props.orientation === _constants.VERTICAL_SCROLLABLE; |
|
_this.state = { |
|
months: getMonths(props.initialMonth, props.numberOfMonths, withoutTransitionMonths) |
|
}; |
|
|
|
_this.isTransitionEndSupported = (0, _isTransitionEndSupported2['default'])(); |
|
_this.onTransitionEnd = _this.onTransitionEnd.bind(_this); |
|
_this.setContainerRef = _this.setContainerRef.bind(_this); |
|
|
|
_this.locale = _moment2['default'].locale(); |
|
_this.onMonthSelect = _this.onMonthSelect.bind(_this); |
|
_this.onYearSelect = _this.onYearSelect.bind(_this); |
|
return _this; |
|
} |
|
|
|
_createClass(CalendarMonthGrid, [{ |
|
key: 'componentDidMount', |
|
value: function () { |
|
function componentDidMount() { |
|
this.removeEventListener = (0, _consolidatedEvents.addEventListener)(this.container, 'transitionend', this.onTransitionEnd); |
|
} |
|
|
|
return componentDidMount; |
|
}() |
|
}, { |
|
key: 'componentWillReceiveProps', |
|
value: function () { |
|
function componentWillReceiveProps(nextProps) { |
|
var _this2 = this; |
|
|
|
var initialMonth = nextProps.initialMonth, |
|
numberOfMonths = nextProps.numberOfMonths, |
|
orientation = nextProps.orientation; |
|
var months = this.state.months; |
|
var _props = this.props, |
|
prevInitialMonth = _props.initialMonth, |
|
prevNumberOfMonths = _props.numberOfMonths; |
|
|
|
var hasMonthChanged = !prevInitialMonth.isSame(initialMonth, 'month'); |
|
var hasNumberOfMonthsChanged = prevNumberOfMonths !== numberOfMonths; |
|
var newMonths = months; |
|
|
|
if (hasMonthChanged && !hasNumberOfMonthsChanged) { |
|
if ((0, _isNextMonth2['default'])(prevInitialMonth, initialMonth)) { |
|
newMonths = months.slice(1); |
|
newMonths.push(months[months.length - 1].clone().add(1, 'month')); |
|
} else if ((0, _isPrevMonth2['default'])(prevInitialMonth, initialMonth)) { |
|
newMonths = months.slice(0, months.length - 1); |
|
newMonths.unshift(months[0].clone().subtract(1, 'month')); |
|
} else { |
|
var withoutTransitionMonths = orientation === _constants.VERTICAL_SCROLLABLE; |
|
newMonths = getMonths(initialMonth, numberOfMonths, withoutTransitionMonths); |
|
} |
|
} |
|
|
|
if (hasNumberOfMonthsChanged) { |
|
var _withoutTransitionMonths = orientation === _constants.VERTICAL_SCROLLABLE; |
|
newMonths = getMonths(initialMonth, numberOfMonths, _withoutTransitionMonths); |
|
} |
|
|
|
var momentLocale = _moment2['default'].locale(); |
|
if (this.locale !== momentLocale) { |
|
this.locale = momentLocale; |
|
newMonths = newMonths.map(function (m) { |
|
return m.locale(_this2.locale); |
|
}); |
|
} |
|
|
|
this.setState({ |
|
months: newMonths |
|
}); |
|
} |
|
|
|
return componentWillReceiveProps; |
|
}() |
|
}, { |
|
key: 'shouldComponentUpdate', |
|
value: function () { |
|
function shouldComponentUpdate(nextProps, nextState) { |
|
return (0, _reactAddonsShallowCompare2['default'])(this, nextProps, nextState); |
|
} |
|
|
|
return shouldComponentUpdate; |
|
}() |
|
}, { |
|
key: 'componentDidUpdate', |
|
value: function () { |
|
function componentDidUpdate() { |
|
var _props2 = this.props, |
|
isAnimating = _props2.isAnimating, |
|
transitionDuration = _props2.transitionDuration, |
|
onMonthTransitionEnd = _props2.onMonthTransitionEnd; |
|
|
|
// For IE9, immediately call onMonthTransitionEnd instead of |
|
// waiting for the animation to complete. Similarly, if transitionDuration |
|
// is set to 0, also immediately invoke the onMonthTransitionEnd callback |
|
|
|
if ((!this.isTransitionEndSupported || !transitionDuration) && isAnimating) { |
|
onMonthTransitionEnd(); |
|
} |
|
} |
|
|
|
return componentDidUpdate; |
|
}() |
|
}, { |
|
key: 'componentWillUnmount', |
|
value: function () { |
|
function componentWillUnmount() { |
|
if (this.removeEventListener) this.removeEventListener(); |
|
} |
|
|
|
return componentWillUnmount; |
|
}() |
|
}, { |
|
key: 'onTransitionEnd', |
|
value: function () { |
|
function onTransitionEnd() { |
|
var onMonthTransitionEnd = this.props.onMonthTransitionEnd; |
|
|
|
onMonthTransitionEnd(); |
|
} |
|
|
|
return onTransitionEnd; |
|
}() |
|
}, { |
|
key: 'onMonthSelect', |
|
value: function () { |
|
function onMonthSelect(currentMonth, newMonthVal) { |
|
var newMonth = currentMonth.clone(); |
|
var _props3 = this.props, |
|
onMonthChange = _props3.onMonthChange, |
|
orientation = _props3.orientation; |
|
var months = this.state.months; |
|
|
|
var withoutTransitionMonths = orientation === _constants.VERTICAL_SCROLLABLE; |
|
var initialMonthSubtraction = months.indexOf(currentMonth); |
|
if (!withoutTransitionMonths) { |
|
initialMonthSubtraction -= 1; |
|
} |
|
newMonth.set('month', newMonthVal).subtract(initialMonthSubtraction, 'months'); |
|
onMonthChange(newMonth); |
|
} |
|
|
|
return onMonthSelect; |
|
}() |
|
}, { |
|
key: 'onYearSelect', |
|
value: function () { |
|
function onYearSelect(currentMonth, newYearVal) { |
|
var newMonth = currentMonth.clone(); |
|
var _props4 = this.props, |
|
onYearChange = _props4.onYearChange, |
|
orientation = _props4.orientation; |
|
var months = this.state.months; |
|
|
|
var withoutTransitionMonths = orientation === _constants.VERTICAL_SCROLLABLE; |
|
var initialMonthSubtraction = months.indexOf(currentMonth); |
|
if (!withoutTransitionMonths) { |
|
initialMonthSubtraction -= 1; |
|
} |
|
newMonth.set('year', newYearVal).subtract(initialMonthSubtraction, 'months'); |
|
onYearChange(newMonth); |
|
} |
|
|
|
return onYearSelect; |
|
}() |
|
}, { |
|
key: 'setContainerRef', |
|
value: function () { |
|
function setContainerRef(ref) { |
|
this.container = ref; |
|
} |
|
|
|
return setContainerRef; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _this3 = this; |
|
|
|
var _props5 = this.props, |
|
enableOutsideDays = _props5.enableOutsideDays, |
|
firstVisibleMonthIndex = _props5.firstVisibleMonthIndex, |
|
horizontalMonthPadding = _props5.horizontalMonthPadding, |
|
isAnimating = _props5.isAnimating, |
|
modifiers = _props5.modifiers, |
|
numberOfMonths = _props5.numberOfMonths, |
|
monthFormat = _props5.monthFormat, |
|
orientation = _props5.orientation, |
|
translationValue = _props5.translationValue, |
|
daySize = _props5.daySize, |
|
onDayMouseEnter = _props5.onDayMouseEnter, |
|
onDayMouseLeave = _props5.onDayMouseLeave, |
|
onDayClick = _props5.onDayClick, |
|
renderMonthText = _props5.renderMonthText, |
|
renderCalendarDay = _props5.renderCalendarDay, |
|
renderDayContents = _props5.renderDayContents, |
|
renderMonthElement = _props5.renderMonthElement, |
|
onMonthTransitionEnd = _props5.onMonthTransitionEnd, |
|
firstDayOfWeek = _props5.firstDayOfWeek, |
|
focusedDate = _props5.focusedDate, |
|
isFocused = _props5.isFocused, |
|
isRTL = _props5.isRTL, |
|
styles = _props5.styles, |
|
phrases = _props5.phrases, |
|
dayAriaLabelFormat = _props5.dayAriaLabelFormat, |
|
transitionDuration = _props5.transitionDuration, |
|
verticalBorderSpacing = _props5.verticalBorderSpacing, |
|
setMonthTitleHeight = _props5.setMonthTitleHeight; |
|
var months = this.state.months; |
|
|
|
var isVertical = orientation === _constants.VERTICAL_ORIENTATION; |
|
var isVerticalScrollable = orientation === _constants.VERTICAL_SCROLLABLE; |
|
var isHorizontal = orientation === _constants.HORIZONTAL_ORIENTATION; |
|
|
|
var calendarMonthWidth = (0, _getCalendarMonthWidth2['default'])(daySize, horizontalMonthPadding); |
|
|
|
var width = isVertical || isVerticalScrollable ? calendarMonthWidth : (numberOfMonths + 2) * calendarMonthWidth; |
|
|
|
var transformType = isVertical || isVerticalScrollable ? 'translateY' : 'translateX'; |
|
var transformValue = transformType + '(' + String(translationValue) + 'px)'; |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
_extends({}, (0, _reactWithStyles.css)(styles.CalendarMonthGrid, isHorizontal && styles.CalendarMonthGrid__horizontal, isVertical && styles.CalendarMonthGrid__vertical, isVerticalScrollable && styles.CalendarMonthGrid__vertical_scrollable, isAnimating && styles.CalendarMonthGrid__animating, isAnimating && transitionDuration && { |
|
transition: 'transform ' + String(transitionDuration) + 'ms ease-in-out' |
|
}, (0, _object2['default'])({}, (0, _getTransformStyles2['default'])(transformValue), { |
|
width: width |
|
})), { |
|
ref: this.setContainerRef, |
|
onTransitionEnd: onMonthTransitionEnd |
|
}), |
|
months.map(function (month, i) { |
|
var isVisible = i >= firstVisibleMonthIndex && i < firstVisibleMonthIndex + numberOfMonths; |
|
var hideForAnimation = i === 0 && !isVisible; |
|
var showForAnimation = i === 0 && isAnimating && isVisible; |
|
var monthString = (0, _toISOMonthString2['default'])(month); |
|
return _react2['default'].createElement( |
|
'div', |
|
_extends({ |
|
key: monthString |
|
}, (0, _reactWithStyles.css)(isHorizontal && styles.CalendarMonthGrid_month__horizontal, hideForAnimation && styles.CalendarMonthGrid_month__hideForAnimation, showForAnimation && !isVertical && !isRTL && { |
|
position: 'absolute', |
|
left: -calendarMonthWidth |
|
}, showForAnimation && !isVertical && isRTL && { |
|
position: 'absolute', |
|
right: 0 |
|
}, showForAnimation && isVertical && { |
|
position: 'absolute', |
|
top: -translationValue |
|
}, !isVisible && !isAnimating && styles.CalendarMonthGrid_month__hidden)), |
|
_react2['default'].createElement(_CalendarMonth2['default'], { |
|
month: month, |
|
isVisible: isVisible, |
|
enableOutsideDays: enableOutsideDays, |
|
modifiers: modifiers[monthString], |
|
monthFormat: monthFormat, |
|
orientation: orientation, |
|
onDayMouseEnter: onDayMouseEnter, |
|
onDayMouseLeave: onDayMouseLeave, |
|
onDayClick: onDayClick, |
|
onMonthSelect: _this3.onMonthSelect, |
|
onYearSelect: _this3.onYearSelect, |
|
renderMonthText: renderMonthText, |
|
renderCalendarDay: renderCalendarDay, |
|
renderDayContents: renderDayContents, |
|
renderMonthElement: renderMonthElement, |
|
firstDayOfWeek: firstDayOfWeek, |
|
daySize: daySize, |
|
focusedDate: isVisible ? focusedDate : null, |
|
isFocused: isFocused, |
|
phrases: phrases, |
|
setMonthTitleHeight: setMonthTitleHeight, |
|
dayAriaLabelFormat: dayAriaLabelFormat, |
|
verticalBorderSpacing: verticalBorderSpacing, |
|
horizontalMonthPadding: horizontalMonthPadding |
|
}) |
|
); |
|
}) |
|
); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return CalendarMonthGrid; |
|
}(_react2['default'].Component); |
|
|
|
CalendarMonthGrid.propTypes = propTypes; |
|
CalendarMonthGrid.defaultProps = defaultProps; |
|
|
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref) { |
|
var _ref$reactDates = _ref.reactDates, |
|
color = _ref$reactDates.color, |
|
noScrollBarOnVerticalScrollable = _ref$reactDates.noScrollBarOnVerticalScrollable, |
|
spacing = _ref$reactDates.spacing, |
|
zIndex = _ref$reactDates.zIndex; |
|
return { |
|
CalendarMonthGrid: { |
|
background: color.background, |
|
textAlign: 'left', |
|
zIndex: zIndex |
|
}, |
|
|
|
CalendarMonthGrid__animating: { |
|
zIndex: zIndex + 1 |
|
}, |
|
|
|
CalendarMonthGrid__horizontal: { |
|
position: 'absolute', |
|
left: spacing.dayPickerHorizontalPadding |
|
}, |
|
|
|
CalendarMonthGrid__vertical: { |
|
margin: '0 auto' |
|
}, |
|
|
|
CalendarMonthGrid__vertical_scrollable: (0, _object2['default'])({ |
|
margin: '0 auto', |
|
overflowY: 'scroll' |
|
}, noScrollBarOnVerticalScrollable && { |
|
'-webkitOverflowScrolling': 'touch', |
|
'::-webkit-scrollbar': { |
|
'-webkit-appearance': 'none', |
|
display: 'none' |
|
} |
|
}), |
|
|
|
CalendarMonthGrid_month__horizontal: { |
|
display: 'inline-block', |
|
verticalAlign: 'top', |
|
minHeight: '100%' |
|
}, |
|
|
|
CalendarMonthGrid_month__hideForAnimation: { |
|
position: 'absolute', |
|
zIndex: zIndex - 1, |
|
opacity: 0, |
|
pointerEvents: 'none' |
|
}, |
|
|
|
CalendarMonthGrid_month__hidden: { |
|
visibility: 'hidden' |
|
} |
|
}; |
|
})(CalendarMonthGrid); |
|
|
|
/***/ }), |
|
/* 176 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports["default"] = getCalendarMonthWidth; |
|
function getCalendarMonthWidth(daySize, calendarMonthPadding) { |
|
return 7 * daySize + 2 * calendarMonthPadding + 1; |
|
} |
|
|
|
/***/ }), |
|
/* 177 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = isSameMonth; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function isSameMonth(a, b) { |
|
if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false; |
|
// Compare least significant, most likely to change units first |
|
// Moment's isSame clones moment inputs and is a tad slow |
|
return a.month() === b.month() && a.year() === b.year(); |
|
} |
|
|
|
/***/ }), |
|
/* 178 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var ES = __webpack_require__(287); |
|
var has = __webpack_require__(63); |
|
var bind = __webpack_require__(59); |
|
var isEnumerable = bind.call(Function.call, Object.prototype.propertyIsEnumerable); |
|
|
|
module.exports = function values(O) { |
|
var obj = ES.RequireObjectCoercible(O); |
|
var vals = []; |
|
for (var key in obj) { |
|
if (has(obj, key) && isEnumerable(obj, key)) { |
|
vals.push(obj[key]); |
|
} |
|
} |
|
return vals; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 179 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var GetIntrinsic = __webpack_require__(136); |
|
|
|
var $TypeError = GetIntrinsic('%TypeError%'); |
|
var $SyntaxError = GetIntrinsic('%SyntaxError%'); |
|
|
|
var has = __webpack_require__(63); |
|
|
|
var predicates = { |
|
// https://ecma-international.org/ecma-262/6.0/#sec-property-descriptor-specification-type |
|
'Property Descriptor': function isPropertyDescriptor(ES, Desc) { |
|
if (ES.Type(Desc) !== 'Object') { |
|
return false; |
|
} |
|
var allowed = { |
|
'[[Configurable]]': true, |
|
'[[Enumerable]]': true, |
|
'[[Get]]': true, |
|
'[[Set]]': true, |
|
'[[Value]]': true, |
|
'[[Writable]]': true |
|
}; |
|
|
|
for (var key in Desc) { // eslint-disable-line |
|
if (has(Desc, key) && !allowed[key]) { |
|
return false; |
|
} |
|
} |
|
|
|
var isData = has(Desc, '[[Value]]'); |
|
var IsAccessor = has(Desc, '[[Get]]') || has(Desc, '[[Set]]'); |
|
if (isData && IsAccessor) { |
|
throw new $TypeError('Property Descriptors may not be both accessor and data descriptors'); |
|
} |
|
return true; |
|
} |
|
}; |
|
|
|
module.exports = function assertRecord(ES, recordType, argumentName, value) { |
|
var predicate = predicates[recordType]; |
|
if (typeof predicate !== 'function') { |
|
throw new $SyntaxError('unknown record type: ' + recordType); |
|
} |
|
if (!predicate(ES, value)) { |
|
throw new $TypeError(argumentName + ' must be a ' + recordType); |
|
} |
|
console.log(predicate(ES, value), value); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 180 */ |
|
/***/ (function(module, exports) { |
|
|
|
module.exports = Number.isNaN || function isNaN(a) { |
|
return a !== a; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 181 */ |
|
/***/ (function(module, exports) { |
|
|
|
var $isNaN = Number.isNaN || function (a) { return a !== a; }; |
|
|
|
module.exports = Number.isFinite || function (x) { return typeof x === 'number' && !$isNaN(x) && x !== Infinity && x !== -Infinity; }; |
|
|
|
|
|
/***/ }), |
|
/* 182 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var bind = __webpack_require__(59); |
|
var has = bind.call(Function.call, Object.prototype.hasOwnProperty); |
|
|
|
var $assign = Object.assign; |
|
|
|
module.exports = function assign(target, source) { |
|
if ($assign) { |
|
return $assign(target, source); |
|
} |
|
|
|
for (var key in source) { |
|
if (has(source, key)) { |
|
target[key] = source[key]; |
|
} |
|
} |
|
return target; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 183 */ |
|
/***/ (function(module, exports) { |
|
|
|
module.exports = function sign(number) { |
|
return number >= 0 ? 1 : -1; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 184 */ |
|
/***/ (function(module, exports) { |
|
|
|
module.exports = function mod(number, modulo) { |
|
var remain = number % modulo; |
|
return Math.floor(remain >= 0 ? remain : remain + modulo); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 185 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var implementation = __webpack_require__(178); |
|
|
|
module.exports = function getPolyfill() { |
|
return typeof Object.values === 'function' ? Object.values : implementation; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 186 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
module.exports = function contains(other) { |
|
if (arguments.length < 1) { |
|
throw new TypeError('1 argument is required'); |
|
} |
|
if (typeof other !== 'object') { |
|
throw new TypeError('Argument 1 (”other“) to Node.contains must be an instance of Node'); |
|
} |
|
|
|
var node = other; |
|
do { |
|
if (this === node) { |
|
return true; |
|
} |
|
if (node) { |
|
node = node.parentNode; |
|
} |
|
} while (node); |
|
|
|
return false; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 187 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var implementation = __webpack_require__(186); |
|
|
|
module.exports = function getPolyfill() { |
|
if (typeof document !== 'undefined') { |
|
if (document.contains) { |
|
return document.contains; |
|
} |
|
if (document.body && document.body.contains) { |
|
return document.body.contains; |
|
} |
|
} |
|
return implementation; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 188 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _reactMomentProptypes = __webpack_require__(66); |
|
|
|
var _reactMomentProptypes2 = _interopRequireDefault(_reactMomentProptypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _FocusedInputShape = __webpack_require__(189); |
|
|
|
var _FocusedInputShape2 = _interopRequireDefault(_FocusedInputShape); |
|
|
|
var _IconPositionShape = __webpack_require__(92); |
|
|
|
var _IconPositionShape2 = _interopRequireDefault(_IconPositionShape); |
|
|
|
var _OrientationShape = __webpack_require__(190); |
|
|
|
var _OrientationShape2 = _interopRequireDefault(_OrientationShape); |
|
|
|
var _DisabledShape = __webpack_require__(107); |
|
|
|
var _DisabledShape2 = _interopRequireDefault(_DisabledShape); |
|
|
|
var _AnchorDirectionShape = __webpack_require__(191); |
|
|
|
var _AnchorDirectionShape2 = _interopRequireDefault(_AnchorDirectionShape); |
|
|
|
var _OpenDirectionShape = __webpack_require__(81); |
|
|
|
var _OpenDirectionShape2 = _interopRequireDefault(_OpenDirectionShape); |
|
|
|
var _DayOfWeekShape = __webpack_require__(73); |
|
|
|
var _DayOfWeekShape2 = _interopRequireDefault(_DayOfWeekShape); |
|
|
|
var _CalendarInfoPositionShape = __webpack_require__(93); |
|
|
|
var _CalendarInfoPositionShape2 = _interopRequireDefault(_CalendarInfoPositionShape); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
exports['default'] = { |
|
// required props for a functional interactive DateRangePicker |
|
startDate: _reactMomentProptypes2['default'].momentObj, |
|
endDate: _reactMomentProptypes2['default'].momentObj, |
|
onDatesChange: _propTypes2['default'].func.isRequired, |
|
|
|
focusedInput: _FocusedInputShape2['default'], |
|
onFocusChange: _propTypes2['default'].func.isRequired, |
|
|
|
onClose: _propTypes2['default'].func, |
|
|
|
// input related props |
|
startDateId: _propTypes2['default'].string.isRequired, |
|
startDatePlaceholderText: _propTypes2['default'].string, |
|
endDateId: _propTypes2['default'].string.isRequired, |
|
endDatePlaceholderText: _propTypes2['default'].string, |
|
disabled: _DisabledShape2['default'], |
|
required: _propTypes2['default'].bool, |
|
readOnly: _propTypes2['default'].bool, |
|
screenReaderInputMessage: _propTypes2['default'].string, |
|
showClearDates: _propTypes2['default'].bool, |
|
showDefaultInputIcon: _propTypes2['default'].bool, |
|
inputIconPosition: _IconPositionShape2['default'], |
|
customInputIcon: _propTypes2['default'].node, |
|
customArrowIcon: _propTypes2['default'].node, |
|
customCloseIcon: _propTypes2['default'].node, |
|
noBorder: _propTypes2['default'].bool, |
|
block: _propTypes2['default'].bool, |
|
small: _propTypes2['default'].bool, |
|
regular: _propTypes2['default'].bool, |
|
keepFocusOnInput: _propTypes2['default'].bool, |
|
|
|
// calendar presentation and interaction related props |
|
renderMonthText: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
renderMonthElement: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
orientation: _OrientationShape2['default'], |
|
anchorDirection: _AnchorDirectionShape2['default'], |
|
openDirection: _OpenDirectionShape2['default'], |
|
horizontalMargin: _propTypes2['default'].number, |
|
withPortal: _propTypes2['default'].bool, |
|
withFullScreenPortal: _propTypes2['default'].bool, |
|
appendToBody: _propTypes2['default'].bool, |
|
disableScroll: _propTypes2['default'].bool, |
|
daySize: _airbnbPropTypes.nonNegativeInteger, |
|
isRTL: _propTypes2['default'].bool, |
|
firstDayOfWeek: _DayOfWeekShape2['default'], |
|
initialVisibleMonth: _propTypes2['default'].func, |
|
numberOfMonths: _propTypes2['default'].number, |
|
keepOpenOnDateSelect: _propTypes2['default'].bool, |
|
reopenPickerOnClearDates: _propTypes2['default'].bool, |
|
renderCalendarInfo: _propTypes2['default'].func, |
|
calendarInfoPosition: _CalendarInfoPositionShape2['default'], |
|
hideKeyboardShortcutsPanel: _propTypes2['default'].bool, |
|
verticalHeight: _airbnbPropTypes.nonNegativeInteger, |
|
transitionDuration: _airbnbPropTypes.nonNegativeInteger, |
|
verticalSpacing: _airbnbPropTypes.nonNegativeInteger, |
|
|
|
// navigation related props |
|
navPrev: _propTypes2['default'].node, |
|
navNext: _propTypes2['default'].node, |
|
onPrevMonthClick: _propTypes2['default'].func, |
|
onNextMonthClick: _propTypes2['default'].func, |
|
|
|
// day presentation and interaction related props |
|
renderCalendarDay: _propTypes2['default'].func, |
|
renderDayContents: _propTypes2['default'].func, |
|
minimumNights: _propTypes2['default'].number, |
|
enableOutsideDays: _propTypes2['default'].bool, |
|
isDayBlocked: _propTypes2['default'].func, |
|
isOutsideRange: _propTypes2['default'].func, |
|
isDayHighlighted: _propTypes2['default'].func, |
|
|
|
// internationalization props |
|
displayFormat: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].func]), |
|
monthFormat: _propTypes2['default'].string, |
|
weekDayFormat: _propTypes2['default'].string, |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.DateRangePickerPhrases)), |
|
dayAriaLabelFormat: _propTypes2['default'].string |
|
}; |
|
|
|
/***/ }), |
|
/* 189 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
exports['default'] = _propTypes2['default'].oneOf([_constants.START_DATE, _constants.END_DATE]); |
|
|
|
/***/ }), |
|
/* 190 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
exports['default'] = _propTypes2['default'].oneOf([_constants.HORIZONTAL_ORIENTATION, _constants.VERTICAL_ORIENTATION]); |
|
|
|
/***/ }), |
|
/* 191 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
exports['default'] = _propTypes2['default'].oneOf([_constants.ANCHOR_LEFT, _constants.ANCHOR_RIGHT]); |
|
|
|
/***/ }), |
|
/* 192 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = getResponsiveContainerStyles; |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } |
|
|
|
function getResponsiveContainerStyles(anchorDirection, currentOffset, containerEdge, margin) { |
|
var windowWidth = typeof window !== 'undefined' ? window.innerWidth : 0; |
|
var calculatedOffset = anchorDirection === _constants.ANCHOR_LEFT ? windowWidth - containerEdge : containerEdge; |
|
var calculatedMargin = margin || 0; |
|
|
|
return _defineProperty({}, anchorDirection, Math.min(currentOffset + calculatedOffset - calculatedMargin, 0)); |
|
} |
|
|
|
/***/ }), |
|
/* 193 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = getDetachedContainerStyles; |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
/** |
|
* Calculate and return a CSS transform style to position a detached element |
|
* next to a reference element. The open and anchor direction indicate wether |
|
* it should be positioned above/below and/or to the left/right of the |
|
* reference element. |
|
* |
|
* Assuming r(0,0), r(1,1), d(0,0), d(1,1) for the bottom-left and top-right |
|
* corners of the reference and detached elements, respectively: |
|
* - openDirection = DOWN, anchorDirection = LEFT => d(0,1) == r(0,1) |
|
* - openDirection = UP, anchorDirection = LEFT => d(0,0) == r(0,0) |
|
* - openDirection = DOWN, anchorDirection = RIGHT => d(1,1) == r(1,1) |
|
* - openDirection = UP, anchorDirection = RIGHT => d(1,0) == r(1,0) |
|
* |
|
* By using a CSS transform, we allow to further position it using |
|
* top/bottom CSS properties for the anchor gutter. |
|
* |
|
* @param {string} openDirection The vertical positioning of the popup |
|
* @param {string} anchorDirection The horizontal position of the popup |
|
* @param {HTMLElement} referenceEl The reference element |
|
*/ |
|
function getDetachedContainerStyles(openDirection, anchorDirection, referenceEl) { |
|
var referenceRect = referenceEl.getBoundingClientRect(); |
|
var offsetX = referenceRect.left; |
|
var offsetY = referenceRect.top; |
|
|
|
if (openDirection === _constants.OPEN_UP) { |
|
offsetY = -(window.innerHeight - referenceRect.bottom); |
|
} |
|
|
|
if (anchorDirection === _constants.ANCHOR_RIGHT) { |
|
offsetX = -(window.innerWidth - referenceRect.right); |
|
} |
|
|
|
return { |
|
transform: 'translate3d(' + String(Math.round(offsetX)) + 'px, ' + String(Math.round(offsetY)) + 'px, 0)' |
|
}; |
|
} |
|
|
|
/***/ }), |
|
/* 194 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.getScrollParent = getScrollParent; |
|
exports.getScrollAncestorsOverflowY = getScrollAncestorsOverflowY; |
|
exports['default'] = disableScroll; |
|
var getScrollingRoot = function getScrollingRoot() { |
|
return document.scrollingElement || document.documentElement; |
|
}; |
|
|
|
/** |
|
* Recursively finds the scroll parent of a node. The scroll parrent of a node |
|
* is the closest node that is scrollable. A node is scrollable if: |
|
* - it is allowed to scroll via CSS ('overflow-y' not visible or hidden); |
|
* - and its children/content are "bigger" than the node's box height. |
|
* |
|
* The root of the document always scrolls by default. |
|
* |
|
* @param {HTMLElement} node Any DOM element. |
|
* @return {HTMLElement} The scroll parent element. |
|
*/ |
|
function getScrollParent(node) { |
|
var parent = node.parentElement; |
|
|
|
if (parent == null) return getScrollingRoot(); |
|
|
|
var _window$getComputedSt = window.getComputedStyle(parent), |
|
overflowY = _window$getComputedSt.overflowY; |
|
|
|
var canScroll = overflowY !== 'visible' && overflowY !== 'hidden'; |
|
|
|
if (canScroll && parent.scrollHeight > parent.clientHeight) { |
|
return parent; |
|
} |
|
|
|
return getScrollParent(parent); |
|
} |
|
|
|
/** |
|
* Recursively traverses the tree upwards from the given node, capturing all |
|
* ancestor nodes that scroll along with their current 'overflow-y' CSS |
|
* property. |
|
* |
|
* @param {HTMLElement} node Any DOM element. |
|
* @param {Map<HTMLElement,string>} [acc] Accumulator map. |
|
* @return {Map<HTMLElement,string>} Map of ancestors with their 'overflow-y' value. |
|
*/ |
|
function getScrollAncestorsOverflowY(node) { |
|
var acc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Map(); |
|
|
|
var scrollingRoot = getScrollingRoot(); |
|
var scrollParent = getScrollParent(node); |
|
acc.set(scrollParent, scrollParent.style.overflowY); |
|
|
|
if (scrollParent === scrollingRoot) return acc; |
|
return getScrollAncestorsOverflowY(scrollParent, acc); |
|
} |
|
|
|
/** |
|
* Disabling the scroll on a node involves finding all the scrollable ancestors |
|
* and set their 'overflow-y' CSS property to 'hidden'. When all ancestors have |
|
* 'overflow-y: hidden' (up to the document element) there is no scroll |
|
* container, thus all the scroll outside of the node is disabled. In order to |
|
* enable scroll again, we store the previous value of the 'overflow-y' for |
|
* every ancestor in a closure and reset it back. |
|
* |
|
* @param {HTMLElement} node Any DOM element. |
|
*/ |
|
function disableScroll(node) { |
|
var scrollAncestorsOverflowY = getScrollAncestorsOverflowY(node); |
|
var toggle = function toggle(on) { |
|
return scrollAncestorsOverflowY.forEach(function (overflowY, ancestor) { |
|
ancestor.style.setProperty('overflow-y', on ? 'hidden' : overflowY); |
|
}); |
|
}; |
|
|
|
toggle(true); |
|
return function () { |
|
return toggle(false); |
|
}; |
|
} |
|
|
|
/***/ }), |
|
/* 195 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _reactMomentProptypes = __webpack_require__(66); |
|
|
|
var _reactMomentProptypes2 = _interopRequireDefault(_reactMomentProptypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _OpenDirectionShape = __webpack_require__(81); |
|
|
|
var _OpenDirectionShape2 = _interopRequireDefault(_OpenDirectionShape); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _DateRangePickerInput = __webpack_require__(196); |
|
|
|
var _DateRangePickerInput2 = _interopRequireDefault(_DateRangePickerInput); |
|
|
|
var _IconPositionShape = __webpack_require__(92); |
|
|
|
var _IconPositionShape2 = _interopRequireDefault(_IconPositionShape); |
|
|
|
var _DisabledShape = __webpack_require__(107); |
|
|
|
var _DisabledShape2 = _interopRequireDefault(_DisabledShape); |
|
|
|
var _toMomentObject = __webpack_require__(78); |
|
|
|
var _toMomentObject2 = _interopRequireDefault(_toMomentObject); |
|
|
|
var _toLocalizedDateString = __webpack_require__(139); |
|
|
|
var _toLocalizedDateString2 = _interopRequireDefault(_toLocalizedDateString); |
|
|
|
var _isInclusivelyAfterDay = __webpack_require__(94); |
|
|
|
var _isInclusivelyAfterDay2 = _interopRequireDefault(_isInclusivelyAfterDay); |
|
|
|
var _isBeforeDay = __webpack_require__(95); |
|
|
|
var _isBeforeDay2 = _interopRequireDefault(_isBeforeDay); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)({ |
|
startDate: _reactMomentProptypes2['default'].momentObj, |
|
startDateId: _propTypes2['default'].string, |
|
startDatePlaceholderText: _propTypes2['default'].string, |
|
isStartDateFocused: _propTypes2['default'].bool, |
|
|
|
endDate: _reactMomentProptypes2['default'].momentObj, |
|
endDateId: _propTypes2['default'].string, |
|
endDatePlaceholderText: _propTypes2['default'].string, |
|
isEndDateFocused: _propTypes2['default'].bool, |
|
|
|
screenReaderMessage: _propTypes2['default'].string, |
|
showClearDates: _propTypes2['default'].bool, |
|
showCaret: _propTypes2['default'].bool, |
|
showDefaultInputIcon: _propTypes2['default'].bool, |
|
inputIconPosition: _IconPositionShape2['default'], |
|
disabled: _DisabledShape2['default'], |
|
required: _propTypes2['default'].bool, |
|
readOnly: _propTypes2['default'].bool, |
|
openDirection: _OpenDirectionShape2['default'], |
|
noBorder: _propTypes2['default'].bool, |
|
block: _propTypes2['default'].bool, |
|
small: _propTypes2['default'].bool, |
|
regular: _propTypes2['default'].bool, |
|
verticalSpacing: _airbnbPropTypes.nonNegativeInteger, |
|
|
|
keepOpenOnDateSelect: _propTypes2['default'].bool, |
|
reopenPickerOnClearDates: _propTypes2['default'].bool, |
|
withFullScreenPortal: _propTypes2['default'].bool, |
|
minimumNights: _airbnbPropTypes.nonNegativeInteger, |
|
isOutsideRange: _propTypes2['default'].func, |
|
displayFormat: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].func]), |
|
|
|
onFocusChange: _propTypes2['default'].func, |
|
onClose: _propTypes2['default'].func, |
|
onDatesChange: _propTypes2['default'].func, |
|
onKeyDownArrowDown: _propTypes2['default'].func, |
|
onKeyDownQuestionMark: _propTypes2['default'].func, |
|
|
|
customInputIcon: _propTypes2['default'].node, |
|
customArrowIcon: _propTypes2['default'].node, |
|
customCloseIcon: _propTypes2['default'].node, |
|
|
|
// accessibility |
|
isFocused: _propTypes2['default'].bool, |
|
|
|
// i18n |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.DateRangePickerInputPhrases)), |
|
|
|
isRTL: _propTypes2['default'].bool |
|
}); |
|
|
|
var defaultProps = { |
|
startDate: null, |
|
startDateId: _constants.START_DATE, |
|
startDatePlaceholderText: 'Start Date', |
|
isStartDateFocused: false, |
|
|
|
endDate: null, |
|
endDateId: _constants.END_DATE, |
|
endDatePlaceholderText: 'End Date', |
|
isEndDateFocused: false, |
|
|
|
screenReaderMessage: '', |
|
showClearDates: false, |
|
showCaret: false, |
|
showDefaultInputIcon: false, |
|
inputIconPosition: _constants.ICON_BEFORE_POSITION, |
|
disabled: false, |
|
required: false, |
|
readOnly: false, |
|
openDirection: _constants.OPEN_DOWN, |
|
noBorder: false, |
|
block: false, |
|
small: false, |
|
regular: false, |
|
verticalSpacing: undefined, |
|
|
|
keepOpenOnDateSelect: false, |
|
reopenPickerOnClearDates: false, |
|
withFullScreenPortal: false, |
|
minimumNights: 1, |
|
isOutsideRange: function () { |
|
function isOutsideRange(day) { |
|
return !(0, _isInclusivelyAfterDay2['default'])(day, (0, _moment2['default'])()); |
|
} |
|
|
|
return isOutsideRange; |
|
}(), |
|
displayFormat: function () { |
|
function displayFormat() { |
|
return _moment2['default'].localeData().longDateFormat('L'); |
|
} |
|
|
|
return displayFormat; |
|
}(), |
|
|
|
onFocusChange: function () { |
|
function onFocusChange() {} |
|
|
|
return onFocusChange; |
|
}(), |
|
onClose: function () { |
|
function onClose() {} |
|
|
|
return onClose; |
|
}(), |
|
onDatesChange: function () { |
|
function onDatesChange() {} |
|
|
|
return onDatesChange; |
|
}(), |
|
onKeyDownArrowDown: function () { |
|
function onKeyDownArrowDown() {} |
|
|
|
return onKeyDownArrowDown; |
|
}(), |
|
onKeyDownQuestionMark: function () { |
|
function onKeyDownQuestionMark() {} |
|
|
|
return onKeyDownQuestionMark; |
|
}(), |
|
|
|
|
|
customInputIcon: null, |
|
customArrowIcon: null, |
|
customCloseIcon: null, |
|
|
|
// accessibility |
|
isFocused: false, |
|
|
|
// i18n |
|
phrases: _defaultPhrases.DateRangePickerInputPhrases, |
|
|
|
isRTL: false |
|
}; |
|
|
|
var DateRangePickerInputController = function (_React$Component) { |
|
_inherits(DateRangePickerInputController, _React$Component); |
|
|
|
function DateRangePickerInputController(props) { |
|
_classCallCheck(this, DateRangePickerInputController); |
|
|
|
var _this = _possibleConstructorReturn(this, (DateRangePickerInputController.__proto__ || Object.getPrototypeOf(DateRangePickerInputController)).call(this, props)); |
|
|
|
_this.onClearFocus = _this.onClearFocus.bind(_this); |
|
_this.onStartDateChange = _this.onStartDateChange.bind(_this); |
|
_this.onStartDateFocus = _this.onStartDateFocus.bind(_this); |
|
_this.onEndDateChange = _this.onEndDateChange.bind(_this); |
|
_this.onEndDateFocus = _this.onEndDateFocus.bind(_this); |
|
_this.clearDates = _this.clearDates.bind(_this); |
|
return _this; |
|
} |
|
|
|
_createClass(DateRangePickerInputController, [{ |
|
key: 'onClearFocus', |
|
value: function () { |
|
function onClearFocus() { |
|
var _props = this.props, |
|
onFocusChange = _props.onFocusChange, |
|
onClose = _props.onClose, |
|
startDate = _props.startDate, |
|
endDate = _props.endDate; |
|
|
|
|
|
onFocusChange(null); |
|
onClose({ startDate: startDate, endDate: endDate }); |
|
} |
|
|
|
return onClearFocus; |
|
}() |
|
}, { |
|
key: 'onEndDateChange', |
|
value: function () { |
|
function onEndDateChange(endDateString) { |
|
var _props2 = this.props, |
|
startDate = _props2.startDate, |
|
isOutsideRange = _props2.isOutsideRange, |
|
minimumNights = _props2.minimumNights, |
|
keepOpenOnDateSelect = _props2.keepOpenOnDateSelect, |
|
onDatesChange = _props2.onDatesChange; |
|
|
|
|
|
var endDate = (0, _toMomentObject2['default'])(endDateString, this.getDisplayFormat()); |
|
|
|
var isEndDateValid = endDate && !isOutsideRange(endDate) && !(startDate && (0, _isBeforeDay2['default'])(endDate, startDate.clone().add(minimumNights, 'days'))); |
|
if (isEndDateValid) { |
|
onDatesChange({ startDate: startDate, endDate: endDate }); |
|
if (!keepOpenOnDateSelect) this.onClearFocus(); |
|
} else { |
|
onDatesChange({ |
|
startDate: startDate, |
|
endDate: null |
|
}); |
|
} |
|
} |
|
|
|
return onEndDateChange; |
|
}() |
|
}, { |
|
key: 'onEndDateFocus', |
|
value: function () { |
|
function onEndDateFocus() { |
|
var _props3 = this.props, |
|
startDate = _props3.startDate, |
|
onFocusChange = _props3.onFocusChange, |
|
withFullScreenPortal = _props3.withFullScreenPortal, |
|
disabled = _props3.disabled; |
|
|
|
|
|
if (!startDate && withFullScreenPortal && (!disabled || disabled === _constants.END_DATE)) { |
|
// When the datepicker is full screen, we never want to focus the end date first |
|
// because there's no indication that that is the case once the datepicker is open and it |
|
// might confuse the user |
|
onFocusChange(_constants.START_DATE); |
|
} else if (!disabled || disabled === _constants.START_DATE) { |
|
onFocusChange(_constants.END_DATE); |
|
} |
|
} |
|
|
|
return onEndDateFocus; |
|
}() |
|
}, { |
|
key: 'onStartDateChange', |
|
value: function () { |
|
function onStartDateChange(startDateString) { |
|
var endDate = this.props.endDate; |
|
var _props4 = this.props, |
|
isOutsideRange = _props4.isOutsideRange, |
|
minimumNights = _props4.minimumNights, |
|
onDatesChange = _props4.onDatesChange, |
|
onFocusChange = _props4.onFocusChange, |
|
disabled = _props4.disabled; |
|
|
|
|
|
var startDate = (0, _toMomentObject2['default'])(startDateString, this.getDisplayFormat()); |
|
var isEndDateBeforeStartDate = startDate && (0, _isBeforeDay2['default'])(endDate, startDate.clone().add(minimumNights, 'days')); |
|
var isStartDateValid = startDate && !isOutsideRange(startDate) && !(disabled === _constants.END_DATE && isEndDateBeforeStartDate); |
|
|
|
if (isStartDateValid) { |
|
if (isEndDateBeforeStartDate) { |
|
endDate = null; |
|
} |
|
|
|
onDatesChange({ startDate: startDate, endDate: endDate }); |
|
onFocusChange(_constants.END_DATE); |
|
} else { |
|
onDatesChange({ |
|
startDate: null, |
|
endDate: endDate |
|
}); |
|
} |
|
} |
|
|
|
return onStartDateChange; |
|
}() |
|
}, { |
|
key: 'onStartDateFocus', |
|
value: function () { |
|
function onStartDateFocus() { |
|
var _props5 = this.props, |
|
disabled = _props5.disabled, |
|
onFocusChange = _props5.onFocusChange; |
|
|
|
if (!disabled || disabled === _constants.END_DATE) { |
|
onFocusChange(_constants.START_DATE); |
|
} |
|
} |
|
|
|
return onStartDateFocus; |
|
}() |
|
}, { |
|
key: 'getDisplayFormat', |
|
value: function () { |
|
function getDisplayFormat() { |
|
var displayFormat = this.props.displayFormat; |
|
|
|
return typeof displayFormat === 'string' ? displayFormat : displayFormat(); |
|
} |
|
|
|
return getDisplayFormat; |
|
}() |
|
}, { |
|
key: 'getDateString', |
|
value: function () { |
|
function getDateString(date) { |
|
var displayFormat = this.getDisplayFormat(); |
|
if (date && displayFormat) { |
|
return date && date.format(displayFormat); |
|
} |
|
return (0, _toLocalizedDateString2['default'])(date); |
|
} |
|
|
|
return getDateString; |
|
}() |
|
}, { |
|
key: 'clearDates', |
|
value: function () { |
|
function clearDates() { |
|
var _props6 = this.props, |
|
onDatesChange = _props6.onDatesChange, |
|
reopenPickerOnClearDates = _props6.reopenPickerOnClearDates, |
|
onFocusChange = _props6.onFocusChange; |
|
|
|
onDatesChange({ startDate: null, endDate: null }); |
|
if (reopenPickerOnClearDates) { |
|
onFocusChange(_constants.START_DATE); |
|
} |
|
} |
|
|
|
return clearDates; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _props7 = this.props, |
|
startDate = _props7.startDate, |
|
startDateId = _props7.startDateId, |
|
startDatePlaceholderText = _props7.startDatePlaceholderText, |
|
isStartDateFocused = _props7.isStartDateFocused, |
|
endDate = _props7.endDate, |
|
endDateId = _props7.endDateId, |
|
endDatePlaceholderText = _props7.endDatePlaceholderText, |
|
isEndDateFocused = _props7.isEndDateFocused, |
|
screenReaderMessage = _props7.screenReaderMessage, |
|
showClearDates = _props7.showClearDates, |
|
showCaret = _props7.showCaret, |
|
showDefaultInputIcon = _props7.showDefaultInputIcon, |
|
inputIconPosition = _props7.inputIconPosition, |
|
customInputIcon = _props7.customInputIcon, |
|
customArrowIcon = _props7.customArrowIcon, |
|
customCloseIcon = _props7.customCloseIcon, |
|
disabled = _props7.disabled, |
|
required = _props7.required, |
|
readOnly = _props7.readOnly, |
|
openDirection = _props7.openDirection, |
|
isFocused = _props7.isFocused, |
|
phrases = _props7.phrases, |
|
onKeyDownArrowDown = _props7.onKeyDownArrowDown, |
|
onKeyDownQuestionMark = _props7.onKeyDownQuestionMark, |
|
isRTL = _props7.isRTL, |
|
noBorder = _props7.noBorder, |
|
block = _props7.block, |
|
small = _props7.small, |
|
regular = _props7.regular, |
|
verticalSpacing = _props7.verticalSpacing; |
|
|
|
|
|
var startDateString = this.getDateString(startDate); |
|
var endDateString = this.getDateString(endDate); |
|
|
|
return _react2['default'].createElement(_DateRangePickerInput2['default'], { |
|
startDate: startDateString, |
|
startDateId: startDateId, |
|
startDatePlaceholderText: startDatePlaceholderText, |
|
isStartDateFocused: isStartDateFocused, |
|
endDate: endDateString, |
|
endDateId: endDateId, |
|
endDatePlaceholderText: endDatePlaceholderText, |
|
isEndDateFocused: isEndDateFocused, |
|
isFocused: isFocused, |
|
disabled: disabled, |
|
required: required, |
|
readOnly: readOnly, |
|
openDirection: openDirection, |
|
showCaret: showCaret, |
|
showDefaultInputIcon: showDefaultInputIcon, |
|
inputIconPosition: inputIconPosition, |
|
customInputIcon: customInputIcon, |
|
customArrowIcon: customArrowIcon, |
|
customCloseIcon: customCloseIcon, |
|
phrases: phrases, |
|
onStartDateChange: this.onStartDateChange, |
|
onStartDateFocus: this.onStartDateFocus, |
|
onStartDateShiftTab: this.onClearFocus, |
|
onEndDateChange: this.onEndDateChange, |
|
onEndDateFocus: this.onEndDateFocus, |
|
onEndDateTab: this.onClearFocus, |
|
showClearDates: showClearDates, |
|
onClearDates: this.clearDates, |
|
screenReaderMessage: screenReaderMessage, |
|
onKeyDownArrowDown: onKeyDownArrowDown, |
|
onKeyDownQuestionMark: onKeyDownQuestionMark, |
|
isRTL: isRTL, |
|
noBorder: noBorder, |
|
block: block, |
|
small: small, |
|
regular: regular, |
|
verticalSpacing: verticalSpacing |
|
}); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return DateRangePickerInputController; |
|
}(_react2['default'].Component); |
|
|
|
exports['default'] = DateRangePickerInputController; |
|
|
|
|
|
DateRangePickerInputController.propTypes = propTypes; |
|
DateRangePickerInputController.defaultProps = defaultProps; |
|
|
|
/***/ }), |
|
/* 196 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _OpenDirectionShape = __webpack_require__(81); |
|
|
|
var _OpenDirectionShape2 = _interopRequireDefault(_OpenDirectionShape); |
|
|
|
var _DateInput = __webpack_require__(197); |
|
|
|
var _DateInput2 = _interopRequireDefault(_DateInput); |
|
|
|
var _IconPositionShape = __webpack_require__(92); |
|
|
|
var _IconPositionShape2 = _interopRequireDefault(_IconPositionShape); |
|
|
|
var _DisabledShape = __webpack_require__(107); |
|
|
|
var _DisabledShape2 = _interopRequireDefault(_DisabledShape); |
|
|
|
var _RightArrow = __webpack_require__(201); |
|
|
|
var _RightArrow2 = _interopRequireDefault(_RightArrow); |
|
|
|
var _LeftArrow = __webpack_require__(202); |
|
|
|
var _LeftArrow2 = _interopRequireDefault(_LeftArrow); |
|
|
|
var _CloseButton = __webpack_require__(96); |
|
|
|
var _CloseButton2 = _interopRequireDefault(_CloseButton); |
|
|
|
var _CalendarIcon = __webpack_require__(203); |
|
|
|
var _CalendarIcon2 = _interopRequireDefault(_CalendarIcon); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, { |
|
startDateId: _propTypes2['default'].string, |
|
startDatePlaceholderText: _propTypes2['default'].string, |
|
screenReaderMessage: _propTypes2['default'].string, |
|
|
|
endDateId: _propTypes2['default'].string, |
|
endDatePlaceholderText: _propTypes2['default'].string, |
|
|
|
onStartDateFocus: _propTypes2['default'].func, |
|
onEndDateFocus: _propTypes2['default'].func, |
|
onStartDateChange: _propTypes2['default'].func, |
|
onEndDateChange: _propTypes2['default'].func, |
|
onStartDateShiftTab: _propTypes2['default'].func, |
|
onEndDateTab: _propTypes2['default'].func, |
|
onClearDates: _propTypes2['default'].func, |
|
onKeyDownArrowDown: _propTypes2['default'].func, |
|
onKeyDownQuestionMark: _propTypes2['default'].func, |
|
|
|
startDate: _propTypes2['default'].string, |
|
endDate: _propTypes2['default'].string, |
|
|
|
isStartDateFocused: _propTypes2['default'].bool, |
|
isEndDateFocused: _propTypes2['default'].bool, |
|
showClearDates: _propTypes2['default'].bool, |
|
disabled: _DisabledShape2['default'], |
|
required: _propTypes2['default'].bool, |
|
readOnly: _propTypes2['default'].bool, |
|
openDirection: _OpenDirectionShape2['default'], |
|
showCaret: _propTypes2['default'].bool, |
|
showDefaultInputIcon: _propTypes2['default'].bool, |
|
inputIconPosition: _IconPositionShape2['default'], |
|
customInputIcon: _propTypes2['default'].node, |
|
customArrowIcon: _propTypes2['default'].node, |
|
customCloseIcon: _propTypes2['default'].node, |
|
noBorder: _propTypes2['default'].bool, |
|
block: _propTypes2['default'].bool, |
|
small: _propTypes2['default'].bool, |
|
regular: _propTypes2['default'].bool, |
|
verticalSpacing: _airbnbPropTypes.nonNegativeInteger, |
|
|
|
// accessibility |
|
isFocused: _propTypes2['default'].bool, // describes actual DOM focus |
|
|
|
// i18n |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.DateRangePickerInputPhrases)), |
|
|
|
isRTL: _propTypes2['default'].bool |
|
})); |
|
|
|
var defaultProps = { |
|
startDateId: _constants.START_DATE, |
|
endDateId: _constants.END_DATE, |
|
startDatePlaceholderText: 'Start Date', |
|
endDatePlaceholderText: 'End Date', |
|
screenReaderMessage: '', |
|
onStartDateFocus: function () { |
|
function onStartDateFocus() {} |
|
|
|
return onStartDateFocus; |
|
}(), |
|
onEndDateFocus: function () { |
|
function onEndDateFocus() {} |
|
|
|
return onEndDateFocus; |
|
}(), |
|
onStartDateChange: function () { |
|
function onStartDateChange() {} |
|
|
|
return onStartDateChange; |
|
}(), |
|
onEndDateChange: function () { |
|
function onEndDateChange() {} |
|
|
|
return onEndDateChange; |
|
}(), |
|
onStartDateShiftTab: function () { |
|
function onStartDateShiftTab() {} |
|
|
|
return onStartDateShiftTab; |
|
}(), |
|
onEndDateTab: function () { |
|
function onEndDateTab() {} |
|
|
|
return onEndDateTab; |
|
}(), |
|
onClearDates: function () { |
|
function onClearDates() {} |
|
|
|
return onClearDates; |
|
}(), |
|
onKeyDownArrowDown: function () { |
|
function onKeyDownArrowDown() {} |
|
|
|
return onKeyDownArrowDown; |
|
}(), |
|
onKeyDownQuestionMark: function () { |
|
function onKeyDownQuestionMark() {} |
|
|
|
return onKeyDownQuestionMark; |
|
}(), |
|
|
|
|
|
startDate: '', |
|
endDate: '', |
|
|
|
isStartDateFocused: false, |
|
isEndDateFocused: false, |
|
showClearDates: false, |
|
disabled: false, |
|
required: false, |
|
readOnly: false, |
|
openDirection: _constants.OPEN_DOWN, |
|
showCaret: false, |
|
showDefaultInputIcon: false, |
|
inputIconPosition: _constants.ICON_BEFORE_POSITION, |
|
customInputIcon: null, |
|
customArrowIcon: null, |
|
customCloseIcon: null, |
|
noBorder: false, |
|
block: false, |
|
small: false, |
|
regular: false, |
|
verticalSpacing: undefined, |
|
|
|
// accessibility |
|
isFocused: false, |
|
|
|
// i18n |
|
phrases: _defaultPhrases.DateRangePickerInputPhrases, |
|
|
|
isRTL: false |
|
}; |
|
|
|
function DateRangePickerInput(_ref) { |
|
var startDate = _ref.startDate, |
|
startDateId = _ref.startDateId, |
|
startDatePlaceholderText = _ref.startDatePlaceholderText, |
|
screenReaderMessage = _ref.screenReaderMessage, |
|
isStartDateFocused = _ref.isStartDateFocused, |
|
onStartDateChange = _ref.onStartDateChange, |
|
onStartDateFocus = _ref.onStartDateFocus, |
|
onStartDateShiftTab = _ref.onStartDateShiftTab, |
|
endDate = _ref.endDate, |
|
endDateId = _ref.endDateId, |
|
endDatePlaceholderText = _ref.endDatePlaceholderText, |
|
isEndDateFocused = _ref.isEndDateFocused, |
|
onEndDateChange = _ref.onEndDateChange, |
|
onEndDateFocus = _ref.onEndDateFocus, |
|
onEndDateTab = _ref.onEndDateTab, |
|
onKeyDownArrowDown = _ref.onKeyDownArrowDown, |
|
onKeyDownQuestionMark = _ref.onKeyDownQuestionMark, |
|
onClearDates = _ref.onClearDates, |
|
showClearDates = _ref.showClearDates, |
|
disabled = _ref.disabled, |
|
required = _ref.required, |
|
readOnly = _ref.readOnly, |
|
showCaret = _ref.showCaret, |
|
openDirection = _ref.openDirection, |
|
showDefaultInputIcon = _ref.showDefaultInputIcon, |
|
inputIconPosition = _ref.inputIconPosition, |
|
customInputIcon = _ref.customInputIcon, |
|
customArrowIcon = _ref.customArrowIcon, |
|
customCloseIcon = _ref.customCloseIcon, |
|
isFocused = _ref.isFocused, |
|
phrases = _ref.phrases, |
|
isRTL = _ref.isRTL, |
|
noBorder = _ref.noBorder, |
|
block = _ref.block, |
|
verticalSpacing = _ref.verticalSpacing, |
|
small = _ref.small, |
|
regular = _ref.regular, |
|
styles = _ref.styles; |
|
|
|
var calendarIcon = customInputIcon || _react2['default'].createElement(_CalendarIcon2['default'], (0, _reactWithStyles.css)(styles.DateRangePickerInput_calendarIcon_svg)); |
|
|
|
var arrowIcon = customArrowIcon || _react2['default'].createElement(_RightArrow2['default'], (0, _reactWithStyles.css)(styles.DateRangePickerInput_arrow_svg)); |
|
if (isRTL) arrowIcon = _react2['default'].createElement(_LeftArrow2['default'], (0, _reactWithStyles.css)(styles.DateRangePickerInput_arrow_svg)); |
|
if (small) arrowIcon = '-'; |
|
|
|
var closeIcon = customCloseIcon || _react2['default'].createElement(_CloseButton2['default'], (0, _reactWithStyles.css)(styles.DateRangePickerInput_clearDates_svg, small && styles.DateRangePickerInput_clearDates_svg__small)); |
|
var screenReaderText = screenReaderMessage || phrases.keyboardNavigationInstructions; |
|
var inputIcon = (showDefaultInputIcon || customInputIcon !== null) && _react2['default'].createElement( |
|
'button', |
|
_extends({}, (0, _reactWithStyles.css)(styles.DateRangePickerInput_calendarIcon), { |
|
type: 'button', |
|
disabled: disabled, |
|
'aria-label': phrases.focusStartDate, |
|
onClick: onKeyDownArrowDown |
|
}), |
|
calendarIcon |
|
); |
|
var startDateDisabled = disabled === _constants.START_DATE || disabled === true; |
|
var endDateDisabled = disabled === _constants.END_DATE || disabled === true; |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
(0, _reactWithStyles.css)(styles.DateRangePickerInput, disabled && styles.DateRangePickerInput__disabled, isRTL && styles.DateRangePickerInput__rtl, !noBorder && styles.DateRangePickerInput__withBorder, block && styles.DateRangePickerInput__block, showClearDates && styles.DateRangePickerInput__showClearDates), |
|
inputIconPosition === _constants.ICON_BEFORE_POSITION && inputIcon, |
|
_react2['default'].createElement(_DateInput2['default'], { |
|
id: startDateId, |
|
placeholder: startDatePlaceholderText, |
|
displayValue: startDate, |
|
screenReaderMessage: screenReaderText, |
|
focused: isStartDateFocused, |
|
isFocused: isFocused, |
|
disabled: startDateDisabled, |
|
required: required, |
|
readOnly: readOnly, |
|
showCaret: showCaret, |
|
openDirection: openDirection, |
|
onChange: onStartDateChange, |
|
onFocus: onStartDateFocus, |
|
onKeyDownShiftTab: onStartDateShiftTab, |
|
onKeyDownArrowDown: onKeyDownArrowDown, |
|
onKeyDownQuestionMark: onKeyDownQuestionMark, |
|
verticalSpacing: verticalSpacing, |
|
small: small, |
|
regular: regular |
|
}), |
|
_react2['default'].createElement( |
|
'div', |
|
_extends({}, (0, _reactWithStyles.css)(styles.DateRangePickerInput_arrow), { |
|
'aria-hidden': 'true', |
|
role: 'presentation' |
|
}), |
|
arrowIcon |
|
), |
|
_react2['default'].createElement(_DateInput2['default'], { |
|
id: endDateId, |
|
placeholder: endDatePlaceholderText, |
|
displayValue: endDate, |
|
screenReaderMessage: screenReaderText, |
|
focused: isEndDateFocused, |
|
isFocused: isFocused, |
|
disabled: endDateDisabled, |
|
required: required, |
|
readOnly: readOnly, |
|
showCaret: showCaret, |
|
openDirection: openDirection, |
|
onChange: onEndDateChange, |
|
onFocus: onEndDateFocus, |
|
onKeyDownTab: onEndDateTab, |
|
onKeyDownArrowDown: onKeyDownArrowDown, |
|
onKeyDownQuestionMark: onKeyDownQuestionMark, |
|
verticalSpacing: verticalSpacing, |
|
small: small, |
|
regular: regular |
|
}), |
|
showClearDates && _react2['default'].createElement( |
|
'button', |
|
_extends({ |
|
type: 'button', |
|
'aria-label': phrases.clearDates |
|
}, (0, _reactWithStyles.css)(styles.DateRangePickerInput_clearDates, small && styles.DateRangePickerInput_clearDates__small, !customCloseIcon && styles.DateRangePickerInput_clearDates_default, !(startDate || endDate) && styles.DateRangePickerInput_clearDates__hide), { |
|
onClick: onClearDates, |
|
disabled: disabled |
|
}), |
|
closeIcon |
|
), |
|
inputIconPosition === _constants.ICON_AFTER_POSITION && inputIcon |
|
); |
|
} |
|
|
|
DateRangePickerInput.propTypes = propTypes; |
|
DateRangePickerInput.defaultProps = defaultProps; |
|
|
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref2) { |
|
var _ref2$reactDates = _ref2.reactDates, |
|
border = _ref2$reactDates.border, |
|
color = _ref2$reactDates.color, |
|
sizing = _ref2$reactDates.sizing; |
|
return { |
|
DateRangePickerInput: { |
|
backgroundColor: color.background, |
|
display: 'inline-block' |
|
}, |
|
|
|
DateRangePickerInput__disabled: { |
|
background: color.disabled |
|
}, |
|
|
|
DateRangePickerInput__withBorder: { |
|
borderColor: color.border, |
|
borderWidth: border.pickerInput.borderWidth, |
|
borderStyle: border.pickerInput.borderStyle, |
|
borderRadius: border.pickerInput.borderRadius |
|
}, |
|
|
|
DateRangePickerInput__rtl: { |
|
direction: 'rtl' |
|
}, |
|
|
|
DateRangePickerInput__block: { |
|
display: 'block' |
|
}, |
|
|
|
DateRangePickerInput__showClearDates: { |
|
paddingRight: 30 |
|
}, |
|
|
|
DateRangePickerInput_arrow: { |
|
display: 'inline-block', |
|
verticalAlign: 'middle', |
|
color: color.text |
|
}, |
|
|
|
DateRangePickerInput_arrow_svg: { |
|
verticalAlign: 'middle', |
|
fill: color.text, |
|
height: sizing.arrowWidth, |
|
width: sizing.arrowWidth |
|
}, |
|
|
|
DateRangePickerInput_clearDates: { |
|
background: 'none', |
|
border: 0, |
|
color: 'inherit', |
|
font: 'inherit', |
|
lineHeight: 'normal', |
|
overflow: 'visible', |
|
|
|
cursor: 'pointer', |
|
padding: 10, |
|
margin: '0 10px 0 5px', |
|
position: 'absolute', |
|
right: 0, |
|
top: '50%', |
|
transform: 'translateY(-50%)' |
|
}, |
|
|
|
DateRangePickerInput_clearDates__small: { |
|
padding: 6 |
|
}, |
|
|
|
DateRangePickerInput_clearDates_default: { |
|
':focus': { |
|
background: color.core.border, |
|
borderRadius: '50%' |
|
}, |
|
|
|
':hover': { |
|
background: color.core.border, |
|
borderRadius: '50%' |
|
} |
|
}, |
|
|
|
DateRangePickerInput_clearDates__hide: { |
|
visibility: 'hidden' |
|
}, |
|
|
|
DateRangePickerInput_clearDates_svg: { |
|
fill: color.core.grayLight, |
|
height: 12, |
|
width: 15, |
|
verticalAlign: 'middle' |
|
}, |
|
|
|
DateRangePickerInput_clearDates_svg__small: { |
|
height: 9 |
|
}, |
|
|
|
DateRangePickerInput_calendarIcon: { |
|
background: 'none', |
|
border: 0, |
|
color: 'inherit', |
|
font: 'inherit', |
|
lineHeight: 'normal', |
|
overflow: 'visible', |
|
|
|
cursor: 'pointer', |
|
display: 'inline-block', |
|
verticalAlign: 'middle', |
|
padding: 10, |
|
margin: '0 5px 0 10px' |
|
}, |
|
|
|
DateRangePickerInput_calendarIcon_svg: { |
|
fill: color.core.grayLight, |
|
height: 15, |
|
width: 14, |
|
verticalAlign: 'middle' |
|
} |
|
}; |
|
})(DateRangePickerInput); |
|
|
|
/***/ }), |
|
/* 197 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
var _throttle = __webpack_require__(198); |
|
|
|
var _throttle2 = _interopRequireDefault(_throttle); |
|
|
|
var _isTouchDevice = __webpack_require__(80); |
|
|
|
var _isTouchDevice2 = _interopRequireDefault(_isTouchDevice); |
|
|
|
var _getInputHeight = __webpack_require__(137); |
|
|
|
var _getInputHeight2 = _interopRequireDefault(_getInputHeight); |
|
|
|
var _OpenDirectionShape = __webpack_require__(81); |
|
|
|
var _OpenDirectionShape2 = _interopRequireDefault(_OpenDirectionShape); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
var FANG_PATH_TOP = 'M0,' + String(_constants.FANG_HEIGHT_PX) + ' ' + String(_constants.FANG_WIDTH_PX) + ',' + String(_constants.FANG_HEIGHT_PX) + ' ' + _constants.FANG_WIDTH_PX / 2 + ',0z'; |
|
var FANG_STROKE_TOP = 'M0,' + String(_constants.FANG_HEIGHT_PX) + ' ' + _constants.FANG_WIDTH_PX / 2 + ',0 ' + String(_constants.FANG_WIDTH_PX) + ',' + String(_constants.FANG_HEIGHT_PX); |
|
var FANG_PATH_BOTTOM = 'M0,0 ' + String(_constants.FANG_WIDTH_PX) + ',0 ' + _constants.FANG_WIDTH_PX / 2 + ',' + String(_constants.FANG_HEIGHT_PX) + 'z'; |
|
var FANG_STROKE_BOTTOM = 'M0,0 ' + _constants.FANG_WIDTH_PX / 2 + ',' + String(_constants.FANG_HEIGHT_PX) + ' ' + String(_constants.FANG_WIDTH_PX) + ',0'; |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, { |
|
id: _propTypes2['default'].string.isRequired, |
|
placeholder: _propTypes2['default'].string, // also used as label |
|
displayValue: _propTypes2['default'].string, |
|
screenReaderMessage: _propTypes2['default'].string, |
|
focused: _propTypes2['default'].bool, |
|
disabled: _propTypes2['default'].bool, |
|
required: _propTypes2['default'].bool, |
|
readOnly: _propTypes2['default'].bool, |
|
openDirection: _OpenDirectionShape2['default'], |
|
showCaret: _propTypes2['default'].bool, |
|
verticalSpacing: _airbnbPropTypes.nonNegativeInteger, |
|
small: _propTypes2['default'].bool, |
|
block: _propTypes2['default'].bool, |
|
regular: _propTypes2['default'].bool, |
|
|
|
onChange: _propTypes2['default'].func, |
|
onFocus: _propTypes2['default'].func, |
|
onKeyDownShiftTab: _propTypes2['default'].func, |
|
onKeyDownTab: _propTypes2['default'].func, |
|
|
|
onKeyDownArrowDown: _propTypes2['default'].func, |
|
onKeyDownQuestionMark: _propTypes2['default'].func, |
|
|
|
// accessibility |
|
isFocused: _propTypes2['default'].bool // describes actual DOM focus |
|
})); |
|
|
|
var defaultProps = { |
|
placeholder: 'Select Date', |
|
displayValue: '', |
|
screenReaderMessage: '', |
|
focused: false, |
|
disabled: false, |
|
required: false, |
|
readOnly: null, |
|
openDirection: _constants.OPEN_DOWN, |
|
showCaret: false, |
|
verticalSpacing: _constants.DEFAULT_VERTICAL_SPACING, |
|
small: false, |
|
block: false, |
|
regular: false, |
|
|
|
onChange: function () { |
|
function onChange() {} |
|
|
|
return onChange; |
|
}(), |
|
onFocus: function () { |
|
function onFocus() {} |
|
|
|
return onFocus; |
|
}(), |
|
onKeyDownShiftTab: function () { |
|
function onKeyDownShiftTab() {} |
|
|
|
return onKeyDownShiftTab; |
|
}(), |
|
onKeyDownTab: function () { |
|
function onKeyDownTab() {} |
|
|
|
return onKeyDownTab; |
|
}(), |
|
onKeyDownArrowDown: function () { |
|
function onKeyDownArrowDown() {} |
|
|
|
return onKeyDownArrowDown; |
|
}(), |
|
onKeyDownQuestionMark: function () { |
|
function onKeyDownQuestionMark() {} |
|
|
|
return onKeyDownQuestionMark; |
|
}(), |
|
|
|
|
|
// accessibility |
|
isFocused: false |
|
}; |
|
|
|
var DateInput = function (_React$Component) { |
|
_inherits(DateInput, _React$Component); |
|
|
|
function DateInput(props) { |
|
_classCallCheck(this, DateInput); |
|
|
|
var _this = _possibleConstructorReturn(this, (DateInput.__proto__ || Object.getPrototypeOf(DateInput)).call(this, props)); |
|
|
|
_this.state = { |
|
dateString: '', |
|
isTouchDevice: false |
|
}; |
|
|
|
_this.onChange = _this.onChange.bind(_this); |
|
_this.onKeyDown = _this.onKeyDown.bind(_this); |
|
_this.setInputRef = _this.setInputRef.bind(_this); |
|
_this.throttledKeyDown = (0, _throttle2['default'])(_this.onFinalKeyDown, 300, { trailing: false }); |
|
return _this; |
|
} |
|
|
|
_createClass(DateInput, [{ |
|
key: 'componentDidMount', |
|
value: function () { |
|
function componentDidMount() { |
|
this.setState({ isTouchDevice: (0, _isTouchDevice2['default'])() }); |
|
} |
|
|
|
return componentDidMount; |
|
}() |
|
}, { |
|
key: 'componentWillReceiveProps', |
|
value: function () { |
|
function componentWillReceiveProps(nextProps) { |
|
var dateString = this.state.dateString; |
|
|
|
if (dateString && nextProps.displayValue) { |
|
this.setState({ |
|
dateString: '' |
|
}); |
|
} |
|
} |
|
|
|
return componentWillReceiveProps; |
|
}() |
|
}, { |
|
key: 'componentDidUpdate', |
|
value: function () { |
|
function componentDidUpdate(prevProps) { |
|
var _props = this.props, |
|
focused = _props.focused, |
|
isFocused = _props.isFocused; |
|
|
|
if (prevProps.focused === focused && prevProps.isFocused === isFocused) return; |
|
|
|
if (focused && isFocused) { |
|
this.inputRef.focus(); |
|
} |
|
} |
|
|
|
return componentDidUpdate; |
|
}() |
|
}, { |
|
key: 'onChange', |
|
value: function () { |
|
function onChange(e) { |
|
var _props2 = this.props, |
|
onChange = _props2.onChange, |
|
onKeyDownQuestionMark = _props2.onKeyDownQuestionMark; |
|
|
|
var dateString = e.target.value; |
|
|
|
// In Safari, onKeyDown does not consistently fire ahead of onChange. As a result, we need to |
|
// special case the `?` key so that it always triggers the appropriate callback, instead of |
|
// modifying the input value |
|
if (dateString[dateString.length - 1] === '?') { |
|
onKeyDownQuestionMark(e); |
|
} else { |
|
this.setState({ dateString: dateString }, function () { |
|
return onChange(dateString); |
|
}); |
|
} |
|
} |
|
|
|
return onChange; |
|
}() |
|
}, { |
|
key: 'onKeyDown', |
|
value: function () { |
|
function onKeyDown(e) { |
|
e.stopPropagation(); |
|
if (!_constants.MODIFIER_KEY_NAMES.has(e.key)) { |
|
this.throttledKeyDown(e); |
|
} |
|
} |
|
|
|
return onKeyDown; |
|
}() |
|
}, { |
|
key: 'onFinalKeyDown', |
|
value: function () { |
|
function onFinalKeyDown(e) { |
|
var _props3 = this.props, |
|
onKeyDownShiftTab = _props3.onKeyDownShiftTab, |
|
onKeyDownTab = _props3.onKeyDownTab, |
|
onKeyDownArrowDown = _props3.onKeyDownArrowDown, |
|
onKeyDownQuestionMark = _props3.onKeyDownQuestionMark; |
|
var key = e.key; |
|
|
|
|
|
if (key === 'Tab') { |
|
if (e.shiftKey) { |
|
onKeyDownShiftTab(e); |
|
} else { |
|
onKeyDownTab(e); |
|
} |
|
} else if (key === 'ArrowDown') { |
|
onKeyDownArrowDown(e); |
|
} else if (key === '?') { |
|
e.preventDefault(); |
|
onKeyDownQuestionMark(e); |
|
} |
|
} |
|
|
|
return onFinalKeyDown; |
|
}() |
|
}, { |
|
key: 'setInputRef', |
|
value: function () { |
|
function setInputRef(ref) { |
|
this.inputRef = ref; |
|
} |
|
|
|
return setInputRef; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _state = this.state, |
|
dateString = _state.dateString, |
|
isTouch = _state.isTouchDevice; |
|
var _props4 = this.props, |
|
id = _props4.id, |
|
placeholder = _props4.placeholder, |
|
displayValue = _props4.displayValue, |
|
screenReaderMessage = _props4.screenReaderMessage, |
|
focused = _props4.focused, |
|
showCaret = _props4.showCaret, |
|
onFocus = _props4.onFocus, |
|
disabled = _props4.disabled, |
|
required = _props4.required, |
|
readOnly = _props4.readOnly, |
|
openDirection = _props4.openDirection, |
|
verticalSpacing = _props4.verticalSpacing, |
|
small = _props4.small, |
|
regular = _props4.regular, |
|
block = _props4.block, |
|
styles = _props4.styles, |
|
reactDates = _props4.theme.reactDates; |
|
|
|
|
|
var value = dateString || displayValue || ''; |
|
var screenReaderMessageId = 'DateInput__screen-reader-message-' + String(id); |
|
|
|
var withFang = showCaret && focused; |
|
|
|
var inputHeight = (0, _getInputHeight2['default'])(reactDates, small); |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
(0, _reactWithStyles.css)(styles.DateInput, small && styles.DateInput__small, block && styles.DateInput__block, withFang && styles.DateInput__withFang, disabled && styles.DateInput__disabled, withFang && openDirection === _constants.OPEN_DOWN && styles.DateInput__openDown, withFang && openDirection === _constants.OPEN_UP && styles.DateInput__openUp), |
|
_react2['default'].createElement('input', _extends({}, (0, _reactWithStyles.css)(styles.DateInput_input, small && styles.DateInput_input__small, regular && styles.DateInput_input__regular, readOnly && styles.DateInput_input__readOnly, focused && styles.DateInput_input__focused, disabled && styles.DateInput_input__disabled), { |
|
'aria-label': placeholder, |
|
type: 'text', |
|
id: id, |
|
name: id, |
|
ref: this.setInputRef, |
|
value: value, |
|
onChange: this.onChange, |
|
onKeyDown: this.onKeyDown, |
|
onFocus: onFocus, |
|
placeholder: placeholder, |
|
autoComplete: 'off', |
|
disabled: disabled, |
|
readOnly: typeof readOnly === 'boolean' ? readOnly : isTouch, |
|
required: required, |
|
'aria-describedby': screenReaderMessage && screenReaderMessageId |
|
})), |
|
withFang && _react2['default'].createElement( |
|
'svg', |
|
_extends({ |
|
role: 'presentation', |
|
focusable: 'false' |
|
}, (0, _reactWithStyles.css)(styles.DateInput_fang, openDirection === _constants.OPEN_DOWN && { |
|
top: inputHeight + verticalSpacing - _constants.FANG_HEIGHT_PX - 1 |
|
}, openDirection === _constants.OPEN_UP && { |
|
bottom: inputHeight + verticalSpacing - _constants.FANG_HEIGHT_PX - 1 |
|
})), |
|
_react2['default'].createElement('path', _extends({}, (0, _reactWithStyles.css)(styles.DateInput_fangShape), { |
|
d: openDirection === _constants.OPEN_DOWN ? FANG_PATH_TOP : FANG_PATH_BOTTOM |
|
})), |
|
_react2['default'].createElement('path', _extends({}, (0, _reactWithStyles.css)(styles.DateInput_fangStroke), { |
|
d: openDirection === _constants.OPEN_DOWN ? FANG_STROKE_TOP : FANG_STROKE_BOTTOM |
|
})) |
|
), |
|
screenReaderMessage && _react2['default'].createElement( |
|
'p', |
|
_extends({}, (0, _reactWithStyles.css)(styles.DateInput_screenReaderMessage), { id: screenReaderMessageId }), |
|
screenReaderMessage |
|
) |
|
); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return DateInput; |
|
}(_react2['default'].Component); |
|
|
|
DateInput.propTypes = propTypes; |
|
DateInput.defaultProps = defaultProps; |
|
|
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref) { |
|
var _ref$reactDates = _ref.reactDates, |
|
border = _ref$reactDates.border, |
|
color = _ref$reactDates.color, |
|
sizing = _ref$reactDates.sizing, |
|
spacing = _ref$reactDates.spacing, |
|
font = _ref$reactDates.font, |
|
zIndex = _ref$reactDates.zIndex; |
|
return { |
|
DateInput: { |
|
margin: 0, |
|
padding: spacing.inputPadding, |
|
background: color.background, |
|
position: 'relative', |
|
display: 'inline-block', |
|
width: sizing.inputWidth, |
|
verticalAlign: 'middle' |
|
}, |
|
|
|
DateInput__small: { |
|
width: sizing.inputWidth_small |
|
}, |
|
|
|
DateInput__block: { |
|
width: '100%' |
|
}, |
|
|
|
DateInput__disabled: { |
|
background: color.disabled, |
|
color: color.textDisabled |
|
}, |
|
|
|
DateInput_input: { |
|
fontWeight: 200, |
|
fontSize: font.input.size, |
|
lineHeight: font.input.lineHeight, |
|
color: color.text, |
|
backgroundColor: color.background, |
|
width: '100%', |
|
padding: String(spacing.displayTextPaddingVertical) + 'px ' + String(spacing.displayTextPaddingHorizontal) + 'px', |
|
paddingTop: spacing.displayTextPaddingTop, |
|
paddingBottom: spacing.displayTextPaddingBottom, |
|
paddingLeft: spacing.displayTextPaddingLeft, |
|
paddingRight: spacing.displayTextPaddingRight, |
|
border: border.input.border, |
|
borderTop: border.input.borderTop, |
|
borderRight: border.input.borderRight, |
|
borderBottom: border.input.borderBottom, |
|
borderLeft: border.input.borderLeft, |
|
borderRadius: border.input.borderRadius |
|
}, |
|
|
|
DateInput_input__small: { |
|
fontSize: font.input.size_small, |
|
lineHeight: font.input.lineHeight_small, |
|
letterSpacing: font.input.letterSpacing_small, |
|
padding: String(spacing.displayTextPaddingVertical_small) + 'px ' + String(spacing.displayTextPaddingHorizontal_small) + 'px', |
|
paddingTop: spacing.displayTextPaddingTop_small, |
|
paddingBottom: spacing.displayTextPaddingBottom_small, |
|
paddingLeft: spacing.displayTextPaddingLeft_small, |
|
paddingRight: spacing.displayTextPaddingRight_small |
|
}, |
|
|
|
DateInput_input__regular: { |
|
fontWeight: 'auto' |
|
}, |
|
|
|
DateInput_input__readOnly: { |
|
userSelect: 'none' |
|
}, |
|
|
|
DateInput_input__focused: { |
|
outline: border.input.outlineFocused, |
|
background: color.backgroundFocused, |
|
border: border.input.borderFocused, |
|
borderTop: border.input.borderTopFocused, |
|
borderRight: border.input.borderRightFocused, |
|
borderBottom: border.input.borderBottomFocused, |
|
borderLeft: border.input.borderLeftFocused |
|
}, |
|
|
|
DateInput_input__disabled: { |
|
background: color.disabled, |
|
fontStyle: font.input.styleDisabled |
|
}, |
|
|
|
DateInput_screenReaderMessage: { |
|
border: 0, |
|
clip: 'rect(0, 0, 0, 0)', |
|
height: 1, |
|
margin: -1, |
|
overflow: 'hidden', |
|
padding: 0, |
|
position: 'absolute', |
|
width: 1 |
|
}, |
|
|
|
DateInput_fang: { |
|
position: 'absolute', |
|
width: _constants.FANG_WIDTH_PX, |
|
height: _constants.FANG_HEIGHT_PX, |
|
left: 22, |
|
zIndex: zIndex + 2 |
|
}, |
|
|
|
DateInput_fangShape: { |
|
fill: color.background |
|
}, |
|
|
|
DateInput_fangStroke: { |
|
stroke: color.core.border, |
|
fill: 'transparent' |
|
} |
|
}; |
|
})(DateInput); |
|
|
|
/***/ }), |
|
/* 198 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var debounce = __webpack_require__(295), |
|
isObject = __webpack_require__(138); |
|
|
|
/** Error message constants. */ |
|
var FUNC_ERROR_TEXT = 'Expected a function'; |
|
|
|
/** |
|
* Creates a throttled function that only invokes `func` at most once per |
|
* every `wait` milliseconds. The throttled function comes with a `cancel` |
|
* method to cancel delayed `func` invocations and a `flush` method to |
|
* immediately invoke them. Provide `options` to indicate whether `func` |
|
* should be invoked on the leading and/or trailing edge of the `wait` |
|
* timeout. The `func` is invoked with the last arguments provided to the |
|
* throttled function. Subsequent calls to the throttled function return the |
|
* result of the last `func` invocation. |
|
* |
|
* **Note:** If `leading` and `trailing` options are `true`, `func` is |
|
* invoked on the trailing edge of the timeout only if the throttled function |
|
* is invoked more than once during the `wait` timeout. |
|
* |
|
* If `wait` is `0` and `leading` is `false`, `func` invocation is deferred |
|
* until to the next tick, similar to `setTimeout` with a timeout of `0`. |
|
* |
|
* See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) |
|
* for details over the differences between `_.throttle` and `_.debounce`. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @since 0.1.0 |
|
* @category Function |
|
* @param {Function} func The function to throttle. |
|
* @param {number} [wait=0] The number of milliseconds to throttle invocations to. |
|
* @param {Object} [options={}] The options object. |
|
* @param {boolean} [options.leading=true] |
|
* Specify invoking on the leading edge of the timeout. |
|
* @param {boolean} [options.trailing=true] |
|
* Specify invoking on the trailing edge of the timeout. |
|
* @returns {Function} Returns the new throttled function. |
|
* @example |
|
* |
|
* // Avoid excessively updating the position while scrolling. |
|
* jQuery(window).on('scroll', _.throttle(updatePosition, 100)); |
|
* |
|
* // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes. |
|
* var throttled = _.throttle(renewToken, 300000, { 'trailing': false }); |
|
* jQuery(element).on('click', throttled); |
|
* |
|
* // Cancel the trailing throttled invocation. |
|
* jQuery(window).on('popstate', throttled.cancel); |
|
*/ |
|
function throttle(func, wait, options) { |
|
var leading = true, |
|
trailing = true; |
|
|
|
if (typeof func != 'function') { |
|
throw new TypeError(FUNC_ERROR_TEXT); |
|
} |
|
if (isObject(options)) { |
|
leading = 'leading' in options ? !!options.leading : leading; |
|
trailing = 'trailing' in options ? !!options.trailing : trailing; |
|
} |
|
return debounce(func, wait, { |
|
'leading': leading, |
|
'maxWait': wait, |
|
'trailing': trailing |
|
}); |
|
} |
|
|
|
module.exports = throttle; |
|
|
|
|
|
/***/ }), |
|
/* 199 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var freeGlobal = __webpack_require__(297); |
|
|
|
/** Detect free variable `self`. */ |
|
var freeSelf = typeof self == 'object' && self && self.Object === Object && self; |
|
|
|
/** Used as a reference to the global object. */ |
|
var root = freeGlobal || freeSelf || Function('return this')(); |
|
|
|
module.exports = root; |
|
|
|
|
|
/***/ }), |
|
/* 200 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var root = __webpack_require__(199); |
|
|
|
/** Built-in value references. */ |
|
var Symbol = root.Symbol; |
|
|
|
module.exports = Symbol; |
|
|
|
|
|
/***/ }), |
|
/* 201 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
var RightArrow = function () { |
|
function RightArrow(props) { |
|
return _react2['default'].createElement( |
|
'svg', |
|
props, |
|
_react2['default'].createElement('path', { |
|
d: 'M694.4 242.4l249.1 249.1c11 11 11 21 0 32L694.4 772.7c-5 5-10 7-16 7s-11-2-16-7c-11-11-11-21 0-32l210.1-210.1H67.1c-13 0-23-10-23-23s10-23 23-23h805.4L662.4 274.5c-21-21.1 11-53.1 32-32.1z' |
|
}) |
|
); |
|
} |
|
|
|
return RightArrow; |
|
}(); |
|
|
|
RightArrow.defaultProps = { |
|
viewBox: '0 0 1000 1000' |
|
}; |
|
exports['default'] = RightArrow; |
|
|
|
/***/ }), |
|
/* 202 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
var LeftArrow = function () { |
|
function LeftArrow(props) { |
|
return _react2['default'].createElement( |
|
'svg', |
|
props, |
|
_react2['default'].createElement('path', { |
|
d: 'M336.2 274.5l-210.1 210h805.4c13 0 23 10 23 23s-10 23-23 23H126.1l210.1 210.1c11 11 11 21 0 32-5 5-10 7-16 7s-11-2-16-7l-249.1-249c-11-11-11-21 0-32l249.1-249.1c21-21.1 53 10.9 32 32z' |
|
}) |
|
); |
|
} |
|
|
|
return LeftArrow; |
|
}(); |
|
|
|
LeftArrow.defaultProps = { |
|
viewBox: '0 0 1000 1000' |
|
}; |
|
exports['default'] = LeftArrow; |
|
|
|
/***/ }), |
|
/* 203 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
var CalendarIcon = function () { |
|
function CalendarIcon(props) { |
|
return _react2['default'].createElement( |
|
'svg', |
|
props, |
|
_react2['default'].createElement('path', { |
|
d: 'M107.2 1392.9h241.1v-241.1H107.2v241.1zm294.7 0h267.9v-241.1H401.9v241.1zm-294.7-294.7h241.1V830.4H107.2v267.8zm294.7 0h267.9V830.4H401.9v267.8zM107.2 776.8h241.1V535.7H107.2v241.1zm616.2 616.1h267.9v-241.1H723.4v241.1zM401.9 776.8h267.9V535.7H401.9v241.1zm642.9 616.1H1286v-241.1h-241.1v241.1zm-321.4-294.7h267.9V830.4H723.4v267.8zM428.7 375V133.9c0-7.3-2.7-13.5-8-18.8-5.3-5.3-11.6-8-18.8-8h-53.6c-7.3 0-13.5 2.7-18.8 8-5.3 5.3-8 11.6-8 18.8V375c0 7.3 2.7 13.5 8 18.8 5.3 5.3 11.6 8 18.8 8h53.6c7.3 0 13.5-2.7 18.8-8 5.3-5.3 8-11.5 8-18.8zm616.1 723.2H1286V830.4h-241.1v267.8zM723.4 776.8h267.9V535.7H723.4v241.1zm321.4 0H1286V535.7h-241.1v241.1zm26.8-401.8V133.9c0-7.3-2.7-13.5-8-18.8-5.3-5.3-11.6-8-18.8-8h-53.6c-7.3 0-13.5 2.7-18.8 8-5.3 5.3-8 11.6-8 18.8V375c0 7.3 2.7 13.5 8 18.8 5.3 5.3 11.6 8 18.8 8h53.6c7.3 0 13.5-2.7 18.8-8 5.4-5.3 8-11.5 8-18.8zm321.5-53.6v1071.4c0 29-10.6 54.1-31.8 75.3-21.2 21.2-46.3 31.8-75.3 31.8H107.2c-29 0-54.1-10.6-75.3-31.8C10.6 1447 0 1421.9 0 1392.9V321.4c0-29 10.6-54.1 31.8-75.3s46.3-31.8 75.3-31.8h107.2v-80.4c0-36.8 13.1-68.4 39.3-94.6S311.4 0 348.3 0h53.6c36.8 0 68.4 13.1 94.6 39.3 26.2 26.2 39.3 57.8 39.3 94.6v80.4h321.5v-80.4c0-36.8 13.1-68.4 39.3-94.6C922.9 13.1 954.4 0 991.3 0h53.6c36.8 0 68.4 13.1 94.6 39.3s39.3 57.8 39.3 94.6v80.4H1286c29 0 54.1 10.6 75.3 31.8 21.2 21.2 31.8 46.3 31.8 75.3z' |
|
}) |
|
); |
|
} |
|
|
|
return CalendarIcon; |
|
}(); |
|
|
|
CalendarIcon.defaultProps = { |
|
viewBox: '0 0 1393.1 1500' |
|
}; |
|
exports['default'] = CalendarIcon; |
|
|
|
/***/ }), |
|
/* 204 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _reactMomentProptypes = __webpack_require__(66); |
|
|
|
var _reactMomentProptypes2 = _interopRequireDefault(_reactMomentProptypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _object3 = __webpack_require__(135); |
|
|
|
var _object4 = _interopRequireDefault(_object3); |
|
|
|
var _isTouchDevice = __webpack_require__(80); |
|
|
|
var _isTouchDevice2 = _interopRequireDefault(_isTouchDevice); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _isInclusivelyAfterDay = __webpack_require__(94); |
|
|
|
var _isInclusivelyAfterDay2 = _interopRequireDefault(_isInclusivelyAfterDay); |
|
|
|
var _isNextDay = __webpack_require__(205); |
|
|
|
var _isNextDay2 = _interopRequireDefault(_isNextDay); |
|
|
|
var _isSameDay = __webpack_require__(77); |
|
|
|
var _isSameDay2 = _interopRequireDefault(_isSameDay); |
|
|
|
var _isAfterDay = __webpack_require__(108); |
|
|
|
var _isAfterDay2 = _interopRequireDefault(_isAfterDay); |
|
|
|
var _isBeforeDay = __webpack_require__(95); |
|
|
|
var _isBeforeDay2 = _interopRequireDefault(_isBeforeDay); |
|
|
|
var _getVisibleDays = __webpack_require__(206); |
|
|
|
var _getVisibleDays2 = _interopRequireDefault(_getVisibleDays); |
|
|
|
var _isDayVisible = __webpack_require__(140); |
|
|
|
var _isDayVisible2 = _interopRequireDefault(_isDayVisible); |
|
|
|
var _getSelectedDateOffset = __webpack_require__(304); |
|
|
|
var _getSelectedDateOffset2 = _interopRequireDefault(_getSelectedDateOffset); |
|
|
|
var _toISODateString = __webpack_require__(104); |
|
|
|
var _toISODateString2 = _interopRequireDefault(_toISODateString); |
|
|
|
var _toISOMonthString = __webpack_require__(106); |
|
|
|
var _toISOMonthString2 = _interopRequireDefault(_toISOMonthString); |
|
|
|
var _DisabledShape = __webpack_require__(107); |
|
|
|
var _DisabledShape2 = _interopRequireDefault(_DisabledShape); |
|
|
|
var _FocusedInputShape = __webpack_require__(189); |
|
|
|
var _FocusedInputShape2 = _interopRequireDefault(_FocusedInputShape); |
|
|
|
var _ScrollableOrientationShape = __webpack_require__(79); |
|
|
|
var _ScrollableOrientationShape2 = _interopRequireDefault(_ScrollableOrientationShape); |
|
|
|
var _DayOfWeekShape = __webpack_require__(73); |
|
|
|
var _DayOfWeekShape2 = _interopRequireDefault(_DayOfWeekShape); |
|
|
|
var _CalendarInfoPositionShape = __webpack_require__(93); |
|
|
|
var _CalendarInfoPositionShape2 = _interopRequireDefault(_CalendarInfoPositionShape); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
var _DayPicker = __webpack_require__(141); |
|
|
|
var _DayPicker2 = _interopRequireDefault(_DayPicker); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)({ |
|
startDate: _reactMomentProptypes2['default'].momentObj, |
|
endDate: _reactMomentProptypes2['default'].momentObj, |
|
onDatesChange: _propTypes2['default'].func, |
|
startDateOffset: _propTypes2['default'].func, |
|
endDateOffset: _propTypes2['default'].func, |
|
|
|
focusedInput: _FocusedInputShape2['default'], |
|
onFocusChange: _propTypes2['default'].func, |
|
onClose: _propTypes2['default'].func, |
|
|
|
keepOpenOnDateSelect: _propTypes2['default'].bool, |
|
minimumNights: _propTypes2['default'].number, |
|
disabled: _DisabledShape2['default'], |
|
isOutsideRange: _propTypes2['default'].func, |
|
isDayBlocked: _propTypes2['default'].func, |
|
isDayHighlighted: _propTypes2['default'].func, |
|
|
|
// DayPicker props |
|
renderMonthText: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
renderMonthElement: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
enableOutsideDays: _propTypes2['default'].bool, |
|
numberOfMonths: _propTypes2['default'].number, |
|
orientation: _ScrollableOrientationShape2['default'], |
|
withPortal: _propTypes2['default'].bool, |
|
initialVisibleMonth: _propTypes2['default'].func, |
|
hideKeyboardShortcutsPanel: _propTypes2['default'].bool, |
|
daySize: _airbnbPropTypes.nonNegativeInteger, |
|
noBorder: _propTypes2['default'].bool, |
|
verticalBorderSpacing: _airbnbPropTypes.nonNegativeInteger, |
|
horizontalMonthPadding: _airbnbPropTypes.nonNegativeInteger, |
|
|
|
navPrev: _propTypes2['default'].node, |
|
navNext: _propTypes2['default'].node, |
|
noNavButtons: _propTypes2['default'].bool, |
|
|
|
onPrevMonthClick: _propTypes2['default'].func, |
|
onNextMonthClick: _propTypes2['default'].func, |
|
onOutsideClick: _propTypes2['default'].func, |
|
renderCalendarDay: _propTypes2['default'].func, |
|
renderDayContents: _propTypes2['default'].func, |
|
renderCalendarInfo: _propTypes2['default'].func, |
|
calendarInfoPosition: _CalendarInfoPositionShape2['default'], |
|
firstDayOfWeek: _DayOfWeekShape2['default'], |
|
verticalHeight: _airbnbPropTypes.nonNegativeInteger, |
|
transitionDuration: _airbnbPropTypes.nonNegativeInteger, |
|
|
|
// accessibility |
|
onBlur: _propTypes2['default'].func, |
|
isFocused: _propTypes2['default'].bool, |
|
showKeyboardShortcuts: _propTypes2['default'].bool, |
|
|
|
// i18n |
|
monthFormat: _propTypes2['default'].string, |
|
weekDayFormat: _propTypes2['default'].string, |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.DayPickerPhrases)), |
|
dayAriaLabelFormat: _propTypes2['default'].string, |
|
|
|
isRTL: _propTypes2['default'].bool |
|
}); |
|
|
|
var defaultProps = { |
|
startDate: undefined, // TODO: use null |
|
endDate: undefined, // TODO: use null |
|
onDatesChange: function () { |
|
function onDatesChange() {} |
|
|
|
return onDatesChange; |
|
}(), |
|
|
|
startDateOffset: undefined, |
|
endDateOffset: undefined, |
|
|
|
focusedInput: null, |
|
onFocusChange: function () { |
|
function onFocusChange() {} |
|
|
|
return onFocusChange; |
|
}(), |
|
onClose: function () { |
|
function onClose() {} |
|
|
|
return onClose; |
|
}(), |
|
|
|
|
|
keepOpenOnDateSelect: false, |
|
minimumNights: 1, |
|
disabled: false, |
|
isOutsideRange: function () { |
|
function isOutsideRange() {} |
|
|
|
return isOutsideRange; |
|
}(), |
|
isDayBlocked: function () { |
|
function isDayBlocked() {} |
|
|
|
return isDayBlocked; |
|
}(), |
|
isDayHighlighted: function () { |
|
function isDayHighlighted() {} |
|
|
|
return isDayHighlighted; |
|
}(), |
|
|
|
|
|
// DayPicker props |
|
renderMonthText: null, |
|
enableOutsideDays: false, |
|
numberOfMonths: 1, |
|
orientation: _constants.HORIZONTAL_ORIENTATION, |
|
withPortal: false, |
|
hideKeyboardShortcutsPanel: false, |
|
initialVisibleMonth: null, |
|
daySize: _constants.DAY_SIZE, |
|
|
|
navPrev: null, |
|
navNext: null, |
|
noNavButtons: false, |
|
|
|
onPrevMonthClick: function () { |
|
function onPrevMonthClick() {} |
|
|
|
return onPrevMonthClick; |
|
}(), |
|
onNextMonthClick: function () { |
|
function onNextMonthClick() {} |
|
|
|
return onNextMonthClick; |
|
}(), |
|
onOutsideClick: function () { |
|
function onOutsideClick() {} |
|
|
|
return onOutsideClick; |
|
}(), |
|
|
|
|
|
renderCalendarDay: undefined, |
|
renderDayContents: null, |
|
renderCalendarInfo: null, |
|
renderMonthElement: null, |
|
calendarInfoPosition: _constants.INFO_POSITION_BOTTOM, |
|
firstDayOfWeek: null, |
|
verticalHeight: null, |
|
noBorder: false, |
|
transitionDuration: undefined, |
|
verticalBorderSpacing: undefined, |
|
horizontalMonthPadding: 13, |
|
|
|
// accessibility |
|
onBlur: function () { |
|
function onBlur() {} |
|
|
|
return onBlur; |
|
}(), |
|
|
|
isFocused: false, |
|
showKeyboardShortcuts: false, |
|
|
|
// i18n |
|
monthFormat: 'MMMM YYYY', |
|
weekDayFormat: 'dd', |
|
phrases: _defaultPhrases.DayPickerPhrases, |
|
dayAriaLabelFormat: undefined, |
|
|
|
isRTL: false |
|
}; |
|
|
|
var getChooseAvailableDatePhrase = function getChooseAvailableDatePhrase(phrases, focusedInput) { |
|
if (focusedInput === _constants.START_DATE) { |
|
return phrases.chooseAvailableStartDate; |
|
} |
|
if (focusedInput === _constants.END_DATE) { |
|
return phrases.chooseAvailableEndDate; |
|
} |
|
return phrases.chooseAvailableDate; |
|
}; |
|
|
|
var DayPickerRangeController = function (_React$Component) { |
|
_inherits(DayPickerRangeController, _React$Component); |
|
|
|
function DayPickerRangeController(props) { |
|
_classCallCheck(this, DayPickerRangeController); |
|
|
|
var _this = _possibleConstructorReturn(this, (DayPickerRangeController.__proto__ || Object.getPrototypeOf(DayPickerRangeController)).call(this, props)); |
|
|
|
_this.isTouchDevice = (0, _isTouchDevice2['default'])(); |
|
_this.today = (0, _moment2['default'])(); |
|
_this.modifiers = { |
|
today: function () { |
|
function today(day) { |
|
return _this.isToday(day); |
|
} |
|
|
|
return today; |
|
}(), |
|
blocked: function () { |
|
function blocked(day) { |
|
return _this.isBlocked(day); |
|
} |
|
|
|
return blocked; |
|
}(), |
|
'blocked-calendar': function () { |
|
function blockedCalendar(day) { |
|
return props.isDayBlocked(day); |
|
} |
|
|
|
return blockedCalendar; |
|
}(), |
|
'blocked-out-of-range': function () { |
|
function blockedOutOfRange(day) { |
|
return props.isOutsideRange(day); |
|
} |
|
|
|
return blockedOutOfRange; |
|
}(), |
|
'highlighted-calendar': function () { |
|
function highlightedCalendar(day) { |
|
return props.isDayHighlighted(day); |
|
} |
|
|
|
return highlightedCalendar; |
|
}(), |
|
valid: function () { |
|
function valid(day) { |
|
return !_this.isBlocked(day); |
|
} |
|
|
|
return valid; |
|
}(), |
|
'selected-start': function () { |
|
function selectedStart(day) { |
|
return _this.isStartDate(day); |
|
} |
|
|
|
return selectedStart; |
|
}(), |
|
'selected-end': function () { |
|
function selectedEnd(day) { |
|
return _this.isEndDate(day); |
|
} |
|
|
|
return selectedEnd; |
|
}(), |
|
'blocked-minimum-nights': function () { |
|
function blockedMinimumNights(day) { |
|
return _this.doesNotMeetMinimumNights(day); |
|
} |
|
|
|
return blockedMinimumNights; |
|
}(), |
|
'selected-span': function () { |
|
function selectedSpan(day) { |
|
return _this.isInSelectedSpan(day); |
|
} |
|
|
|
return selectedSpan; |
|
}(), |
|
'last-in-range': function () { |
|
function lastInRange(day) { |
|
return _this.isLastInRange(day); |
|
} |
|
|
|
return lastInRange; |
|
}(), |
|
hovered: function () { |
|
function hovered(day) { |
|
return _this.isHovered(day); |
|
} |
|
|
|
return hovered; |
|
}(), |
|
'hovered-span': function () { |
|
function hoveredSpan(day) { |
|
return _this.isInHoveredSpan(day); |
|
} |
|
|
|
return hoveredSpan; |
|
}(), |
|
'hovered-offset': function () { |
|
function hoveredOffset(day) { |
|
return _this.isInHoveredSpan(day); |
|
} |
|
|
|
return hoveredOffset; |
|
}(), |
|
'after-hovered-start': function () { |
|
function afterHoveredStart(day) { |
|
return _this.isDayAfterHoveredStartDate(day); |
|
} |
|
|
|
return afterHoveredStart; |
|
}(), |
|
'first-day-of-week': function () { |
|
function firstDayOfWeek(day) { |
|
return _this.isFirstDayOfWeek(day); |
|
} |
|
|
|
return firstDayOfWeek; |
|
}(), |
|
'last-day-of-week': function () { |
|
function lastDayOfWeek(day) { |
|
return _this.isLastDayOfWeek(day); |
|
} |
|
|
|
return lastDayOfWeek; |
|
}() |
|
}; |
|
|
|
var _this$getStateForNewM = _this.getStateForNewMonth(props), |
|
currentMonth = _this$getStateForNewM.currentMonth, |
|
visibleDays = _this$getStateForNewM.visibleDays; |
|
|
|
// initialize phrases |
|
// set the appropriate CalendarDay phrase based on focusedInput |
|
|
|
|
|
var chooseAvailableDate = getChooseAvailableDatePhrase(props.phrases, props.focusedInput); |
|
|
|
_this.state = { |
|
hoverDate: null, |
|
currentMonth: currentMonth, |
|
phrases: (0, _object2['default'])({}, props.phrases, { |
|
chooseAvailableDate: chooseAvailableDate |
|
}), |
|
visibleDays: visibleDays |
|
}; |
|
|
|
_this.onDayClick = _this.onDayClick.bind(_this); |
|
_this.onDayMouseEnter = _this.onDayMouseEnter.bind(_this); |
|
_this.onDayMouseLeave = _this.onDayMouseLeave.bind(_this); |
|
_this.onPrevMonthClick = _this.onPrevMonthClick.bind(_this); |
|
_this.onNextMonthClick = _this.onNextMonthClick.bind(_this); |
|
_this.onMonthChange = _this.onMonthChange.bind(_this); |
|
_this.onYearChange = _this.onYearChange.bind(_this); |
|
_this.onMultiplyScrollableMonths = _this.onMultiplyScrollableMonths.bind(_this); |
|
_this.getFirstFocusableDay = _this.getFirstFocusableDay.bind(_this); |
|
return _this; |
|
} |
|
|
|
_createClass(DayPickerRangeController, [{ |
|
key: 'componentWillReceiveProps', |
|
value: function () { |
|
function componentWillReceiveProps(nextProps) { |
|
var _this2 = this; |
|
|
|
var startDate = nextProps.startDate, |
|
endDate = nextProps.endDate, |
|
focusedInput = nextProps.focusedInput, |
|
minimumNights = nextProps.minimumNights, |
|
isOutsideRange = nextProps.isOutsideRange, |
|
isDayBlocked = nextProps.isDayBlocked, |
|
isDayHighlighted = nextProps.isDayHighlighted, |
|
phrases = nextProps.phrases, |
|
initialVisibleMonth = nextProps.initialVisibleMonth, |
|
numberOfMonths = nextProps.numberOfMonths, |
|
enableOutsideDays = nextProps.enableOutsideDays; |
|
var _props = this.props, |
|
prevStartDate = _props.startDate, |
|
prevEndDate = _props.endDate, |
|
prevFocusedInput = _props.focusedInput, |
|
prevMinimumNights = _props.minimumNights, |
|
prevIsOutsideRange = _props.isOutsideRange, |
|
prevIsDayBlocked = _props.isDayBlocked, |
|
prevIsDayHighlighted = _props.isDayHighlighted, |
|
prevPhrases = _props.phrases, |
|
prevInitialVisibleMonth = _props.initialVisibleMonth, |
|
prevNumberOfMonths = _props.numberOfMonths, |
|
prevEnableOutsideDays = _props.enableOutsideDays; |
|
var visibleDays = this.state.visibleDays; |
|
|
|
|
|
var recomputeOutsideRange = false; |
|
var recomputeDayBlocked = false; |
|
var recomputeDayHighlighted = false; |
|
|
|
if (isOutsideRange !== prevIsOutsideRange) { |
|
this.modifiers['blocked-out-of-range'] = function (day) { |
|
return isOutsideRange(day); |
|
}; |
|
recomputeOutsideRange = true; |
|
} |
|
|
|
if (isDayBlocked !== prevIsDayBlocked) { |
|
this.modifiers['blocked-calendar'] = function (day) { |
|
return isDayBlocked(day); |
|
}; |
|
recomputeDayBlocked = true; |
|
} |
|
|
|
if (isDayHighlighted !== prevIsDayHighlighted) { |
|
this.modifiers['highlighted-calendar'] = function (day) { |
|
return isDayHighlighted(day); |
|
}; |
|
recomputeDayHighlighted = true; |
|
} |
|
|
|
var recomputePropModifiers = recomputeOutsideRange || recomputeDayBlocked || recomputeDayHighlighted; |
|
|
|
var didStartDateChange = startDate !== prevStartDate; |
|
var didEndDateChange = endDate !== prevEndDate; |
|
var didFocusChange = focusedInput !== prevFocusedInput; |
|
|
|
if (numberOfMonths !== prevNumberOfMonths || enableOutsideDays !== prevEnableOutsideDays || initialVisibleMonth !== prevInitialVisibleMonth && !prevFocusedInput && didFocusChange) { |
|
var newMonthState = this.getStateForNewMonth(nextProps); |
|
var currentMonth = newMonthState.currentMonth; |
|
visibleDays = newMonthState.visibleDays; |
|
|
|
this.setState({ |
|
currentMonth: currentMonth, |
|
visibleDays: visibleDays |
|
}); |
|
} |
|
|
|
var modifiers = {}; |
|
|
|
if (didStartDateChange) { |
|
modifiers = this.deleteModifier(modifiers, prevStartDate, 'selected-start'); |
|
modifiers = this.addModifier(modifiers, startDate, 'selected-start'); |
|
|
|
if (prevStartDate) { |
|
var startSpan = prevStartDate.clone().add(1, 'day'); |
|
var endSpan = prevStartDate.clone().add(prevMinimumNights + 1, 'days'); |
|
modifiers = this.deleteModifierFromRange(modifiers, startSpan, endSpan, 'after-hovered-start'); |
|
} |
|
} |
|
|
|
if (didEndDateChange) { |
|
modifiers = this.deleteModifier(modifiers, prevEndDate, 'selected-end'); |
|
modifiers = this.addModifier(modifiers, endDate, 'selected-end'); |
|
} |
|
|
|
if (didStartDateChange || didEndDateChange) { |
|
if (prevStartDate && prevEndDate) { |
|
modifiers = this.deleteModifierFromRange(modifiers, prevStartDate, prevEndDate.clone().add(1, 'day'), 'selected-span'); |
|
} |
|
|
|
if (startDate && endDate) { |
|
modifiers = this.deleteModifierFromRange(modifiers, startDate, endDate.clone().add(1, 'day'), 'hovered-span'); |
|
|
|
modifiers = this.addModifierToRange(modifiers, startDate.clone().add(1, 'day'), endDate, 'selected-span'); |
|
} |
|
} |
|
|
|
if (!this.isTouchDevice && didStartDateChange && startDate && !endDate) { |
|
var _startSpan = startDate.clone().add(1, 'day'); |
|
var _endSpan = startDate.clone().add(minimumNights + 1, 'days'); |
|
modifiers = this.addModifierToRange(modifiers, _startSpan, _endSpan, 'after-hovered-start'); |
|
} |
|
|
|
if (prevMinimumNights > 0) { |
|
if (didFocusChange || didStartDateChange || minimumNights !== prevMinimumNights) { |
|
var _startSpan2 = prevStartDate || this.today; |
|
modifiers = this.deleteModifierFromRange(modifiers, _startSpan2, _startSpan2.clone().add(prevMinimumNights, 'days'), 'blocked-minimum-nights'); |
|
|
|
modifiers = this.deleteModifierFromRange(modifiers, _startSpan2, _startSpan2.clone().add(prevMinimumNights, 'days'), 'blocked'); |
|
} |
|
} |
|
|
|
if (didFocusChange || recomputePropModifiers) { |
|
(0, _object4['default'])(visibleDays).forEach(function (days) { |
|
Object.keys(days).forEach(function (day) { |
|
var momentObj = (0, _moment2['default'])(day); |
|
var isBlocked = false; |
|
|
|
if (didFocusChange || recomputeOutsideRange) { |
|
if (isOutsideRange(momentObj)) { |
|
modifiers = _this2.addModifier(modifiers, momentObj, 'blocked-out-of-range'); |
|
isBlocked = true; |
|
} else { |
|
modifiers = _this2.deleteModifier(modifiers, momentObj, 'blocked-out-of-range'); |
|
} |
|
} |
|
|
|
if (didFocusChange || recomputeDayBlocked) { |
|
if (isDayBlocked(momentObj)) { |
|
modifiers = _this2.addModifier(modifiers, momentObj, 'blocked-calendar'); |
|
isBlocked = true; |
|
} else { |
|
modifiers = _this2.deleteModifier(modifiers, momentObj, 'blocked-calendar'); |
|
} |
|
} |
|
|
|
if (isBlocked) { |
|
modifiers = _this2.addModifier(modifiers, momentObj, 'blocked'); |
|
} else { |
|
modifiers = _this2.deleteModifier(modifiers, momentObj, 'blocked'); |
|
} |
|
|
|
if (didFocusChange || recomputeDayHighlighted) { |
|
if (isDayHighlighted(momentObj)) { |
|
modifiers = _this2.addModifier(modifiers, momentObj, 'highlighted-calendar'); |
|
} else { |
|
modifiers = _this2.deleteModifier(modifiers, momentObj, 'highlighted-calendar'); |
|
} |
|
} |
|
}); |
|
}); |
|
} |
|
|
|
if (minimumNights > 0 && startDate && focusedInput === _constants.END_DATE) { |
|
modifiers = this.addModifierToRange(modifiers, startDate, startDate.clone().add(minimumNights, 'days'), 'blocked-minimum-nights'); |
|
|
|
modifiers = this.addModifierToRange(modifiers, startDate, startDate.clone().add(minimumNights, 'days'), 'blocked'); |
|
} |
|
|
|
var today = (0, _moment2['default'])(); |
|
if (!(0, _isSameDay2['default'])(this.today, today)) { |
|
modifiers = this.deleteModifier(modifiers, this.today, 'today'); |
|
modifiers = this.addModifier(modifiers, today, 'today'); |
|
this.today = today; |
|
} |
|
|
|
if (Object.keys(modifiers).length > 0) { |
|
this.setState({ |
|
visibleDays: (0, _object2['default'])({}, visibleDays, modifiers) |
|
}); |
|
} |
|
|
|
if (didFocusChange || phrases !== prevPhrases) { |
|
// set the appropriate CalendarDay phrase based on focusedInput |
|
var chooseAvailableDate = getChooseAvailableDatePhrase(phrases, focusedInput); |
|
|
|
this.setState({ |
|
phrases: (0, _object2['default'])({}, phrases, { |
|
chooseAvailableDate: chooseAvailableDate |
|
}) |
|
}); |
|
} |
|
} |
|
|
|
return componentWillReceiveProps; |
|
}() |
|
}, { |
|
key: 'onDayClick', |
|
value: function () { |
|
function onDayClick(day, e) { |
|
var _props2 = this.props, |
|
keepOpenOnDateSelect = _props2.keepOpenOnDateSelect, |
|
minimumNights = _props2.minimumNights, |
|
onBlur = _props2.onBlur, |
|
focusedInput = _props2.focusedInput, |
|
onFocusChange = _props2.onFocusChange, |
|
onClose = _props2.onClose, |
|
onDatesChange = _props2.onDatesChange, |
|
startDateOffset = _props2.startDateOffset, |
|
endDateOffset = _props2.endDateOffset, |
|
disabled = _props2.disabled; |
|
|
|
|
|
if (e) e.preventDefault(); |
|
if (this.isBlocked(day)) return; |
|
|
|
var _props3 = this.props, |
|
startDate = _props3.startDate, |
|
endDate = _props3.endDate; |
|
|
|
|
|
if (startDateOffset || endDateOffset) { |
|
startDate = (0, _getSelectedDateOffset2['default'])(startDateOffset, day); |
|
endDate = (0, _getSelectedDateOffset2['default'])(endDateOffset, day); |
|
|
|
if (!keepOpenOnDateSelect) { |
|
onFocusChange(null); |
|
onClose({ startDate: startDate, endDate: endDate }); |
|
} |
|
} else if (focusedInput === _constants.START_DATE) { |
|
var lastAllowedStartDate = endDate && endDate.clone().subtract(minimumNights, 'days'); |
|
var isStartDateAfterEndDate = (0, _isBeforeDay2['default'])(lastAllowedStartDate, day) || (0, _isAfterDay2['default'])(startDate, endDate); |
|
var isEndDateDisabled = disabled === _constants.END_DATE; |
|
|
|
if (!isEndDateDisabled || !isStartDateAfterEndDate) { |
|
startDate = day; |
|
if (isStartDateAfterEndDate) { |
|
endDate = null; |
|
} |
|
} |
|
|
|
if (isEndDateDisabled && !isStartDateAfterEndDate) { |
|
onFocusChange(null); |
|
onClose({ startDate: startDate, endDate: endDate }); |
|
} else if (!isEndDateDisabled) { |
|
onFocusChange(_constants.END_DATE); |
|
} |
|
} else if (focusedInput === _constants.END_DATE) { |
|
var firstAllowedEndDate = startDate && startDate.clone().add(minimumNights, 'days'); |
|
|
|
if (!startDate) { |
|
endDate = day; |
|
onFocusChange(_constants.START_DATE); |
|
} else if ((0, _isInclusivelyAfterDay2['default'])(day, firstAllowedEndDate)) { |
|
endDate = day; |
|
if (!keepOpenOnDateSelect) { |
|
onFocusChange(null); |
|
onClose({ startDate: startDate, endDate: endDate }); |
|
} |
|
} else if (disabled !== _constants.START_DATE) { |
|
startDate = day; |
|
endDate = null; |
|
} |
|
} |
|
|
|
onDatesChange({ startDate: startDate, endDate: endDate }); |
|
onBlur(); |
|
} |
|
|
|
return onDayClick; |
|
}() |
|
}, { |
|
key: 'onDayMouseEnter', |
|
value: function () { |
|
function onDayMouseEnter(day) { |
|
/* eslint react/destructuring-assignment: 1 */ |
|
if (this.isTouchDevice) return; |
|
var _props4 = this.props, |
|
startDate = _props4.startDate, |
|
endDate = _props4.endDate, |
|
focusedInput = _props4.focusedInput, |
|
minimumNights = _props4.minimumNights, |
|
startDateOffset = _props4.startDateOffset, |
|
endDateOffset = _props4.endDateOffset; |
|
var _state = this.state, |
|
hoverDate = _state.hoverDate, |
|
visibleDays = _state.visibleDays; |
|
|
|
var dateOffset = null; |
|
|
|
if (focusedInput) { |
|
var hasOffset = startDateOffset || endDateOffset; |
|
var modifiers = {}; |
|
|
|
if (hasOffset) { |
|
var start = (0, _getSelectedDateOffset2['default'])(startDateOffset, day); |
|
var end = (0, _getSelectedDateOffset2['default'])(endDateOffset, day, function (rangeDay) { |
|
return rangeDay.add(1, 'day'); |
|
}); |
|
|
|
dateOffset = { |
|
start: start, |
|
end: end |
|
}; |
|
|
|
// eslint-disable-next-line react/destructuring-assignment |
|
if (this.state.dateOffset && this.state.dateOffset.start && this.state.dateOffset.end) { |
|
modifiers = this.deleteModifierFromRange(modifiers, this.state.dateOffset.start, this.state.dateOffset.end, 'hovered-offset'); |
|
} |
|
modifiers = this.addModifierToRange(modifiers, start, end, 'hovered-offset'); |
|
} |
|
|
|
if (!hasOffset) { |
|
modifiers = this.deleteModifier(modifiers, hoverDate, 'hovered'); |
|
modifiers = this.addModifier(modifiers, day, 'hovered'); |
|
|
|
if (startDate && !endDate && focusedInput === _constants.END_DATE) { |
|
if ((0, _isAfterDay2['default'])(hoverDate, startDate)) { |
|
var endSpan = hoverDate.clone().add(1, 'day'); |
|
modifiers = this.deleteModifierFromRange(modifiers, startDate, endSpan, 'hovered-span'); |
|
} |
|
|
|
if (!this.isBlocked(day) && (0, _isAfterDay2['default'])(day, startDate)) { |
|
var _endSpan2 = day.clone().add(1, 'day'); |
|
modifiers = this.addModifierToRange(modifiers, startDate, _endSpan2, 'hovered-span'); |
|
} |
|
} |
|
|
|
if (!startDate && endDate && focusedInput === _constants.START_DATE) { |
|
if ((0, _isBeforeDay2['default'])(hoverDate, endDate)) { |
|
modifiers = this.deleteModifierFromRange(modifiers, hoverDate, endDate, 'hovered-span'); |
|
} |
|
|
|
if (!this.isBlocked(day) && (0, _isBeforeDay2['default'])(day, endDate)) { |
|
modifiers = this.addModifierToRange(modifiers, day, endDate, 'hovered-span'); |
|
} |
|
} |
|
|
|
if (startDate) { |
|
var startSpan = startDate.clone().add(1, 'day'); |
|
var _endSpan3 = startDate.clone().add(minimumNights + 1, 'days'); |
|
modifiers = this.deleteModifierFromRange(modifiers, startSpan, _endSpan3, 'after-hovered-start'); |
|
|
|
if ((0, _isSameDay2['default'])(day, startDate)) { |
|
var newStartSpan = startDate.clone().add(1, 'day'); |
|
var newEndSpan = startDate.clone().add(minimumNights + 1, 'days'); |
|
modifiers = this.addModifierToRange(modifiers, newStartSpan, newEndSpan, 'after-hovered-start'); |
|
} |
|
} |
|
} |
|
|
|
this.setState({ |
|
hoverDate: day, |
|
dateOffset: dateOffset, |
|
visibleDays: (0, _object2['default'])({}, visibleDays, modifiers) |
|
}); |
|
} |
|
} |
|
|
|
return onDayMouseEnter; |
|
}() |
|
}, { |
|
key: 'onDayMouseLeave', |
|
value: function () { |
|
function onDayMouseLeave(day) { |
|
var _props5 = this.props, |
|
startDate = _props5.startDate, |
|
endDate = _props5.endDate, |
|
minimumNights = _props5.minimumNights; |
|
var _state2 = this.state, |
|
hoverDate = _state2.hoverDate, |
|
visibleDays = _state2.visibleDays, |
|
dateOffset = _state2.dateOffset; |
|
|
|
if (this.isTouchDevice || !hoverDate) return; |
|
|
|
var modifiers = {}; |
|
modifiers = this.deleteModifier(modifiers, hoverDate, 'hovered'); |
|
|
|
if (dateOffset) { |
|
modifiers = this.deleteModifierFromRange(modifiers, this.state.dateOffset.start, this.state.dateOffset.end, 'hovered-offset'); |
|
} |
|
|
|
if (startDate && !endDate && (0, _isAfterDay2['default'])(hoverDate, startDate)) { |
|
var endSpan = hoverDate.clone().add(1, 'day'); |
|
modifiers = this.deleteModifierFromRange(modifiers, startDate, endSpan, 'hovered-span'); |
|
} |
|
|
|
if (!startDate && endDate && (0, _isAfterDay2['default'])(endDate, hoverDate)) { |
|
modifiers = this.deleteModifierFromRange(modifiers, hoverDate, endDate, 'hovered-span'); |
|
} |
|
|
|
if (startDate && (0, _isSameDay2['default'])(day, startDate)) { |
|
var startSpan = startDate.clone().add(1, 'day'); |
|
var _endSpan4 = startDate.clone().add(minimumNights + 1, 'days'); |
|
modifiers = this.deleteModifierFromRange(modifiers, startSpan, _endSpan4, 'after-hovered-start'); |
|
} |
|
|
|
this.setState({ |
|
hoverDate: null, |
|
visibleDays: (0, _object2['default'])({}, visibleDays, modifiers) |
|
}); |
|
} |
|
|
|
return onDayMouseLeave; |
|
}() |
|
}, { |
|
key: 'onPrevMonthClick', |
|
value: function () { |
|
function onPrevMonthClick() { |
|
var _props6 = this.props, |
|
onPrevMonthClick = _props6.onPrevMonthClick, |
|
numberOfMonths = _props6.numberOfMonths, |
|
enableOutsideDays = _props6.enableOutsideDays; |
|
var _state3 = this.state, |
|
currentMonth = _state3.currentMonth, |
|
visibleDays = _state3.visibleDays; |
|
|
|
|
|
var newVisibleDays = {}; |
|
Object.keys(visibleDays).sort().slice(0, numberOfMonths + 1).forEach(function (month) { |
|
newVisibleDays[month] = visibleDays[month]; |
|
}); |
|
|
|
var prevMonth = currentMonth.clone().subtract(2, 'months'); |
|
var prevMonthVisibleDays = (0, _getVisibleDays2['default'])(prevMonth, 1, enableOutsideDays, true); |
|
|
|
var newCurrentMonth = currentMonth.clone().subtract(1, 'month'); |
|
this.setState({ |
|
currentMonth: newCurrentMonth, |
|
visibleDays: (0, _object2['default'])({}, newVisibleDays, this.getModifiers(prevMonthVisibleDays)) |
|
}, function () { |
|
onPrevMonthClick(newCurrentMonth.clone()); |
|
}); |
|
} |
|
|
|
return onPrevMonthClick; |
|
}() |
|
}, { |
|
key: 'onNextMonthClick', |
|
value: function () { |
|
function onNextMonthClick() { |
|
var _props7 = this.props, |
|
onNextMonthClick = _props7.onNextMonthClick, |
|
numberOfMonths = _props7.numberOfMonths, |
|
enableOutsideDays = _props7.enableOutsideDays; |
|
var _state4 = this.state, |
|
currentMonth = _state4.currentMonth, |
|
visibleDays = _state4.visibleDays; |
|
|
|
|
|
var newVisibleDays = {}; |
|
Object.keys(visibleDays).sort().slice(1).forEach(function (month) { |
|
newVisibleDays[month] = visibleDays[month]; |
|
}); |
|
|
|
var nextMonth = currentMonth.clone().add(numberOfMonths + 1, 'month'); |
|
var nextMonthVisibleDays = (0, _getVisibleDays2['default'])(nextMonth, 1, enableOutsideDays, true); |
|
|
|
var newCurrentMonth = currentMonth.clone().add(1, 'month'); |
|
this.setState({ |
|
currentMonth: newCurrentMonth, |
|
visibleDays: (0, _object2['default'])({}, newVisibleDays, this.getModifiers(nextMonthVisibleDays)) |
|
}, function () { |
|
onNextMonthClick(newCurrentMonth.clone()); |
|
}); |
|
} |
|
|
|
return onNextMonthClick; |
|
}() |
|
}, { |
|
key: 'onMonthChange', |
|
value: function () { |
|
function onMonthChange(newMonth) { |
|
var _props8 = this.props, |
|
numberOfMonths = _props8.numberOfMonths, |
|
enableOutsideDays = _props8.enableOutsideDays, |
|
orientation = _props8.orientation; |
|
|
|
var withoutTransitionMonths = orientation === _constants.VERTICAL_SCROLLABLE; |
|
var newVisibleDays = (0, _getVisibleDays2['default'])(newMonth, numberOfMonths, enableOutsideDays, withoutTransitionMonths); |
|
|
|
this.setState({ |
|
currentMonth: newMonth.clone(), |
|
visibleDays: this.getModifiers(newVisibleDays) |
|
}); |
|
} |
|
|
|
return onMonthChange; |
|
}() |
|
}, { |
|
key: 'onYearChange', |
|
value: function () { |
|
function onYearChange(newMonth) { |
|
var _props9 = this.props, |
|
numberOfMonths = _props9.numberOfMonths, |
|
enableOutsideDays = _props9.enableOutsideDays, |
|
orientation = _props9.orientation; |
|
|
|
var withoutTransitionMonths = orientation === _constants.VERTICAL_SCROLLABLE; |
|
var newVisibleDays = (0, _getVisibleDays2['default'])(newMonth, numberOfMonths, enableOutsideDays, withoutTransitionMonths); |
|
|
|
this.setState({ |
|
currentMonth: newMonth.clone(), |
|
visibleDays: this.getModifiers(newVisibleDays) |
|
}); |
|
} |
|
|
|
return onYearChange; |
|
}() |
|
}, { |
|
key: 'onMultiplyScrollableMonths', |
|
value: function () { |
|
function onMultiplyScrollableMonths() { |
|
var _props10 = this.props, |
|
numberOfMonths = _props10.numberOfMonths, |
|
enableOutsideDays = _props10.enableOutsideDays; |
|
var _state5 = this.state, |
|
currentMonth = _state5.currentMonth, |
|
visibleDays = _state5.visibleDays; |
|
|
|
|
|
var numberOfVisibleMonths = Object.keys(visibleDays).length; |
|
var nextMonth = currentMonth.clone().add(numberOfVisibleMonths, 'month'); |
|
var newVisibleDays = (0, _getVisibleDays2['default'])(nextMonth, numberOfMonths, enableOutsideDays, true); |
|
|
|
this.setState({ |
|
visibleDays: (0, _object2['default'])({}, visibleDays, this.getModifiers(newVisibleDays)) |
|
}); |
|
} |
|
|
|
return onMultiplyScrollableMonths; |
|
}() |
|
}, { |
|
key: 'getFirstFocusableDay', |
|
value: function () { |
|
function getFirstFocusableDay(newMonth) { |
|
var _this3 = this; |
|
|
|
var _props11 = this.props, |
|
startDate = _props11.startDate, |
|
endDate = _props11.endDate, |
|
focusedInput = _props11.focusedInput, |
|
minimumNights = _props11.minimumNights, |
|
numberOfMonths = _props11.numberOfMonths; |
|
|
|
|
|
var focusedDate = newMonth.clone().startOf('month'); |
|
if (focusedInput === _constants.START_DATE && startDate) { |
|
focusedDate = startDate.clone(); |
|
} else if (focusedInput === _constants.END_DATE && !endDate && startDate) { |
|
focusedDate = startDate.clone().add(minimumNights, 'days'); |
|
} else if (focusedInput === _constants.END_DATE && endDate) { |
|
focusedDate = endDate.clone(); |
|
} |
|
|
|
if (this.isBlocked(focusedDate)) { |
|
var days = []; |
|
var lastVisibleDay = newMonth.clone().add(numberOfMonths - 1, 'months').endOf('month'); |
|
var currentDay = focusedDate.clone(); |
|
while (!(0, _isAfterDay2['default'])(currentDay, lastVisibleDay)) { |
|
currentDay = currentDay.clone().add(1, 'day'); |
|
days.push(currentDay); |
|
} |
|
|
|
var viableDays = days.filter(function (day) { |
|
return !_this3.isBlocked(day); |
|
}); |
|
|
|
if (viableDays.length > 0) { |
|
var _viableDays = _slicedToArray(viableDays, 1); |
|
|
|
focusedDate = _viableDays[0]; |
|
} |
|
} |
|
|
|
return focusedDate; |
|
} |
|
|
|
return getFirstFocusableDay; |
|
}() |
|
}, { |
|
key: 'getModifiers', |
|
value: function () { |
|
function getModifiers(visibleDays) { |
|
var _this4 = this; |
|
|
|
var modifiers = {}; |
|
Object.keys(visibleDays).forEach(function (month) { |
|
modifiers[month] = {}; |
|
visibleDays[month].forEach(function (day) { |
|
modifiers[month][(0, _toISODateString2['default'])(day)] = _this4.getModifiersForDay(day); |
|
}); |
|
}); |
|
|
|
return modifiers; |
|
} |
|
|
|
return getModifiers; |
|
}() |
|
}, { |
|
key: 'getModifiersForDay', |
|
value: function () { |
|
function getModifiersForDay(day) { |
|
var _this5 = this; |
|
|
|
return new Set(Object.keys(this.modifiers).filter(function (modifier) { |
|
return _this5.modifiers[modifier](day); |
|
})); |
|
} |
|
|
|
return getModifiersForDay; |
|
}() |
|
}, { |
|
key: 'getStateForNewMonth', |
|
value: function () { |
|
function getStateForNewMonth(nextProps) { |
|
var _this6 = this; |
|
|
|
var initialVisibleMonth = nextProps.initialVisibleMonth, |
|
numberOfMonths = nextProps.numberOfMonths, |
|
enableOutsideDays = nextProps.enableOutsideDays, |
|
orientation = nextProps.orientation, |
|
startDate = nextProps.startDate; |
|
|
|
var initialVisibleMonthThunk = initialVisibleMonth || (startDate ? function () { |
|
return startDate; |
|
} : function () { |
|
return _this6.today; |
|
}); |
|
var currentMonth = initialVisibleMonthThunk(); |
|
var withoutTransitionMonths = orientation === _constants.VERTICAL_SCROLLABLE; |
|
var visibleDays = this.getModifiers((0, _getVisibleDays2['default'])(currentMonth, numberOfMonths, enableOutsideDays, withoutTransitionMonths)); |
|
return { currentMonth: currentMonth, visibleDays: visibleDays }; |
|
} |
|
|
|
return getStateForNewMonth; |
|
}() |
|
}, { |
|
key: 'addModifier', |
|
value: function () { |
|
function addModifier(updatedDays, day, modifier) { |
|
var _props12 = this.props, |
|
numberOfVisibleMonths = _props12.numberOfMonths, |
|
enableOutsideDays = _props12.enableOutsideDays, |
|
orientation = _props12.orientation; |
|
var _state6 = this.state, |
|
firstVisibleMonth = _state6.currentMonth, |
|
visibleDays = _state6.visibleDays; |
|
|
|
|
|
var currentMonth = firstVisibleMonth; |
|
var numberOfMonths = numberOfVisibleMonths; |
|
if (orientation === _constants.VERTICAL_SCROLLABLE) { |
|
numberOfMonths = Object.keys(visibleDays).length; |
|
} else { |
|
currentMonth = currentMonth.clone().subtract(1, 'month'); |
|
numberOfMonths += 2; |
|
} |
|
if (!day || !(0, _isDayVisible2['default'])(day, currentMonth, numberOfMonths, enableOutsideDays)) { |
|
return updatedDays; |
|
} |
|
|
|
var iso = (0, _toISODateString2['default'])(day); |
|
|
|
var updatedDaysAfterAddition = (0, _object2['default'])({}, updatedDays); |
|
if (enableOutsideDays) { |
|
var monthsToUpdate = Object.keys(visibleDays).filter(function (monthKey) { |
|
return Object.keys(visibleDays[monthKey]).indexOf(iso) > -1; |
|
}); |
|
|
|
updatedDaysAfterAddition = monthsToUpdate.reduce(function (days, monthIso) { |
|
var month = updatedDays[monthIso] || visibleDays[monthIso]; |
|
var modifiers = new Set(month[iso]); |
|
modifiers.add(modifier); |
|
return (0, _object2['default'])({}, days, _defineProperty({}, monthIso, (0, _object2['default'])({}, month, _defineProperty({}, iso, modifiers)))); |
|
}, updatedDaysAfterAddition); |
|
} else { |
|
var monthIso = (0, _toISOMonthString2['default'])(day); |
|
var month = updatedDays[monthIso] || visibleDays[monthIso]; |
|
|
|
var modifiers = new Set(month[iso]); |
|
modifiers.add(modifier); |
|
updatedDaysAfterAddition = (0, _object2['default'])({}, updatedDaysAfterAddition, _defineProperty({}, monthIso, (0, _object2['default'])({}, month, _defineProperty({}, iso, modifiers)))); |
|
} |
|
|
|
return updatedDaysAfterAddition; |
|
} |
|
|
|
return addModifier; |
|
}() |
|
}, { |
|
key: 'addModifierToRange', |
|
value: function () { |
|
function addModifierToRange(updatedDays, start, end, modifier) { |
|
var days = updatedDays; |
|
|
|
var spanStart = start.clone(); |
|
while ((0, _isBeforeDay2['default'])(spanStart, end)) { |
|
days = this.addModifier(days, spanStart, modifier); |
|
spanStart = spanStart.clone().add(1, 'day'); |
|
} |
|
|
|
return days; |
|
} |
|
|
|
return addModifierToRange; |
|
}() |
|
}, { |
|
key: 'deleteModifier', |
|
value: function () { |
|
function deleteModifier(updatedDays, day, modifier) { |
|
var _props13 = this.props, |
|
numberOfVisibleMonths = _props13.numberOfMonths, |
|
enableOutsideDays = _props13.enableOutsideDays, |
|
orientation = _props13.orientation; |
|
var _state7 = this.state, |
|
firstVisibleMonth = _state7.currentMonth, |
|
visibleDays = _state7.visibleDays; |
|
|
|
var currentMonth = firstVisibleMonth; |
|
var numberOfMonths = numberOfVisibleMonths; |
|
if (orientation === _constants.VERTICAL_SCROLLABLE) { |
|
numberOfMonths = Object.keys(visibleDays).length; |
|
} else { |
|
currentMonth = currentMonth.clone().subtract(1, 'month'); |
|
numberOfMonths += 2; |
|
} |
|
if (!day || !(0, _isDayVisible2['default'])(day, currentMonth, numberOfMonths, enableOutsideDays)) { |
|
return updatedDays; |
|
} |
|
|
|
var iso = (0, _toISODateString2['default'])(day); |
|
|
|
var updatedDaysAfterDeletion = (0, _object2['default'])({}, updatedDays); |
|
if (enableOutsideDays) { |
|
var monthsToUpdate = Object.keys(visibleDays).filter(function (monthKey) { |
|
return Object.keys(visibleDays[monthKey]).indexOf(iso) > -1; |
|
}); |
|
|
|
updatedDaysAfterDeletion = monthsToUpdate.reduce(function (days, monthIso) { |
|
var month = updatedDays[monthIso] || visibleDays[monthIso]; |
|
var modifiers = new Set(month[iso]); |
|
modifiers['delete'](modifier); |
|
return (0, _object2['default'])({}, days, _defineProperty({}, monthIso, (0, _object2['default'])({}, month, _defineProperty({}, iso, modifiers)))); |
|
}, updatedDaysAfterDeletion); |
|
} else { |
|
var monthIso = (0, _toISOMonthString2['default'])(day); |
|
var month = updatedDays[monthIso] || visibleDays[monthIso]; |
|
|
|
var modifiers = new Set(month[iso]); |
|
modifiers['delete'](modifier); |
|
updatedDaysAfterDeletion = (0, _object2['default'])({}, updatedDaysAfterDeletion, _defineProperty({}, monthIso, (0, _object2['default'])({}, month, _defineProperty({}, iso, modifiers)))); |
|
} |
|
|
|
return updatedDaysAfterDeletion; |
|
} |
|
|
|
return deleteModifier; |
|
}() |
|
}, { |
|
key: 'deleteModifierFromRange', |
|
value: function () { |
|
function deleteModifierFromRange(updatedDays, start, end, modifier) { |
|
var days = updatedDays; |
|
|
|
var spanStart = start.clone(); |
|
while ((0, _isBeforeDay2['default'])(spanStart, end)) { |
|
days = this.deleteModifier(days, spanStart, modifier); |
|
spanStart = spanStart.clone().add(1, 'day'); |
|
} |
|
|
|
return days; |
|
} |
|
|
|
return deleteModifierFromRange; |
|
}() |
|
}, { |
|
key: 'doesNotMeetMinimumNights', |
|
value: function () { |
|
function doesNotMeetMinimumNights(day) { |
|
var _props14 = this.props, |
|
startDate = _props14.startDate, |
|
isOutsideRange = _props14.isOutsideRange, |
|
focusedInput = _props14.focusedInput, |
|
minimumNights = _props14.minimumNights; |
|
|
|
if (focusedInput !== _constants.END_DATE) return false; |
|
|
|
if (startDate) { |
|
var dayDiff = day.diff(startDate.clone().startOf('day').hour(12), 'days'); |
|
return dayDiff < minimumNights && dayDiff >= 0; |
|
} |
|
return isOutsideRange((0, _moment2['default'])(day).subtract(minimumNights, 'days')); |
|
} |
|
|
|
return doesNotMeetMinimumNights; |
|
}() |
|
}, { |
|
key: 'isDayAfterHoveredStartDate', |
|
value: function () { |
|
function isDayAfterHoveredStartDate(day) { |
|
var _props15 = this.props, |
|
startDate = _props15.startDate, |
|
endDate = _props15.endDate, |
|
minimumNights = _props15.minimumNights; |
|
|
|
var _ref = this.state || {}, |
|
hoverDate = _ref.hoverDate; |
|
|
|
return !!startDate && !endDate && !this.isBlocked(day) && (0, _isNextDay2['default'])(hoverDate, day) && minimumNights > 0 && (0, _isSameDay2['default'])(hoverDate, startDate); |
|
} |
|
|
|
return isDayAfterHoveredStartDate; |
|
}() |
|
}, { |
|
key: 'isEndDate', |
|
value: function () { |
|
function isEndDate(day) { |
|
var endDate = this.props.endDate; |
|
|
|
return (0, _isSameDay2['default'])(day, endDate); |
|
} |
|
|
|
return isEndDate; |
|
}() |
|
}, { |
|
key: 'isHovered', |
|
value: function () { |
|
function isHovered(day) { |
|
var _ref2 = this.state || {}, |
|
hoverDate = _ref2.hoverDate; |
|
|
|
var focusedInput = this.props.focusedInput; |
|
|
|
return !!focusedInput && (0, _isSameDay2['default'])(day, hoverDate); |
|
} |
|
|
|
return isHovered; |
|
}() |
|
}, { |
|
key: 'isInHoveredSpan', |
|
value: function () { |
|
function isInHoveredSpan(day) { |
|
var _props16 = this.props, |
|
startDate = _props16.startDate, |
|
endDate = _props16.endDate; |
|
|
|
var _ref3 = this.state || {}, |
|
hoverDate = _ref3.hoverDate; |
|
|
|
var isForwardRange = !!startDate && !endDate && (day.isBetween(startDate, hoverDate) || (0, _isSameDay2['default'])(hoverDate, day)); |
|
var isBackwardRange = !!endDate && !startDate && (day.isBetween(hoverDate, endDate) || (0, _isSameDay2['default'])(hoverDate, day)); |
|
|
|
var isValidDayHovered = hoverDate && !this.isBlocked(hoverDate); |
|
|
|
return (isForwardRange || isBackwardRange) && isValidDayHovered; |
|
} |
|
|
|
return isInHoveredSpan; |
|
}() |
|
}, { |
|
key: 'isInSelectedSpan', |
|
value: function () { |
|
function isInSelectedSpan(day) { |
|
var _props17 = this.props, |
|
startDate = _props17.startDate, |
|
endDate = _props17.endDate; |
|
|
|
return day.isBetween(startDate, endDate); |
|
} |
|
|
|
return isInSelectedSpan; |
|
}() |
|
}, { |
|
key: 'isLastInRange', |
|
value: function () { |
|
function isLastInRange(day) { |
|
var endDate = this.props.endDate; |
|
|
|
return this.isInSelectedSpan(day) && (0, _isNextDay2['default'])(day, endDate); |
|
} |
|
|
|
return isLastInRange; |
|
}() |
|
}, { |
|
key: 'isStartDate', |
|
value: function () { |
|
function isStartDate(day) { |
|
var startDate = this.props.startDate; |
|
|
|
return (0, _isSameDay2['default'])(day, startDate); |
|
} |
|
|
|
return isStartDate; |
|
}() |
|
}, { |
|
key: 'isBlocked', |
|
value: function () { |
|
function isBlocked(day) { |
|
var _props18 = this.props, |
|
isDayBlocked = _props18.isDayBlocked, |
|
isOutsideRange = _props18.isOutsideRange; |
|
|
|
return isDayBlocked(day) || isOutsideRange(day) || this.doesNotMeetMinimumNights(day); |
|
} |
|
|
|
return isBlocked; |
|
}() |
|
}, { |
|
key: 'isToday', |
|
value: function () { |
|
function isToday(day) { |
|
return (0, _isSameDay2['default'])(day, this.today); |
|
} |
|
|
|
return isToday; |
|
}() |
|
}, { |
|
key: 'isFirstDayOfWeek', |
|
value: function () { |
|
function isFirstDayOfWeek(day) { |
|
var firstDayOfWeek = this.props.firstDayOfWeek; |
|
|
|
return day.day() === (firstDayOfWeek || _moment2['default'].localeData().firstDayOfWeek()); |
|
} |
|
|
|
return isFirstDayOfWeek; |
|
}() |
|
}, { |
|
key: 'isLastDayOfWeek', |
|
value: function () { |
|
function isLastDayOfWeek(day) { |
|
var firstDayOfWeek = this.props.firstDayOfWeek; |
|
|
|
return day.day() === ((firstDayOfWeek || _moment2['default'].localeData().firstDayOfWeek()) + 6) % 7; |
|
} |
|
|
|
return isLastDayOfWeek; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _props19 = this.props, |
|
numberOfMonths = _props19.numberOfMonths, |
|
orientation = _props19.orientation, |
|
monthFormat = _props19.monthFormat, |
|
renderMonthText = _props19.renderMonthText, |
|
navPrev = _props19.navPrev, |
|
navNext = _props19.navNext, |
|
noNavButtons = _props19.noNavButtons, |
|
onOutsideClick = _props19.onOutsideClick, |
|
withPortal = _props19.withPortal, |
|
enableOutsideDays = _props19.enableOutsideDays, |
|
firstDayOfWeek = _props19.firstDayOfWeek, |
|
hideKeyboardShortcutsPanel = _props19.hideKeyboardShortcutsPanel, |
|
daySize = _props19.daySize, |
|
focusedInput = _props19.focusedInput, |
|
renderCalendarDay = _props19.renderCalendarDay, |
|
renderDayContents = _props19.renderDayContents, |
|
renderCalendarInfo = _props19.renderCalendarInfo, |
|
renderMonthElement = _props19.renderMonthElement, |
|
calendarInfoPosition = _props19.calendarInfoPosition, |
|
onBlur = _props19.onBlur, |
|
isFocused = _props19.isFocused, |
|
showKeyboardShortcuts = _props19.showKeyboardShortcuts, |
|
isRTL = _props19.isRTL, |
|
weekDayFormat = _props19.weekDayFormat, |
|
dayAriaLabelFormat = _props19.dayAriaLabelFormat, |
|
verticalHeight = _props19.verticalHeight, |
|
noBorder = _props19.noBorder, |
|
transitionDuration = _props19.transitionDuration, |
|
verticalBorderSpacing = _props19.verticalBorderSpacing, |
|
horizontalMonthPadding = _props19.horizontalMonthPadding; |
|
var _state8 = this.state, |
|
currentMonth = _state8.currentMonth, |
|
phrases = _state8.phrases, |
|
visibleDays = _state8.visibleDays; |
|
|
|
|
|
return _react2['default'].createElement(_DayPicker2['default'], { |
|
orientation: orientation, |
|
enableOutsideDays: enableOutsideDays, |
|
modifiers: visibleDays, |
|
numberOfMonths: numberOfMonths, |
|
onDayClick: this.onDayClick, |
|
onDayMouseEnter: this.onDayMouseEnter, |
|
onDayMouseLeave: this.onDayMouseLeave, |
|
onPrevMonthClick: this.onPrevMonthClick, |
|
onNextMonthClick: this.onNextMonthClick, |
|
onMonthChange: this.onMonthChange, |
|
onYearChange: this.onYearChange, |
|
onMultiplyScrollableMonths: this.onMultiplyScrollableMonths, |
|
monthFormat: monthFormat, |
|
renderMonthText: renderMonthText, |
|
withPortal: withPortal, |
|
hidden: !focusedInput, |
|
initialVisibleMonth: function () { |
|
function initialVisibleMonth() { |
|
return currentMonth; |
|
} |
|
|
|
return initialVisibleMonth; |
|
}(), |
|
daySize: daySize, |
|
onOutsideClick: onOutsideClick, |
|
navPrev: navPrev, |
|
navNext: navNext, |
|
noNavButtons: noNavButtons, |
|
renderCalendarDay: renderCalendarDay, |
|
renderDayContents: renderDayContents, |
|
renderCalendarInfo: renderCalendarInfo, |
|
renderMonthElement: renderMonthElement, |
|
calendarInfoPosition: calendarInfoPosition, |
|
firstDayOfWeek: firstDayOfWeek, |
|
hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel, |
|
isFocused: isFocused, |
|
getFirstFocusableDay: this.getFirstFocusableDay, |
|
onBlur: onBlur, |
|
showKeyboardShortcuts: showKeyboardShortcuts, |
|
phrases: phrases, |
|
isRTL: isRTL, |
|
weekDayFormat: weekDayFormat, |
|
dayAriaLabelFormat: dayAriaLabelFormat, |
|
verticalHeight: verticalHeight, |
|
verticalBorderSpacing: verticalBorderSpacing, |
|
noBorder: noBorder, |
|
transitionDuration: transitionDuration, |
|
horizontalMonthPadding: horizontalMonthPadding |
|
}); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return DayPickerRangeController; |
|
}(_react2['default'].Component); |
|
|
|
exports['default'] = DayPickerRangeController; |
|
|
|
|
|
DayPickerRangeController.propTypes = propTypes; |
|
DayPickerRangeController.defaultProps = defaultProps; |
|
|
|
/***/ }), |
|
/* 205 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = isNextDay; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _isSameDay = __webpack_require__(77); |
|
|
|
var _isSameDay2 = _interopRequireDefault(_isSameDay); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function isNextDay(a, b) { |
|
if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false; |
|
var nextDay = (0, _moment2['default'])(a).add(1, 'day'); |
|
return (0, _isSameDay2['default'])(nextDay, b); |
|
} |
|
|
|
/***/ }), |
|
/* 206 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = getVisibleDays; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _toISOMonthString = __webpack_require__(106); |
|
|
|
var _toISOMonthString2 = _interopRequireDefault(_toISOMonthString); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function getVisibleDays(month, numberOfMonths, enableOutsideDays, withoutTransitionMonths) { |
|
if (!_moment2['default'].isMoment(month)) return {}; |
|
|
|
var visibleDaysByMonth = {}; |
|
var currentMonth = withoutTransitionMonths ? month.clone() : month.clone().subtract(1, 'month'); |
|
for (var i = 0; i < (withoutTransitionMonths ? numberOfMonths : numberOfMonths + 2); i += 1) { |
|
var visibleDays = []; |
|
|
|
// set utc offset to get correct dates in future (when timezone changes) |
|
var baseDate = currentMonth.clone(); |
|
var firstOfMonth = baseDate.clone().startOf('month').hour(12); |
|
var lastOfMonth = baseDate.clone().endOf('month').hour(12); |
|
|
|
var currentDay = firstOfMonth.clone(); |
|
|
|
// days belonging to the previous month |
|
if (enableOutsideDays) { |
|
for (var j = 0; j < currentDay.weekday(); j += 1) { |
|
var prevDay = currentDay.clone().subtract(j + 1, 'day'); |
|
visibleDays.unshift(prevDay); |
|
} |
|
} |
|
|
|
while (currentDay < lastOfMonth) { |
|
visibleDays.push(currentDay.clone()); |
|
currentDay.add(1, 'day'); |
|
} |
|
|
|
if (enableOutsideDays) { |
|
// weekday() returns the index of the day of the week according to the locale |
|
// this means if the week starts on Monday, weekday() will return 0 for a Monday date, not 1 |
|
if (currentDay.weekday() !== 0) { |
|
// days belonging to the next month |
|
for (var k = currentDay.weekday(), count = 0; k < 7; k += 1, count += 1) { |
|
var nextDay = currentDay.clone().add(count, 'day'); |
|
visibleDays.push(nextDay); |
|
} |
|
} |
|
} |
|
|
|
visibleDaysByMonth[(0, _toISOMonthString2['default'])(currentMonth)] = visibleDays; |
|
currentMonth = currentMonth.clone().add(1, 'month'); |
|
} |
|
|
|
return visibleDaysByMonth; |
|
} |
|
|
|
/***/ }), |
|
/* 207 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _reactMomentProptypes = __webpack_require__(66); |
|
|
|
var _reactMomentProptypes2 = _interopRequireDefault(_reactMomentProptypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _object3 = __webpack_require__(135); |
|
|
|
var _object4 = _interopRequireDefault(_object3); |
|
|
|
var _isTouchDevice = __webpack_require__(80); |
|
|
|
var _isTouchDevice2 = _interopRequireDefault(_isTouchDevice); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _isSameDay = __webpack_require__(77); |
|
|
|
var _isSameDay2 = _interopRequireDefault(_isSameDay); |
|
|
|
var _isAfterDay = __webpack_require__(108); |
|
|
|
var _isAfterDay2 = _interopRequireDefault(_isAfterDay); |
|
|
|
var _getVisibleDays = __webpack_require__(206); |
|
|
|
var _getVisibleDays2 = _interopRequireDefault(_getVisibleDays); |
|
|
|
var _isDayVisible = __webpack_require__(140); |
|
|
|
var _isDayVisible2 = _interopRequireDefault(_isDayVisible); |
|
|
|
var _toISODateString = __webpack_require__(104); |
|
|
|
var _toISODateString2 = _interopRequireDefault(_toISODateString); |
|
|
|
var _toISOMonthString = __webpack_require__(106); |
|
|
|
var _toISOMonthString2 = _interopRequireDefault(_toISOMonthString); |
|
|
|
var _ScrollableOrientationShape = __webpack_require__(79); |
|
|
|
var _ScrollableOrientationShape2 = _interopRequireDefault(_ScrollableOrientationShape); |
|
|
|
var _DayOfWeekShape = __webpack_require__(73); |
|
|
|
var _DayOfWeekShape2 = _interopRequireDefault(_DayOfWeekShape); |
|
|
|
var _CalendarInfoPositionShape = __webpack_require__(93); |
|
|
|
var _CalendarInfoPositionShape2 = _interopRequireDefault(_CalendarInfoPositionShape); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
var _DayPicker = __webpack_require__(141); |
|
|
|
var _DayPicker2 = _interopRequireDefault(_DayPicker); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)({ |
|
date: _reactMomentProptypes2['default'].momentObj, |
|
onDateChange: _propTypes2['default'].func, |
|
|
|
focused: _propTypes2['default'].bool, |
|
onFocusChange: _propTypes2['default'].func, |
|
onClose: _propTypes2['default'].func, |
|
|
|
keepOpenOnDateSelect: _propTypes2['default'].bool, |
|
isOutsideRange: _propTypes2['default'].func, |
|
isDayBlocked: _propTypes2['default'].func, |
|
isDayHighlighted: _propTypes2['default'].func, |
|
|
|
// DayPicker props |
|
renderMonthText: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
renderMonthElement: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
enableOutsideDays: _propTypes2['default'].bool, |
|
numberOfMonths: _propTypes2['default'].number, |
|
orientation: _ScrollableOrientationShape2['default'], |
|
withPortal: _propTypes2['default'].bool, |
|
initialVisibleMonth: _propTypes2['default'].func, |
|
firstDayOfWeek: _DayOfWeekShape2['default'], |
|
hideKeyboardShortcutsPanel: _propTypes2['default'].bool, |
|
daySize: _airbnbPropTypes.nonNegativeInteger, |
|
verticalHeight: _airbnbPropTypes.nonNegativeInteger, |
|
noBorder: _propTypes2['default'].bool, |
|
verticalBorderSpacing: _airbnbPropTypes.nonNegativeInteger, |
|
transitionDuration: _airbnbPropTypes.nonNegativeInteger, |
|
horizontalMonthPadding: _airbnbPropTypes.nonNegativeInteger, |
|
|
|
navPrev: _propTypes2['default'].node, |
|
navNext: _propTypes2['default'].node, |
|
|
|
onPrevMonthClick: _propTypes2['default'].func, |
|
onNextMonthClick: _propTypes2['default'].func, |
|
onOutsideClick: _propTypes2['default'].func, |
|
renderCalendarDay: _propTypes2['default'].func, |
|
renderDayContents: _propTypes2['default'].func, |
|
renderCalendarInfo: _propTypes2['default'].func, |
|
calendarInfoPosition: _CalendarInfoPositionShape2['default'], |
|
|
|
// accessibility |
|
onBlur: _propTypes2['default'].func, |
|
isFocused: _propTypes2['default'].bool, |
|
showKeyboardShortcuts: _propTypes2['default'].bool, |
|
|
|
// i18n |
|
monthFormat: _propTypes2['default'].string, |
|
weekDayFormat: _propTypes2['default'].string, |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.DayPickerPhrases)), |
|
dayAriaLabelFormat: _propTypes2['default'].string, |
|
|
|
isRTL: _propTypes2['default'].bool |
|
}); |
|
|
|
var defaultProps = { |
|
date: undefined, // TODO: use null |
|
onDateChange: function () { |
|
function onDateChange() {} |
|
|
|
return onDateChange; |
|
}(), |
|
|
|
|
|
focused: false, |
|
onFocusChange: function () { |
|
function onFocusChange() {} |
|
|
|
return onFocusChange; |
|
}(), |
|
onClose: function () { |
|
function onClose() {} |
|
|
|
return onClose; |
|
}(), |
|
|
|
|
|
keepOpenOnDateSelect: false, |
|
isOutsideRange: function () { |
|
function isOutsideRange() {} |
|
|
|
return isOutsideRange; |
|
}(), |
|
isDayBlocked: function () { |
|
function isDayBlocked() {} |
|
|
|
return isDayBlocked; |
|
}(), |
|
isDayHighlighted: function () { |
|
function isDayHighlighted() {} |
|
|
|
return isDayHighlighted; |
|
}(), |
|
|
|
|
|
// DayPicker props |
|
renderMonthText: null, |
|
enableOutsideDays: false, |
|
numberOfMonths: 1, |
|
orientation: _constants.HORIZONTAL_ORIENTATION, |
|
withPortal: false, |
|
hideKeyboardShortcutsPanel: false, |
|
initialVisibleMonth: null, |
|
firstDayOfWeek: null, |
|
daySize: _constants.DAY_SIZE, |
|
verticalHeight: null, |
|
noBorder: false, |
|
verticalBorderSpacing: undefined, |
|
transitionDuration: undefined, |
|
horizontalMonthPadding: 13, |
|
|
|
navPrev: null, |
|
navNext: null, |
|
|
|
onPrevMonthClick: function () { |
|
function onPrevMonthClick() {} |
|
|
|
return onPrevMonthClick; |
|
}(), |
|
onNextMonthClick: function () { |
|
function onNextMonthClick() {} |
|
|
|
return onNextMonthClick; |
|
}(), |
|
onOutsideClick: function () { |
|
function onOutsideClick() {} |
|
|
|
return onOutsideClick; |
|
}(), |
|
|
|
|
|
renderCalendarDay: undefined, |
|
renderDayContents: null, |
|
renderCalendarInfo: null, |
|
renderMonthElement: null, |
|
calendarInfoPosition: _constants.INFO_POSITION_BOTTOM, |
|
|
|
// accessibility |
|
onBlur: function () { |
|
function onBlur() {} |
|
|
|
return onBlur; |
|
}(), |
|
|
|
isFocused: false, |
|
showKeyboardShortcuts: false, |
|
|
|
// i18n |
|
monthFormat: 'MMMM YYYY', |
|
weekDayFormat: 'dd', |
|
phrases: _defaultPhrases.DayPickerPhrases, |
|
dayAriaLabelFormat: undefined, |
|
|
|
isRTL: false |
|
}; |
|
|
|
var DayPickerSingleDateController = function (_React$Component) { |
|
_inherits(DayPickerSingleDateController, _React$Component); |
|
|
|
function DayPickerSingleDateController(props) { |
|
_classCallCheck(this, DayPickerSingleDateController); |
|
|
|
var _this = _possibleConstructorReturn(this, (DayPickerSingleDateController.__proto__ || Object.getPrototypeOf(DayPickerSingleDateController)).call(this, props)); |
|
|
|
_this.isTouchDevice = false; |
|
_this.today = (0, _moment2['default'])(); |
|
|
|
_this.modifiers = { |
|
today: function () { |
|
function today(day) { |
|
return _this.isToday(day); |
|
} |
|
|
|
return today; |
|
}(), |
|
blocked: function () { |
|
function blocked(day) { |
|
return _this.isBlocked(day); |
|
} |
|
|
|
return blocked; |
|
}(), |
|
'blocked-calendar': function () { |
|
function blockedCalendar(day) { |
|
return props.isDayBlocked(day); |
|
} |
|
|
|
return blockedCalendar; |
|
}(), |
|
'blocked-out-of-range': function () { |
|
function blockedOutOfRange(day) { |
|
return props.isOutsideRange(day); |
|
} |
|
|
|
return blockedOutOfRange; |
|
}(), |
|
'highlighted-calendar': function () { |
|
function highlightedCalendar(day) { |
|
return props.isDayHighlighted(day); |
|
} |
|
|
|
return highlightedCalendar; |
|
}(), |
|
valid: function () { |
|
function valid(day) { |
|
return !_this.isBlocked(day); |
|
} |
|
|
|
return valid; |
|
}(), |
|
hovered: function () { |
|
function hovered(day) { |
|
return _this.isHovered(day); |
|
} |
|
|
|
return hovered; |
|
}(), |
|
selected: function () { |
|
function selected(day) { |
|
return _this.isSelected(day); |
|
} |
|
|
|
return selected; |
|
}(), |
|
'first-day-of-week': function () { |
|
function firstDayOfWeek(day) { |
|
return _this.isFirstDayOfWeek(day); |
|
} |
|
|
|
return firstDayOfWeek; |
|
}(), |
|
'last-day-of-week': function () { |
|
function lastDayOfWeek(day) { |
|
return _this.isLastDayOfWeek(day); |
|
} |
|
|
|
return lastDayOfWeek; |
|
}() |
|
}; |
|
|
|
var _this$getStateForNewM = _this.getStateForNewMonth(props), |
|
currentMonth = _this$getStateForNewM.currentMonth, |
|
visibleDays = _this$getStateForNewM.visibleDays; |
|
|
|
_this.state = { |
|
hoverDate: null, |
|
currentMonth: currentMonth, |
|
visibleDays: visibleDays |
|
}; |
|
|
|
_this.onDayMouseEnter = _this.onDayMouseEnter.bind(_this); |
|
_this.onDayMouseLeave = _this.onDayMouseLeave.bind(_this); |
|
_this.onDayClick = _this.onDayClick.bind(_this); |
|
|
|
_this.onPrevMonthClick = _this.onPrevMonthClick.bind(_this); |
|
_this.onNextMonthClick = _this.onNextMonthClick.bind(_this); |
|
_this.onMonthChange = _this.onMonthChange.bind(_this); |
|
_this.onYearChange = _this.onYearChange.bind(_this); |
|
|
|
_this.getFirstFocusableDay = _this.getFirstFocusableDay.bind(_this); |
|
return _this; |
|
} |
|
|
|
_createClass(DayPickerSingleDateController, [{ |
|
key: 'componentDidMount', |
|
value: function () { |
|
function componentDidMount() { |
|
this.isTouchDevice = (0, _isTouchDevice2['default'])(); |
|
} |
|
|
|
return componentDidMount; |
|
}() |
|
}, { |
|
key: 'componentWillReceiveProps', |
|
value: function () { |
|
function componentWillReceiveProps(nextProps) { |
|
var _this2 = this; |
|
|
|
var date = nextProps.date, |
|
focused = nextProps.focused, |
|
isOutsideRange = nextProps.isOutsideRange, |
|
isDayBlocked = nextProps.isDayBlocked, |
|
isDayHighlighted = nextProps.isDayHighlighted, |
|
initialVisibleMonth = nextProps.initialVisibleMonth, |
|
numberOfMonths = nextProps.numberOfMonths, |
|
enableOutsideDays = nextProps.enableOutsideDays; |
|
var _props = this.props, |
|
prevIsOutsideRange = _props.isOutsideRange, |
|
prevIsDayBlocked = _props.isDayBlocked, |
|
prevIsDayHighlighted = _props.isDayHighlighted, |
|
prevNumberOfMonths = _props.numberOfMonths, |
|
prevEnableOutsideDays = _props.enableOutsideDays, |
|
prevInitialVisibleMonth = _props.initialVisibleMonth, |
|
prevFocused = _props.focused, |
|
prevDate = _props.date; |
|
var visibleDays = this.state.visibleDays; |
|
|
|
|
|
var recomputeOutsideRange = false; |
|
var recomputeDayBlocked = false; |
|
var recomputeDayHighlighted = false; |
|
|
|
if (isOutsideRange !== prevIsOutsideRange) { |
|
this.modifiers['blocked-out-of-range'] = function (day) { |
|
return isOutsideRange(day); |
|
}; |
|
recomputeOutsideRange = true; |
|
} |
|
|
|
if (isDayBlocked !== prevIsDayBlocked) { |
|
this.modifiers['blocked-calendar'] = function (day) { |
|
return isDayBlocked(day); |
|
}; |
|
recomputeDayBlocked = true; |
|
} |
|
|
|
if (isDayHighlighted !== prevIsDayHighlighted) { |
|
this.modifiers['highlighted-calendar'] = function (day) { |
|
return isDayHighlighted(day); |
|
}; |
|
recomputeDayHighlighted = true; |
|
} |
|
|
|
var recomputePropModifiers = recomputeOutsideRange || recomputeDayBlocked || recomputeDayHighlighted; |
|
|
|
if (numberOfMonths !== prevNumberOfMonths || enableOutsideDays !== prevEnableOutsideDays || initialVisibleMonth !== prevInitialVisibleMonth && !prevFocused && focused) { |
|
var newMonthState = this.getStateForNewMonth(nextProps); |
|
var currentMonth = newMonthState.currentMonth; |
|
visibleDays = newMonthState.visibleDays; |
|
|
|
this.setState({ |
|
currentMonth: currentMonth, |
|
visibleDays: visibleDays |
|
}); |
|
} |
|
|
|
var didDateChange = date !== prevDate; |
|
var didFocusChange = focused !== prevFocused; |
|
|
|
var modifiers = {}; |
|
|
|
if (didDateChange) { |
|
modifiers = this.deleteModifier(modifiers, prevDate, 'selected'); |
|
modifiers = this.addModifier(modifiers, date, 'selected'); |
|
} |
|
|
|
if (didFocusChange || recomputePropModifiers) { |
|
(0, _object4['default'])(visibleDays).forEach(function (days) { |
|
Object.keys(days).forEach(function (day) { |
|
var momentObj = (0, _moment2['default'])(day); |
|
if (_this2.isBlocked(momentObj)) { |
|
modifiers = _this2.addModifier(modifiers, momentObj, 'blocked'); |
|
} else { |
|
modifiers = _this2.deleteModifier(modifiers, momentObj, 'blocked'); |
|
} |
|
|
|
if (didFocusChange || recomputeOutsideRange) { |
|
if (isOutsideRange(momentObj)) { |
|
modifiers = _this2.addModifier(modifiers, momentObj, 'blocked-out-of-range'); |
|
} else { |
|
modifiers = _this2.deleteModifier(modifiers, momentObj, 'blocked-out-of-range'); |
|
} |
|
} |
|
|
|
if (didFocusChange || recomputeDayBlocked) { |
|
if (isDayBlocked(momentObj)) { |
|
modifiers = _this2.addModifier(modifiers, momentObj, 'blocked-calendar'); |
|
} else { |
|
modifiers = _this2.deleteModifier(modifiers, momentObj, 'blocked-calendar'); |
|
} |
|
} |
|
|
|
if (didFocusChange || recomputeDayHighlighted) { |
|
if (isDayHighlighted(momentObj)) { |
|
modifiers = _this2.addModifier(modifiers, momentObj, 'highlighted-calendar'); |
|
} else { |
|
modifiers = _this2.deleteModifier(modifiers, momentObj, 'highlighted-calendar'); |
|
} |
|
} |
|
}); |
|
}); |
|
} |
|
|
|
var today = (0, _moment2['default'])(); |
|
if (!(0, _isSameDay2['default'])(this.today, today)) { |
|
modifiers = this.deleteModifier(modifiers, this.today, 'today'); |
|
modifiers = this.addModifier(modifiers, today, 'today'); |
|
this.today = today; |
|
} |
|
|
|
if (Object.keys(modifiers).length > 0) { |
|
this.setState({ |
|
visibleDays: (0, _object2['default'])({}, visibleDays, modifiers) |
|
}); |
|
} |
|
} |
|
|
|
return componentWillReceiveProps; |
|
}() |
|
}, { |
|
key: 'componentWillUpdate', |
|
value: function () { |
|
function componentWillUpdate() { |
|
this.today = (0, _moment2['default'])(); |
|
} |
|
|
|
return componentWillUpdate; |
|
}() |
|
}, { |
|
key: 'onDayClick', |
|
value: function () { |
|
function onDayClick(day, e) { |
|
if (e) e.preventDefault(); |
|
if (this.isBlocked(day)) return; |
|
var _props2 = this.props, |
|
onDateChange = _props2.onDateChange, |
|
keepOpenOnDateSelect = _props2.keepOpenOnDateSelect, |
|
onFocusChange = _props2.onFocusChange, |
|
onClose = _props2.onClose; |
|
|
|
|
|
onDateChange(day); |
|
if (!keepOpenOnDateSelect) { |
|
onFocusChange({ focused: false }); |
|
onClose({ date: day }); |
|
} |
|
} |
|
|
|
return onDayClick; |
|
}() |
|
}, { |
|
key: 'onDayMouseEnter', |
|
value: function () { |
|
function onDayMouseEnter(day) { |
|
if (this.isTouchDevice) return; |
|
var _state = this.state, |
|
hoverDate = _state.hoverDate, |
|
visibleDays = _state.visibleDays; |
|
|
|
|
|
var modifiers = this.deleteModifier({}, hoverDate, 'hovered'); |
|
modifiers = this.addModifier(modifiers, day, 'hovered'); |
|
|
|
this.setState({ |
|
hoverDate: day, |
|
visibleDays: (0, _object2['default'])({}, visibleDays, modifiers) |
|
}); |
|
} |
|
|
|
return onDayMouseEnter; |
|
}() |
|
}, { |
|
key: 'onDayMouseLeave', |
|
value: function () { |
|
function onDayMouseLeave() { |
|
var _state2 = this.state, |
|
hoverDate = _state2.hoverDate, |
|
visibleDays = _state2.visibleDays; |
|
|
|
if (this.isTouchDevice || !hoverDate) return; |
|
|
|
var modifiers = this.deleteModifier({}, hoverDate, 'hovered'); |
|
|
|
this.setState({ |
|
hoverDate: null, |
|
visibleDays: (0, _object2['default'])({}, visibleDays, modifiers) |
|
}); |
|
} |
|
|
|
return onDayMouseLeave; |
|
}() |
|
}, { |
|
key: 'onPrevMonthClick', |
|
value: function () { |
|
function onPrevMonthClick() { |
|
var _props3 = this.props, |
|
onPrevMonthClick = _props3.onPrevMonthClick, |
|
numberOfMonths = _props3.numberOfMonths, |
|
enableOutsideDays = _props3.enableOutsideDays; |
|
var _state3 = this.state, |
|
currentMonth = _state3.currentMonth, |
|
visibleDays = _state3.visibleDays; |
|
|
|
|
|
var newVisibleDays = {}; |
|
Object.keys(visibleDays).sort().slice(0, numberOfMonths + 1).forEach(function (month) { |
|
newVisibleDays[month] = visibleDays[month]; |
|
}); |
|
|
|
var prevMonth = currentMonth.clone().subtract(1, 'month'); |
|
var prevMonthVisibleDays = (0, _getVisibleDays2['default'])(prevMonth, 1, enableOutsideDays); |
|
|
|
this.setState({ |
|
currentMonth: prevMonth, |
|
visibleDays: (0, _object2['default'])({}, newVisibleDays, this.getModifiers(prevMonthVisibleDays)) |
|
}, function () { |
|
onPrevMonthClick(prevMonth.clone()); |
|
}); |
|
} |
|
|
|
return onPrevMonthClick; |
|
}() |
|
}, { |
|
key: 'onNextMonthClick', |
|
value: function () { |
|
function onNextMonthClick() { |
|
var _props4 = this.props, |
|
onNextMonthClick = _props4.onNextMonthClick, |
|
numberOfMonths = _props4.numberOfMonths, |
|
enableOutsideDays = _props4.enableOutsideDays; |
|
var _state4 = this.state, |
|
currentMonth = _state4.currentMonth, |
|
visibleDays = _state4.visibleDays; |
|
|
|
|
|
var newVisibleDays = {}; |
|
Object.keys(visibleDays).sort().slice(1).forEach(function (month) { |
|
newVisibleDays[month] = visibleDays[month]; |
|
}); |
|
|
|
var nextMonth = currentMonth.clone().add(numberOfMonths, 'month'); |
|
var nextMonthVisibleDays = (0, _getVisibleDays2['default'])(nextMonth, 1, enableOutsideDays); |
|
|
|
var newCurrentMonth = currentMonth.clone().add(1, 'month'); |
|
this.setState({ |
|
currentMonth: newCurrentMonth, |
|
visibleDays: (0, _object2['default'])({}, newVisibleDays, this.getModifiers(nextMonthVisibleDays)) |
|
}, function () { |
|
onNextMonthClick(newCurrentMonth.clone()); |
|
}); |
|
} |
|
|
|
return onNextMonthClick; |
|
}() |
|
}, { |
|
key: 'onMonthChange', |
|
value: function () { |
|
function onMonthChange(newMonth) { |
|
var _props5 = this.props, |
|
numberOfMonths = _props5.numberOfMonths, |
|
enableOutsideDays = _props5.enableOutsideDays, |
|
orientation = _props5.orientation; |
|
|
|
var withoutTransitionMonths = orientation === _constants.VERTICAL_SCROLLABLE; |
|
var newVisibleDays = (0, _getVisibleDays2['default'])(newMonth, numberOfMonths, enableOutsideDays, withoutTransitionMonths); |
|
|
|
this.setState({ |
|
currentMonth: newMonth.clone(), |
|
visibleDays: this.getModifiers(newVisibleDays) |
|
}); |
|
} |
|
|
|
return onMonthChange; |
|
}() |
|
}, { |
|
key: 'onYearChange', |
|
value: function () { |
|
function onYearChange(newMonth) { |
|
var _props6 = this.props, |
|
numberOfMonths = _props6.numberOfMonths, |
|
enableOutsideDays = _props6.enableOutsideDays, |
|
orientation = _props6.orientation; |
|
|
|
var withoutTransitionMonths = orientation === _constants.VERTICAL_SCROLLABLE; |
|
var newVisibleDays = (0, _getVisibleDays2['default'])(newMonth, numberOfMonths, enableOutsideDays, withoutTransitionMonths); |
|
|
|
this.setState({ |
|
currentMonth: newMonth.clone(), |
|
visibleDays: this.getModifiers(newVisibleDays) |
|
}); |
|
} |
|
|
|
return onYearChange; |
|
}() |
|
}, { |
|
key: 'getFirstFocusableDay', |
|
value: function () { |
|
function getFirstFocusableDay(newMonth) { |
|
var _this3 = this; |
|
|
|
var _props7 = this.props, |
|
date = _props7.date, |
|
numberOfMonths = _props7.numberOfMonths; |
|
|
|
|
|
var focusedDate = newMonth.clone().startOf('month'); |
|
if (date) { |
|
focusedDate = date.clone(); |
|
} |
|
|
|
if (this.isBlocked(focusedDate)) { |
|
var days = []; |
|
var lastVisibleDay = newMonth.clone().add(numberOfMonths - 1, 'months').endOf('month'); |
|
var currentDay = focusedDate.clone(); |
|
while (!(0, _isAfterDay2['default'])(currentDay, lastVisibleDay)) { |
|
currentDay = currentDay.clone().add(1, 'day'); |
|
days.push(currentDay); |
|
} |
|
|
|
var viableDays = days.filter(function (day) { |
|
return !_this3.isBlocked(day) && (0, _isAfterDay2['default'])(day, focusedDate); |
|
}); |
|
if (viableDays.length > 0) { |
|
var _viableDays = _slicedToArray(viableDays, 1); |
|
|
|
focusedDate = _viableDays[0]; |
|
} |
|
} |
|
|
|
return focusedDate; |
|
} |
|
|
|
return getFirstFocusableDay; |
|
}() |
|
}, { |
|
key: 'getModifiers', |
|
value: function () { |
|
function getModifiers(visibleDays) { |
|
var _this4 = this; |
|
|
|
var modifiers = {}; |
|
Object.keys(visibleDays).forEach(function (month) { |
|
modifiers[month] = {}; |
|
visibleDays[month].forEach(function (day) { |
|
modifiers[month][(0, _toISODateString2['default'])(day)] = _this4.getModifiersForDay(day); |
|
}); |
|
}); |
|
|
|
return modifiers; |
|
} |
|
|
|
return getModifiers; |
|
}() |
|
}, { |
|
key: 'getModifiersForDay', |
|
value: function () { |
|
function getModifiersForDay(day) { |
|
var _this5 = this; |
|
|
|
return new Set(Object.keys(this.modifiers).filter(function (modifier) { |
|
return _this5.modifiers[modifier](day); |
|
})); |
|
} |
|
|
|
return getModifiersForDay; |
|
}() |
|
}, { |
|
key: 'getStateForNewMonth', |
|
value: function () { |
|
function getStateForNewMonth(nextProps) { |
|
var _this6 = this; |
|
|
|
var initialVisibleMonth = nextProps.initialVisibleMonth, |
|
date = nextProps.date, |
|
numberOfMonths = nextProps.numberOfMonths, |
|
enableOutsideDays = nextProps.enableOutsideDays; |
|
|
|
var initialVisibleMonthThunk = initialVisibleMonth || (date ? function () { |
|
return date; |
|
} : function () { |
|
return _this6.today; |
|
}); |
|
var currentMonth = initialVisibleMonthThunk(); |
|
var visibleDays = this.getModifiers((0, _getVisibleDays2['default'])(currentMonth, numberOfMonths, enableOutsideDays)); |
|
return { currentMonth: currentMonth, visibleDays: visibleDays }; |
|
} |
|
|
|
return getStateForNewMonth; |
|
}() |
|
}, { |
|
key: 'addModifier', |
|
value: function () { |
|
function addModifier(updatedDays, day, modifier) { |
|
var _props8 = this.props, |
|
numberOfVisibleMonths = _props8.numberOfMonths, |
|
enableOutsideDays = _props8.enableOutsideDays, |
|
orientation = _props8.orientation; |
|
var _state5 = this.state, |
|
firstVisibleMonth = _state5.currentMonth, |
|
visibleDays = _state5.visibleDays; |
|
|
|
|
|
var currentMonth = firstVisibleMonth; |
|
var numberOfMonths = numberOfVisibleMonths; |
|
if (orientation === _constants.VERTICAL_SCROLLABLE) { |
|
numberOfMonths = Object.keys(visibleDays).length; |
|
} else { |
|
currentMonth = currentMonth.clone().subtract(1, 'month'); |
|
numberOfMonths += 2; |
|
} |
|
if (!day || !(0, _isDayVisible2['default'])(day, currentMonth, numberOfMonths, enableOutsideDays)) { |
|
return updatedDays; |
|
} |
|
|
|
var iso = (0, _toISODateString2['default'])(day); |
|
|
|
var updatedDaysAfterAddition = (0, _object2['default'])({}, updatedDays); |
|
if (enableOutsideDays) { |
|
var monthsToUpdate = Object.keys(visibleDays).filter(function (monthKey) { |
|
return Object.keys(visibleDays[monthKey]).indexOf(iso) > -1; |
|
}); |
|
|
|
updatedDaysAfterAddition = monthsToUpdate.reduce(function (days, monthIso) { |
|
var month = updatedDays[monthIso] || visibleDays[monthIso]; |
|
var modifiers = new Set(month[iso]); |
|
modifiers.add(modifier); |
|
return (0, _object2['default'])({}, days, _defineProperty({}, monthIso, (0, _object2['default'])({}, month, _defineProperty({}, iso, modifiers)))); |
|
}, updatedDaysAfterAddition); |
|
} else { |
|
var monthIso = (0, _toISOMonthString2['default'])(day); |
|
var month = updatedDays[monthIso] || visibleDays[monthIso]; |
|
|
|
var modifiers = new Set(month[iso]); |
|
modifiers.add(modifier); |
|
updatedDaysAfterAddition = (0, _object2['default'])({}, updatedDaysAfterAddition, _defineProperty({}, monthIso, (0, _object2['default'])({}, month, _defineProperty({}, iso, modifiers)))); |
|
} |
|
|
|
return updatedDaysAfterAddition; |
|
} |
|
|
|
return addModifier; |
|
}() |
|
}, { |
|
key: 'deleteModifier', |
|
value: function () { |
|
function deleteModifier(updatedDays, day, modifier) { |
|
var _props9 = this.props, |
|
numberOfVisibleMonths = _props9.numberOfMonths, |
|
enableOutsideDays = _props9.enableOutsideDays, |
|
orientation = _props9.orientation; |
|
var _state6 = this.state, |
|
firstVisibleMonth = _state6.currentMonth, |
|
visibleDays = _state6.visibleDays; |
|
|
|
|
|
var currentMonth = firstVisibleMonth; |
|
var numberOfMonths = numberOfVisibleMonths; |
|
if (orientation === _constants.VERTICAL_SCROLLABLE) { |
|
numberOfMonths = Object.keys(visibleDays).length; |
|
} else { |
|
currentMonth = currentMonth.clone().subtract(1, 'month'); |
|
numberOfMonths += 2; |
|
} |
|
if (!day || !(0, _isDayVisible2['default'])(day, currentMonth, numberOfMonths, enableOutsideDays)) { |
|
return updatedDays; |
|
} |
|
|
|
var iso = (0, _toISODateString2['default'])(day); |
|
|
|
var updatedDaysAfterDeletion = (0, _object2['default'])({}, updatedDays); |
|
if (enableOutsideDays) { |
|
var monthsToUpdate = Object.keys(visibleDays).filter(function (monthKey) { |
|
return Object.keys(visibleDays[monthKey]).indexOf(iso) > -1; |
|
}); |
|
|
|
updatedDaysAfterDeletion = monthsToUpdate.reduce(function (days, monthIso) { |
|
var month = updatedDays[monthIso] || visibleDays[monthIso]; |
|
var modifiers = new Set(month[iso]); |
|
modifiers['delete'](modifier); |
|
return (0, _object2['default'])({}, days, _defineProperty({}, monthIso, (0, _object2['default'])({}, month, _defineProperty({}, iso, modifiers)))); |
|
}, updatedDaysAfterDeletion); |
|
} else { |
|
var monthIso = (0, _toISOMonthString2['default'])(day); |
|
var month = updatedDays[monthIso] || visibleDays[monthIso]; |
|
|
|
var modifiers = new Set(month[iso]); |
|
modifiers['delete'](modifier); |
|
updatedDaysAfterDeletion = (0, _object2['default'])({}, updatedDaysAfterDeletion, _defineProperty({}, monthIso, (0, _object2['default'])({}, month, _defineProperty({}, iso, modifiers)))); |
|
} |
|
|
|
return updatedDaysAfterDeletion; |
|
} |
|
|
|
return deleteModifier; |
|
}() |
|
}, { |
|
key: 'isBlocked', |
|
value: function () { |
|
function isBlocked(day) { |
|
var _props10 = this.props, |
|
isDayBlocked = _props10.isDayBlocked, |
|
isOutsideRange = _props10.isOutsideRange; |
|
|
|
return isDayBlocked(day) || isOutsideRange(day); |
|
} |
|
|
|
return isBlocked; |
|
}() |
|
}, { |
|
key: 'isHovered', |
|
value: function () { |
|
function isHovered(day) { |
|
var _ref = this.state || {}, |
|
hoverDate = _ref.hoverDate; |
|
|
|
return (0, _isSameDay2['default'])(day, hoverDate); |
|
} |
|
|
|
return isHovered; |
|
}() |
|
}, { |
|
key: 'isSelected', |
|
value: function () { |
|
function isSelected(day) { |
|
var date = this.props.date; |
|
|
|
return (0, _isSameDay2['default'])(day, date); |
|
} |
|
|
|
return isSelected; |
|
}() |
|
}, { |
|
key: 'isToday', |
|
value: function () { |
|
function isToday(day) { |
|
return (0, _isSameDay2['default'])(day, this.today); |
|
} |
|
|
|
return isToday; |
|
}() |
|
}, { |
|
key: 'isFirstDayOfWeek', |
|
value: function () { |
|
function isFirstDayOfWeek(day) { |
|
var firstDayOfWeek = this.props.firstDayOfWeek; |
|
|
|
return day.day() === (firstDayOfWeek || _moment2['default'].localeData().firstDayOfWeek()); |
|
} |
|
|
|
return isFirstDayOfWeek; |
|
}() |
|
}, { |
|
key: 'isLastDayOfWeek', |
|
value: function () { |
|
function isLastDayOfWeek(day) { |
|
var firstDayOfWeek = this.props.firstDayOfWeek; |
|
|
|
return day.day() === ((firstDayOfWeek || _moment2['default'].localeData().firstDayOfWeek()) + 6) % 7; |
|
} |
|
|
|
return isLastDayOfWeek; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _props11 = this.props, |
|
numberOfMonths = _props11.numberOfMonths, |
|
orientation = _props11.orientation, |
|
monthFormat = _props11.monthFormat, |
|
renderMonthText = _props11.renderMonthText, |
|
navPrev = _props11.navPrev, |
|
navNext = _props11.navNext, |
|
onOutsideClick = _props11.onOutsideClick, |
|
withPortal = _props11.withPortal, |
|
focused = _props11.focused, |
|
enableOutsideDays = _props11.enableOutsideDays, |
|
hideKeyboardShortcutsPanel = _props11.hideKeyboardShortcutsPanel, |
|
daySize = _props11.daySize, |
|
firstDayOfWeek = _props11.firstDayOfWeek, |
|
renderCalendarDay = _props11.renderCalendarDay, |
|
renderDayContents = _props11.renderDayContents, |
|
renderCalendarInfo = _props11.renderCalendarInfo, |
|
renderMonthElement = _props11.renderMonthElement, |
|
calendarInfoPosition = _props11.calendarInfoPosition, |
|
isFocused = _props11.isFocused, |
|
isRTL = _props11.isRTL, |
|
phrases = _props11.phrases, |
|
dayAriaLabelFormat = _props11.dayAriaLabelFormat, |
|
onBlur = _props11.onBlur, |
|
showKeyboardShortcuts = _props11.showKeyboardShortcuts, |
|
weekDayFormat = _props11.weekDayFormat, |
|
verticalHeight = _props11.verticalHeight, |
|
noBorder = _props11.noBorder, |
|
transitionDuration = _props11.transitionDuration, |
|
verticalBorderSpacing = _props11.verticalBorderSpacing, |
|
horizontalMonthPadding = _props11.horizontalMonthPadding; |
|
var _state7 = this.state, |
|
currentMonth = _state7.currentMonth, |
|
visibleDays = _state7.visibleDays; |
|
|
|
|
|
return _react2['default'].createElement(_DayPicker2['default'], { |
|
orientation: orientation, |
|
enableOutsideDays: enableOutsideDays, |
|
modifiers: visibleDays, |
|
numberOfMonths: numberOfMonths, |
|
onDayClick: this.onDayClick, |
|
onDayMouseEnter: this.onDayMouseEnter, |
|
onDayMouseLeave: this.onDayMouseLeave, |
|
onPrevMonthClick: this.onPrevMonthClick, |
|
onNextMonthClick: this.onNextMonthClick, |
|
onMonthChange: this.onMonthChange, |
|
onYearChange: this.onYearChange, |
|
monthFormat: monthFormat, |
|
withPortal: withPortal, |
|
hidden: !focused, |
|
hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel, |
|
initialVisibleMonth: function () { |
|
function initialVisibleMonth() { |
|
return currentMonth; |
|
} |
|
|
|
return initialVisibleMonth; |
|
}(), |
|
firstDayOfWeek: firstDayOfWeek, |
|
onOutsideClick: onOutsideClick, |
|
navPrev: navPrev, |
|
navNext: navNext, |
|
renderMonthText: renderMonthText, |
|
renderCalendarDay: renderCalendarDay, |
|
renderDayContents: renderDayContents, |
|
renderCalendarInfo: renderCalendarInfo, |
|
renderMonthElement: renderMonthElement, |
|
calendarInfoPosition: calendarInfoPosition, |
|
isFocused: isFocused, |
|
getFirstFocusableDay: this.getFirstFocusableDay, |
|
onBlur: onBlur, |
|
phrases: phrases, |
|
daySize: daySize, |
|
isRTL: isRTL, |
|
showKeyboardShortcuts: showKeyboardShortcuts, |
|
weekDayFormat: weekDayFormat, |
|
dayAriaLabelFormat: dayAriaLabelFormat, |
|
verticalHeight: verticalHeight, |
|
noBorder: noBorder, |
|
transitionDuration: transitionDuration, |
|
verticalBorderSpacing: verticalBorderSpacing, |
|
horizontalMonthPadding: horizontalMonthPadding |
|
}); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return DayPickerSingleDateController; |
|
}(_react2['default'].Component); |
|
|
|
exports['default'] = DayPickerSingleDateController; |
|
|
|
|
|
DayPickerSingleDateController.propTypes = propTypes; |
|
DayPickerSingleDateController.defaultProps = defaultProps; |
|
|
|
/***/ }), |
|
/* 208 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _reactMomentProptypes = __webpack_require__(66); |
|
|
|
var _reactMomentProptypes2 = _interopRequireDefault(_reactMomentProptypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _IconPositionShape = __webpack_require__(92); |
|
|
|
var _IconPositionShape2 = _interopRequireDefault(_IconPositionShape); |
|
|
|
var _OrientationShape = __webpack_require__(190); |
|
|
|
var _OrientationShape2 = _interopRequireDefault(_OrientationShape); |
|
|
|
var _AnchorDirectionShape = __webpack_require__(191); |
|
|
|
var _AnchorDirectionShape2 = _interopRequireDefault(_AnchorDirectionShape); |
|
|
|
var _OpenDirectionShape = __webpack_require__(81); |
|
|
|
var _OpenDirectionShape2 = _interopRequireDefault(_OpenDirectionShape); |
|
|
|
var _DayOfWeekShape = __webpack_require__(73); |
|
|
|
var _DayOfWeekShape2 = _interopRequireDefault(_DayOfWeekShape); |
|
|
|
var _CalendarInfoPositionShape = __webpack_require__(93); |
|
|
|
var _CalendarInfoPositionShape2 = _interopRequireDefault(_CalendarInfoPositionShape); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
exports['default'] = { |
|
// required props for a functional interactive SingleDatePicker |
|
date: _reactMomentProptypes2['default'].momentObj, |
|
onDateChange: _propTypes2['default'].func.isRequired, |
|
|
|
focused: _propTypes2['default'].bool, |
|
onFocusChange: _propTypes2['default'].func.isRequired, |
|
|
|
// input related props |
|
id: _propTypes2['default'].string.isRequired, |
|
placeholder: _propTypes2['default'].string, |
|
disabled: _propTypes2['default'].bool, |
|
required: _propTypes2['default'].bool, |
|
readOnly: _propTypes2['default'].bool, |
|
screenReaderInputMessage: _propTypes2['default'].string, |
|
showClearDate: _propTypes2['default'].bool, |
|
customCloseIcon: _propTypes2['default'].node, |
|
showDefaultInputIcon: _propTypes2['default'].bool, |
|
inputIconPosition: _IconPositionShape2['default'], |
|
customInputIcon: _propTypes2['default'].node, |
|
noBorder: _propTypes2['default'].bool, |
|
block: _propTypes2['default'].bool, |
|
small: _propTypes2['default'].bool, |
|
regular: _propTypes2['default'].bool, |
|
verticalSpacing: _airbnbPropTypes.nonNegativeInteger, |
|
keepFocusOnInput: _propTypes2['default'].bool, |
|
|
|
// calendar presentation and interaction related props |
|
renderMonthText: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
renderMonthElement: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'), |
|
orientation: _OrientationShape2['default'], |
|
anchorDirection: _AnchorDirectionShape2['default'], |
|
openDirection: _OpenDirectionShape2['default'], |
|
horizontalMargin: _propTypes2['default'].number, |
|
withPortal: _propTypes2['default'].bool, |
|
withFullScreenPortal: _propTypes2['default'].bool, |
|
appendToBody: _propTypes2['default'].bool, |
|
disableScroll: _propTypes2['default'].bool, |
|
initialVisibleMonth: _propTypes2['default'].func, |
|
firstDayOfWeek: _DayOfWeekShape2['default'], |
|
numberOfMonths: _propTypes2['default'].number, |
|
keepOpenOnDateSelect: _propTypes2['default'].bool, |
|
reopenPickerOnClearDate: _propTypes2['default'].bool, |
|
renderCalendarInfo: _propTypes2['default'].func, |
|
calendarInfoPosition: _CalendarInfoPositionShape2['default'], |
|
hideKeyboardShortcutsPanel: _propTypes2['default'].bool, |
|
daySize: _airbnbPropTypes.nonNegativeInteger, |
|
isRTL: _propTypes2['default'].bool, |
|
verticalHeight: _airbnbPropTypes.nonNegativeInteger, |
|
transitionDuration: _airbnbPropTypes.nonNegativeInteger, |
|
horizontalMonthPadding: _airbnbPropTypes.nonNegativeInteger, |
|
|
|
// navigation related props |
|
navPrev: _propTypes2['default'].node, |
|
navNext: _propTypes2['default'].node, |
|
|
|
onPrevMonthClick: _propTypes2['default'].func, |
|
onNextMonthClick: _propTypes2['default'].func, |
|
onClose: _propTypes2['default'].func, |
|
|
|
// day presentation and interaction related props |
|
renderCalendarDay: _propTypes2['default'].func, |
|
renderDayContents: _propTypes2['default'].func, |
|
enableOutsideDays: _propTypes2['default'].bool, |
|
isDayBlocked: _propTypes2['default'].func, |
|
isOutsideRange: _propTypes2['default'].func, |
|
isDayHighlighted: _propTypes2['default'].func, |
|
|
|
// internationalization props |
|
displayFormat: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].func]), |
|
monthFormat: _propTypes2['default'].string, |
|
weekDayFormat: _propTypes2['default'].string, |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.SingleDatePickerPhrases)), |
|
dayAriaLabelFormat: _propTypes2['default'].string |
|
}; |
|
|
|
/***/ }), |
|
/* 209 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _DateInput = __webpack_require__(197); |
|
|
|
var _DateInput2 = _interopRequireDefault(_DateInput); |
|
|
|
var _IconPositionShape = __webpack_require__(92); |
|
|
|
var _IconPositionShape2 = _interopRequireDefault(_IconPositionShape); |
|
|
|
var _CloseButton = __webpack_require__(96); |
|
|
|
var _CloseButton2 = _interopRequireDefault(_CloseButton); |
|
|
|
var _CalendarIcon = __webpack_require__(203); |
|
|
|
var _CalendarIcon2 = _interopRequireDefault(_CalendarIcon); |
|
|
|
var _OpenDirectionShape = __webpack_require__(81); |
|
|
|
var _OpenDirectionShape2 = _interopRequireDefault(_OpenDirectionShape); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, { |
|
id: _propTypes2['default'].string.isRequired, |
|
placeholder: _propTypes2['default'].string, // also used as label |
|
displayValue: _propTypes2['default'].string, |
|
screenReaderMessage: _propTypes2['default'].string, |
|
focused: _propTypes2['default'].bool, |
|
isFocused: _propTypes2['default'].bool, // describes actual DOM focus |
|
disabled: _propTypes2['default'].bool, |
|
required: _propTypes2['default'].bool, |
|
readOnly: _propTypes2['default'].bool, |
|
openDirection: _OpenDirectionShape2['default'], |
|
showCaret: _propTypes2['default'].bool, |
|
showClearDate: _propTypes2['default'].bool, |
|
customCloseIcon: _propTypes2['default'].node, |
|
showDefaultInputIcon: _propTypes2['default'].bool, |
|
inputIconPosition: _IconPositionShape2['default'], |
|
customInputIcon: _propTypes2['default'].node, |
|
isRTL: _propTypes2['default'].bool, |
|
noBorder: _propTypes2['default'].bool, |
|
block: _propTypes2['default'].bool, |
|
small: _propTypes2['default'].bool, |
|
regular: _propTypes2['default'].bool, |
|
verticalSpacing: _airbnbPropTypes.nonNegativeInteger, |
|
|
|
onChange: _propTypes2['default'].func, |
|
onClearDate: _propTypes2['default'].func, |
|
onFocus: _propTypes2['default'].func, |
|
onKeyDownShiftTab: _propTypes2['default'].func, |
|
onKeyDownTab: _propTypes2['default'].func, |
|
onKeyDownArrowDown: _propTypes2['default'].func, |
|
onKeyDownQuestionMark: _propTypes2['default'].func, |
|
|
|
// i18n |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.SingleDatePickerInputPhrases)) |
|
})); |
|
|
|
var defaultProps = { |
|
placeholder: 'Select Date', |
|
displayValue: '', |
|
screenReaderMessage: '', |
|
focused: false, |
|
isFocused: false, |
|
disabled: false, |
|
required: false, |
|
readOnly: false, |
|
openDirection: _constants.OPEN_DOWN, |
|
showCaret: false, |
|
showClearDate: false, |
|
showDefaultInputIcon: false, |
|
inputIconPosition: _constants.ICON_BEFORE_POSITION, |
|
customCloseIcon: null, |
|
customInputIcon: null, |
|
isRTL: false, |
|
noBorder: false, |
|
block: false, |
|
small: false, |
|
regular: false, |
|
verticalSpacing: undefined, |
|
|
|
onChange: function () { |
|
function onChange() {} |
|
|
|
return onChange; |
|
}(), |
|
onClearDate: function () { |
|
function onClearDate() {} |
|
|
|
return onClearDate; |
|
}(), |
|
onFocus: function () { |
|
function onFocus() {} |
|
|
|
return onFocus; |
|
}(), |
|
onKeyDownShiftTab: function () { |
|
function onKeyDownShiftTab() {} |
|
|
|
return onKeyDownShiftTab; |
|
}(), |
|
onKeyDownTab: function () { |
|
function onKeyDownTab() {} |
|
|
|
return onKeyDownTab; |
|
}(), |
|
onKeyDownArrowDown: function () { |
|
function onKeyDownArrowDown() {} |
|
|
|
return onKeyDownArrowDown; |
|
}(), |
|
onKeyDownQuestionMark: function () { |
|
function onKeyDownQuestionMark() {} |
|
|
|
return onKeyDownQuestionMark; |
|
}(), |
|
|
|
|
|
// i18n |
|
phrases: _defaultPhrases.SingleDatePickerInputPhrases |
|
}; |
|
|
|
/* eslint react/no-this-in-sfc: 1 */ |
|
|
|
function SingleDatePickerInput(_ref) { |
|
var id = _ref.id, |
|
placeholder = _ref.placeholder, |
|
displayValue = _ref.displayValue, |
|
focused = _ref.focused, |
|
isFocused = _ref.isFocused, |
|
disabled = _ref.disabled, |
|
required = _ref.required, |
|
readOnly = _ref.readOnly, |
|
showCaret = _ref.showCaret, |
|
showClearDate = _ref.showClearDate, |
|
showDefaultInputIcon = _ref.showDefaultInputIcon, |
|
inputIconPosition = _ref.inputIconPosition, |
|
phrases = _ref.phrases, |
|
onClearDate = _ref.onClearDate, |
|
onChange = _ref.onChange, |
|
onFocus = _ref.onFocus, |
|
onKeyDownShiftTab = _ref.onKeyDownShiftTab, |
|
onKeyDownTab = _ref.onKeyDownTab, |
|
onKeyDownArrowDown = _ref.onKeyDownArrowDown, |
|
onKeyDownQuestionMark = _ref.onKeyDownQuestionMark, |
|
screenReaderMessage = _ref.screenReaderMessage, |
|
customCloseIcon = _ref.customCloseIcon, |
|
customInputIcon = _ref.customInputIcon, |
|
openDirection = _ref.openDirection, |
|
isRTL = _ref.isRTL, |
|
noBorder = _ref.noBorder, |
|
block = _ref.block, |
|
small = _ref.small, |
|
regular = _ref.regular, |
|
verticalSpacing = _ref.verticalSpacing, |
|
styles = _ref.styles; |
|
|
|
var calendarIcon = customInputIcon || _react2['default'].createElement(_CalendarIcon2['default'], (0, _reactWithStyles.css)(styles.SingleDatePickerInput_calendarIcon_svg)); |
|
var closeIcon = customCloseIcon || _react2['default'].createElement(_CloseButton2['default'], (0, _reactWithStyles.css)(styles.SingleDatePickerInput_clearDate_svg, small && styles.SingleDatePickerInput_clearDate_svg__small)); |
|
|
|
var screenReaderText = screenReaderMessage || phrases.keyboardNavigationInstructions; |
|
var inputIcon = (showDefaultInputIcon || customInputIcon !== null) && _react2['default'].createElement( |
|
'button', |
|
_extends({}, (0, _reactWithStyles.css)(styles.SingleDatePickerInput_calendarIcon), { |
|
type: 'button', |
|
disabled: disabled, |
|
'aria-label': phrases.focusStartDate, |
|
onClick: onFocus |
|
}), |
|
calendarIcon |
|
); |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
(0, _reactWithStyles.css)(styles.SingleDatePickerInput, disabled && styles.SingleDatePickerInput__disabled, isRTL && styles.SingleDatePickerInput__rtl, !noBorder && styles.SingleDatePickerInput__withBorder, block && styles.SingleDatePickerInput__block, showClearDate && styles.SingleDatePickerInput__showClearDate), |
|
inputIconPosition === _constants.ICON_BEFORE_POSITION && inputIcon, |
|
_react2['default'].createElement(_DateInput2['default'], { |
|
id: id, |
|
placeholder: placeholder // also used as label |
|
, displayValue: displayValue, |
|
screenReaderMessage: screenReaderText, |
|
focused: focused, |
|
isFocused: isFocused, |
|
disabled: disabled, |
|
required: required, |
|
readOnly: readOnly, |
|
showCaret: showCaret, |
|
onChange: onChange, |
|
onFocus: onFocus, |
|
onKeyDownShiftTab: onKeyDownShiftTab, |
|
onKeyDownTab: onKeyDownTab, |
|
onKeyDownArrowDown: onKeyDownArrowDown, |
|
onKeyDownQuestionMark: onKeyDownQuestionMark, |
|
openDirection: openDirection, |
|
verticalSpacing: verticalSpacing, |
|
small: small, |
|
regular: regular, |
|
block: block |
|
}), |
|
showClearDate && _react2['default'].createElement( |
|
'button', |
|
_extends({}, (0, _reactWithStyles.css)(styles.SingleDatePickerInput_clearDate, small && styles.SingleDatePickerInput_clearDate__small, !customCloseIcon && styles.SingleDatePickerInput_clearDate__default, !displayValue && styles.SingleDatePickerInput_clearDate__hide), { |
|
type: 'button', |
|
'aria-label': phrases.clearDate, |
|
disabled: disabled, |
|
onMouseEnter: this && this.onClearDateMouseEnter, |
|
onMouseLeave: this && this.onClearDateMouseLeave, |
|
onClick: onClearDate |
|
}), |
|
closeIcon |
|
), |
|
inputIconPosition === _constants.ICON_AFTER_POSITION && inputIcon |
|
); |
|
} |
|
|
|
SingleDatePickerInput.propTypes = propTypes; |
|
SingleDatePickerInput.defaultProps = defaultProps; |
|
|
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref2) { |
|
var _ref2$reactDates = _ref2.reactDates, |
|
border = _ref2$reactDates.border, |
|
color = _ref2$reactDates.color; |
|
return { |
|
SingleDatePickerInput: { |
|
display: 'inline-block', |
|
backgroundColor: color.background |
|
}, |
|
|
|
SingleDatePickerInput__withBorder: { |
|
borderColor: color.border, |
|
borderWidth: border.pickerInput.borderWidth, |
|
borderStyle: border.pickerInput.borderStyle, |
|
borderRadius: border.pickerInput.borderRadius |
|
}, |
|
|
|
SingleDatePickerInput__rtl: { |
|
direction: 'rtl' |
|
}, |
|
|
|
SingleDatePickerInput__disabled: { |
|
backgroundColor: color.disabled |
|
}, |
|
|
|
SingleDatePickerInput__block: { |
|
display: 'block' |
|
}, |
|
|
|
SingleDatePickerInput__showClearDate: { |
|
paddingRight: 30 |
|
}, |
|
|
|
SingleDatePickerInput_clearDate: { |
|
background: 'none', |
|
border: 0, |
|
color: 'inherit', |
|
font: 'inherit', |
|
lineHeight: 'normal', |
|
overflow: 'visible', |
|
|
|
cursor: 'pointer', |
|
padding: 10, |
|
margin: '0 10px 0 5px', |
|
position: 'absolute', |
|
right: 0, |
|
top: '50%', |
|
transform: 'translateY(-50%)' |
|
}, |
|
|
|
SingleDatePickerInput_clearDate__default: { |
|
':focus': { |
|
background: color.core.border, |
|
borderRadius: '50%' |
|
}, |
|
|
|
':hover': { |
|
background: color.core.border, |
|
borderRadius: '50%' |
|
} |
|
}, |
|
|
|
SingleDatePickerInput_clearDate__small: { |
|
padding: 6 |
|
}, |
|
|
|
SingleDatePickerInput_clearDate__hide: { |
|
visibility: 'hidden' |
|
}, |
|
|
|
SingleDatePickerInput_clearDate_svg: { |
|
fill: color.core.grayLight, |
|
height: 12, |
|
width: 15, |
|
verticalAlign: 'middle' |
|
}, |
|
|
|
SingleDatePickerInput_clearDate_svg__small: { |
|
height: 9 |
|
}, |
|
|
|
SingleDatePickerInput_calendarIcon: { |
|
background: 'none', |
|
border: 0, |
|
color: 'inherit', |
|
font: 'inherit', |
|
lineHeight: 'normal', |
|
overflow: 'visible', |
|
|
|
cursor: 'pointer', |
|
display: 'inline-block', |
|
verticalAlign: 'middle', |
|
padding: 10, |
|
margin: '0 5px 0 10px' |
|
}, |
|
|
|
SingleDatePickerInput_calendarIcon_svg: { |
|
fill: color.core.grayLight, |
|
height: 15, |
|
width: 14, |
|
verticalAlign: 'middle' |
|
} |
|
}; |
|
})(SingleDatePickerInput); |
|
|
|
/***/ }), |
|
/* 210 */, |
|
/* 211 */, |
|
/* 212 */, |
|
/* 213 */, |
|
/* 214 */, |
|
/* 215 */, |
|
/* 216 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
__webpack_require__.r(__webpack_exports__); |
|
|
|
// EXTERNAL MODULE: external "ReactDOM" |
|
var external_ReactDOM_ = __webpack_require__(57); |
|
var external_ReactDOM_default = /*#__PURE__*/__webpack_require__.n(external_ReactDOM_); |
|
|
|
// EXTERNAL MODULE: external "React" |
|
var external_React_ = __webpack_require__(28); |
|
var external_React_default = /*#__PURE__*/__webpack_require__.n(external_React_); |
|
|
|
// EXTERNAL MODULE: ./node_modules/prop-types/index.js |
|
var prop_types = __webpack_require__(33); |
|
var prop_types_default = /*#__PURE__*/__webpack_require__.n(prop_types); |
|
|
|
// CONCATENATED MODULE: ./node_modules/react-portal/es/utils.js |
|
var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement); |
|
// CONCATENATED MODULE: ./node_modules/react-portal/es/Portal.js |
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
|
|
|
|
|
|
|
|
|
|
var Portal_Portal = function (_React$Component) { |
|
_inherits(Portal, _React$Component); |
|
|
|
function Portal() { |
|
_classCallCheck(this, Portal); |
|
|
|
return _possibleConstructorReturn(this, (Portal.__proto__ || Object.getPrototypeOf(Portal)).apply(this, arguments)); |
|
} |
|
|
|
_createClass(Portal, [{ |
|
key: 'componentWillUnmount', |
|
value: function componentWillUnmount() { |
|
if (this.defaultNode) { |
|
document.body.removeChild(this.defaultNode); |
|
} |
|
this.defaultNode = null; |
|
} |
|
}, { |
|
key: 'render', |
|
value: function render() { |
|
if (!canUseDOM) { |
|
return null; |
|
} |
|
if (!this.props.node && !this.defaultNode) { |
|
this.defaultNode = document.createElement('div'); |
|
document.body.appendChild(this.defaultNode); |
|
} |
|
return external_ReactDOM_default.a.createPortal(this.props.children, this.props.node || this.defaultNode); |
|
} |
|
}]); |
|
|
|
return Portal; |
|
}(external_React_default.a.Component); |
|
|
|
Portal_Portal.propTypes = { |
|
children: prop_types_default.a.node.isRequired, |
|
node: prop_types_default.a.any |
|
}; |
|
|
|
/* harmony default export */ var es_Portal = (Portal_Portal); |
|
// CONCATENATED MODULE: ./node_modules/react-portal/es/LegacyPortal.js |
|
var LegacyPortal_createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
function LegacyPortal_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function LegacyPortal_possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function LegacyPortal_inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
// This file is a fallback for a consumer who is not yet on React 16 |
|
// as createPortal was introduced in React 16 |
|
|
|
|
|
|
|
|
|
|
|
var LegacyPortal_Portal = function (_React$Component) { |
|
LegacyPortal_inherits(Portal, _React$Component); |
|
|
|
function Portal() { |
|
LegacyPortal_classCallCheck(this, Portal); |
|
|
|
return LegacyPortal_possibleConstructorReturn(this, (Portal.__proto__ || Object.getPrototypeOf(Portal)).apply(this, arguments)); |
|
} |
|
|
|
LegacyPortal_createClass(Portal, [{ |
|
key: 'componentDidMount', |
|
value: function componentDidMount() { |
|
this.renderPortal(); |
|
} |
|
}, { |
|
key: 'componentDidUpdate', |
|
value: function componentDidUpdate(props) { |
|
this.renderPortal(); |
|
} |
|
}, { |
|
key: 'componentWillUnmount', |
|
value: function componentWillUnmount() { |
|
external_ReactDOM_default.a.unmountComponentAtNode(this.defaultNode || this.props.node); |
|
if (this.defaultNode) { |
|
document.body.removeChild(this.defaultNode); |
|
} |
|
this.defaultNode = null; |
|
this.portal = null; |
|
} |
|
}, { |
|
key: 'renderPortal', |
|
value: function renderPortal(props) { |
|
if (!this.props.node && !this.defaultNode) { |
|
this.defaultNode = document.createElement('div'); |
|
document.body.appendChild(this.defaultNode); |
|
} |
|
|
|
var children = this.props.children; |
|
// https://gist.github.com/jimfb/d99e0678e9da715ccf6454961ef04d1b |
|
if (typeof this.props.children.type === 'function') { |
|
children = external_React_default.a.cloneElement(this.props.children); |
|
} |
|
|
|
this.portal = external_ReactDOM_default.a.unstable_renderSubtreeIntoContainer(this, children, this.props.node || this.defaultNode); |
|
} |
|
}, { |
|
key: 'render', |
|
value: function render() { |
|
return null; |
|
} |
|
}]); |
|
|
|
return Portal; |
|
}(external_React_default.a.Component); |
|
|
|
/* harmony default export */ var LegacyPortal = (LegacyPortal_Portal); |
|
|
|
|
|
LegacyPortal_Portal.propTypes = { |
|
children: prop_types_default.a.node.isRequired, |
|
node: prop_types_default.a.any |
|
}; |
|
// CONCATENATED MODULE: ./node_modules/react-portal/es/PortalCompat.js |
|
|
|
|
|
|
|
|
|
|
|
var PortalCompat_Portal = void 0; |
|
|
|
if (external_ReactDOM_default.a.createPortal) { |
|
PortalCompat_Portal = es_Portal; |
|
} else { |
|
PortalCompat_Portal = LegacyPortal; |
|
} |
|
|
|
/* harmony default export */ var PortalCompat = (PortalCompat_Portal); |
|
// CONCATENATED MODULE: ./node_modules/react-portal/es/PortalWithState.js |
|
var PortalWithState_createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
function PortalWithState_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function PortalWithState_possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function PortalWithState_inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
|
|
|
|
|
|
|
|
var KEYCODES = { |
|
ESCAPE: 27 |
|
}; |
|
|
|
var PortalWithState_PortalWithState = function (_React$Component) { |
|
PortalWithState_inherits(PortalWithState, _React$Component); |
|
|
|
function PortalWithState(props) { |
|
PortalWithState_classCallCheck(this, PortalWithState); |
|
|
|
var _this = PortalWithState_possibleConstructorReturn(this, (PortalWithState.__proto__ || Object.getPrototypeOf(PortalWithState)).call(this, props)); |
|
|
|
_this.portalNode = null; |
|
_this.state = { active: !!props.defaultOpen }; |
|
_this.openPortal = _this.openPortal.bind(_this); |
|
_this.closePortal = _this.closePortal.bind(_this); |
|
_this.wrapWithPortal = _this.wrapWithPortal.bind(_this); |
|
_this.handleOutsideMouseClick = _this.handleOutsideMouseClick.bind(_this); |
|
_this.handleKeydown = _this.handleKeydown.bind(_this); |
|
return _this; |
|
} |
|
|
|
PortalWithState_createClass(PortalWithState, [{ |
|
key: 'componentDidMount', |
|
value: function componentDidMount() { |
|
if (this.props.closeOnEsc) { |
|
document.addEventListener('keydown', this.handleKeydown); |
|
} |
|
if (this.props.closeOnOutsideClick) { |
|
document.addEventListener('click', this.handleOutsideMouseClick); |
|
} |
|
} |
|
}, { |
|
key: 'componentWillUnmount', |
|
value: function componentWillUnmount() { |
|
if (this.props.closeOnEsc) { |
|
document.removeEventListener('keydown', this.handleKeydown); |
|
} |
|
if (this.props.closeOnOutsideClick) { |
|
document.removeEventListener('click', this.handleOutsideMouseClick); |
|
} |
|
} |
|
}, { |
|
key: 'openPortal', |
|
value: function openPortal(e) { |
|
if (this.state.active) { |
|
return; |
|
} |
|
if (e && e.nativeEvent) { |
|
e.nativeEvent.stopImmediatePropagation(); |
|
} |
|
this.setState({ active: true }, this.props.onOpen); |
|
} |
|
}, { |
|
key: 'closePortal', |
|
value: function closePortal() { |
|
if (!this.state.active) { |
|
return; |
|
} |
|
this.setState({ active: false }, this.props.onClose); |
|
} |
|
}, { |
|
key: 'wrapWithPortal', |
|
value: function wrapWithPortal(children) { |
|
var _this2 = this; |
|
|
|
if (!this.state.active) { |
|
return null; |
|
} |
|
return external_React_default.a.createElement( |
|
PortalCompat, |
|
{ |
|
node: this.props.node, |
|
key: 'react-portal', |
|
ref: function ref(portalNode) { |
|
return _this2.portalNode = portalNode; |
|
} |
|
}, |
|
children |
|
); |
|
} |
|
}, { |
|
key: 'handleOutsideMouseClick', |
|
value: function handleOutsideMouseClick(e) { |
|
if (!this.state.active) { |
|
return; |
|
} |
|
var root = this.portalNode.props.node || this.portalNode.defaultNode; |
|
if (!root || root.contains(e.target) || e.button && e.button !== 0) { |
|
return; |
|
} |
|
this.closePortal(); |
|
} |
|
}, { |
|
key: 'handleKeydown', |
|
value: function handleKeydown(e) { |
|
if (e.keyCode === KEYCODES.ESCAPE && this.state.active) { |
|
this.closePortal(); |
|
} |
|
} |
|
}, { |
|
key: 'render', |
|
value: function render() { |
|
return this.props.children({ |
|
openPortal: this.openPortal, |
|
closePortal: this.closePortal, |
|
portal: this.wrapWithPortal, |
|
isOpen: this.state.active |
|
}); |
|
} |
|
}]); |
|
|
|
return PortalWithState; |
|
}(external_React_default.a.Component); |
|
|
|
PortalWithState_PortalWithState.propTypes = { |
|
children: prop_types_default.a.func.isRequired, |
|
defaultOpen: prop_types_default.a.bool, |
|
node: prop_types_default.a.any, |
|
closeOnEsc: prop_types_default.a.bool, |
|
closeOnOutsideClick: prop_types_default.a.bool, |
|
onOpen: prop_types_default.a.func, |
|
onClose: prop_types_default.a.func |
|
}; |
|
|
|
PortalWithState_PortalWithState.defaultProps = { |
|
onOpen: function onOpen() {}, |
|
onClose: function onClose() {} |
|
}; |
|
|
|
/* harmony default export */ var es_PortalWithState = (PortalWithState_PortalWithState); |
|
// CONCATENATED MODULE: ./node_modules/react-portal/es/index.js |
|
/* concated harmony reexport Portal */__webpack_require__.d(__webpack_exports__, "Portal", function() { return PortalCompat; }); |
|
/* concated harmony reexport PortalWithState */__webpack_require__.d(__webpack_exports__, "PortalWithState", function() { return es_PortalWithState; }); |
|
|
|
|
|
|
|
|
|
|
|
/***/ }), |
|
/* 217 */, |
|
/* 218 */, |
|
/* 219 */, |
|
/* 220 */, |
|
/* 221 */, |
|
/* 222 */, |
|
/* 223 */, |
|
/* 224 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
/*! |
|
* clipboard.js v2.0.4 |
|
* https://zenorocha.github.io/clipboard.js |
|
* |
|
* Licensed MIT © Zeno Rocha |
|
*/ |
|
(function webpackUniversalModuleDefinition(root, factory) { |
|
if(true) |
|
module.exports = factory(); |
|
else {} |
|
})(this, function() { |
|
return /******/ (function(modules) { // webpackBootstrap |
|
/******/ // The module cache |
|
/******/ var installedModules = {}; |
|
/******/ |
|
/******/ // The require function |
|
/******/ function __webpack_require__(moduleId) { |
|
/******/ |
|
/******/ // Check if module is in cache |
|
/******/ if(installedModules[moduleId]) { |
|
/******/ return installedModules[moduleId].exports; |
|
/******/ } |
|
/******/ // Create a new module (and put it into the cache) |
|
/******/ var module = installedModules[moduleId] = { |
|
/******/ i: moduleId, |
|
/******/ l: false, |
|
/******/ exports: {} |
|
/******/ }; |
|
/******/ |
|
/******/ // Execute the module function |
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); |
|
/******/ |
|
/******/ // Flag the module as loaded |
|
/******/ module.l = true; |
|
/******/ |
|
/******/ // Return the exports of the module |
|
/******/ return module.exports; |
|
/******/ } |
|
/******/ |
|
/******/ |
|
/******/ // expose the modules object (__webpack_modules__) |
|
/******/ __webpack_require__.m = modules; |
|
/******/ |
|
/******/ // expose the module cache |
|
/******/ __webpack_require__.c = installedModules; |
|
/******/ |
|
/******/ // define getter function for harmony exports |
|
/******/ __webpack_require__.d = function(exports, name, getter) { |
|
/******/ if(!__webpack_require__.o(exports, name)) { |
|
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); |
|
/******/ } |
|
/******/ }; |
|
/******/ |
|
/******/ // define __esModule on exports |
|
/******/ __webpack_require__.r = function(exports) { |
|
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { |
|
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); |
|
/******/ } |
|
/******/ Object.defineProperty(exports, '__esModule', { value: true }); |
|
/******/ }; |
|
/******/ |
|
/******/ // create a fake namespace object |
|
/******/ // mode & 1: value is a module id, require it |
|
/******/ // mode & 2: merge all properties of value into the ns |
|
/******/ // mode & 4: return value when already ns object |
|
/******/ // mode & 8|1: behave like require |
|
/******/ __webpack_require__.t = function(value, mode) { |
|
/******/ if(mode & 1) value = __webpack_require__(value); |
|
/******/ if(mode & 8) return value; |
|
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; |
|
/******/ var ns = Object.create(null); |
|
/******/ __webpack_require__.r(ns); |
|
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); |
|
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); |
|
/******/ return ns; |
|
/******/ }; |
|
/******/ |
|
/******/ // getDefaultExport function for compatibility with non-harmony modules |
|
/******/ __webpack_require__.n = function(module) { |
|
/******/ var getter = module && module.__esModule ? |
|
/******/ function getDefault() { return module['default']; } : |
|
/******/ function getModuleExports() { return module; }; |
|
/******/ __webpack_require__.d(getter, 'a', getter); |
|
/******/ return getter; |
|
/******/ }; |
|
/******/ |
|
/******/ // Object.prototype.hasOwnProperty.call |
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; |
|
/******/ |
|
/******/ // __webpack_public_path__ |
|
/******/ __webpack_require__.p = ""; |
|
/******/ |
|
/******/ |
|
/******/ // Load entry module and return exports |
|
/******/ return __webpack_require__(__webpack_require__.s = 0); |
|
/******/ }) |
|
/************************************************************************/ |
|
/******/ ([ |
|
/* 0 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _clipboardAction = __webpack_require__(1); |
|
|
|
var _clipboardAction2 = _interopRequireDefault(_clipboardAction); |
|
|
|
var _tinyEmitter = __webpack_require__(3); |
|
|
|
var _tinyEmitter2 = _interopRequireDefault(_tinyEmitter); |
|
|
|
var _goodListener = __webpack_require__(4); |
|
|
|
var _goodListener2 = _interopRequireDefault(_goodListener); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
/** |
|
* Base class which takes one or more elements, adds event listeners to them, |
|
* and instantiates a new `ClipboardAction` on each click. |
|
*/ |
|
var Clipboard = function (_Emitter) { |
|
_inherits(Clipboard, _Emitter); |
|
|
|
/** |
|
* @param {String|HTMLElement|HTMLCollection|NodeList} trigger |
|
* @param {Object} options |
|
*/ |
|
function Clipboard(trigger, options) { |
|
_classCallCheck(this, Clipboard); |
|
|
|
var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).call(this)); |
|
|
|
_this.resolveOptions(options); |
|
_this.listenClick(trigger); |
|
return _this; |
|
} |
|
|
|
/** |
|
* Defines if attributes would be resolved using internal setter functions |
|
* or custom functions that were passed in the constructor. |
|
* @param {Object} options |
|
*/ |
|
|
|
|
|
_createClass(Clipboard, [{ |
|
key: 'resolveOptions', |
|
value: function resolveOptions() { |
|
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; |
|
|
|
this.action = typeof options.action === 'function' ? options.action : this.defaultAction; |
|
this.target = typeof options.target === 'function' ? options.target : this.defaultTarget; |
|
this.text = typeof options.text === 'function' ? options.text : this.defaultText; |
|
this.container = _typeof(options.container) === 'object' ? options.container : document.body; |
|
} |
|
|
|
/** |
|
* Adds a click event listener to the passed trigger. |
|
* @param {String|HTMLElement|HTMLCollection|NodeList} trigger |
|
*/ |
|
|
|
}, { |
|
key: 'listenClick', |
|
value: function listenClick(trigger) { |
|
var _this2 = this; |
|
|
|
this.listener = (0, _goodListener2.default)(trigger, 'click', function (e) { |
|
return _this2.onClick(e); |
|
}); |
|
} |
|
|
|
/** |
|
* Defines a new `ClipboardAction` on each click event. |
|
* @param {Event} e |
|
*/ |
|
|
|
}, { |
|
key: 'onClick', |
|
value: function onClick(e) { |
|
var trigger = e.delegateTarget || e.currentTarget; |
|
|
|
if (this.clipboardAction) { |
|
this.clipboardAction = null; |
|
} |
|
|
|
this.clipboardAction = new _clipboardAction2.default({ |
|
action: this.action(trigger), |
|
target: this.target(trigger), |
|
text: this.text(trigger), |
|
container: this.container, |
|
trigger: trigger, |
|
emitter: this |
|
}); |
|
} |
|
|
|
/** |
|
* Default `action` lookup function. |
|
* @param {Element} trigger |
|
*/ |
|
|
|
}, { |
|
key: 'defaultAction', |
|
value: function defaultAction(trigger) { |
|
return getAttributeValue('action', trigger); |
|
} |
|
|
|
/** |
|
* Default `target` lookup function. |
|
* @param {Element} trigger |
|
*/ |
|
|
|
}, { |
|
key: 'defaultTarget', |
|
value: function defaultTarget(trigger) { |
|
var selector = getAttributeValue('target', trigger); |
|
|
|
if (selector) { |
|
return document.querySelector(selector); |
|
} |
|
} |
|
|
|
/** |
|
* Returns the support of the given action, or all actions if no action is |
|
* given. |
|
* @param {String} [action] |
|
*/ |
|
|
|
}, { |
|
key: 'defaultText', |
|
|
|
|
|
/** |
|
* Default `text` lookup function. |
|
* @param {Element} trigger |
|
*/ |
|
value: function defaultText(trigger) { |
|
return getAttributeValue('text', trigger); |
|
} |
|
|
|
/** |
|
* Destroy lifecycle. |
|
*/ |
|
|
|
}, { |
|
key: 'destroy', |
|
value: function destroy() { |
|
this.listener.destroy(); |
|
|
|
if (this.clipboardAction) { |
|
this.clipboardAction.destroy(); |
|
this.clipboardAction = null; |
|
} |
|
} |
|
}], [{ |
|
key: 'isSupported', |
|
value: function isSupported() { |
|
var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut']; |
|
|
|
var actions = typeof action === 'string' ? [action] : action; |
|
var support = !!document.queryCommandSupported; |
|
|
|
actions.forEach(function (action) { |
|
support = support && !!document.queryCommandSupported(action); |
|
}); |
|
|
|
return support; |
|
} |
|
}]); |
|
|
|
return Clipboard; |
|
}(_tinyEmitter2.default); |
|
|
|
/** |
|
* Helper function to retrieve attribute value. |
|
* @param {String} suffix |
|
* @param {Element} element |
|
*/ |
|
|
|
|
|
function getAttributeValue(suffix, element) { |
|
var attribute = 'data-clipboard-' + suffix; |
|
|
|
if (!element.hasAttribute(attribute)) { |
|
return; |
|
} |
|
|
|
return element.getAttribute(attribute); |
|
} |
|
|
|
module.exports = Clipboard; |
|
|
|
/***/ }), |
|
/* 1 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _select = __webpack_require__(2); |
|
|
|
var _select2 = _interopRequireDefault(_select); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
/** |
|
* Inner class which performs selection from either `text` or `target` |
|
* properties and then executes copy or cut operations. |
|
*/ |
|
var ClipboardAction = function () { |
|
/** |
|
* @param {Object} options |
|
*/ |
|
function ClipboardAction(options) { |
|
_classCallCheck(this, ClipboardAction); |
|
|
|
this.resolveOptions(options); |
|
this.initSelection(); |
|
} |
|
|
|
/** |
|
* Defines base properties passed from constructor. |
|
* @param {Object} options |
|
*/ |
|
|
|
|
|
_createClass(ClipboardAction, [{ |
|
key: 'resolveOptions', |
|
value: function resolveOptions() { |
|
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; |
|
|
|
this.action = options.action; |
|
this.container = options.container; |
|
this.emitter = options.emitter; |
|
this.target = options.target; |
|
this.text = options.text; |
|
this.trigger = options.trigger; |
|
|
|
this.selectedText = ''; |
|
} |
|
|
|
/** |
|
* Decides which selection strategy is going to be applied based |
|
* on the existence of `text` and `target` properties. |
|
*/ |
|
|
|
}, { |
|
key: 'initSelection', |
|
value: function initSelection() { |
|
if (this.text) { |
|
this.selectFake(); |
|
} else if (this.target) { |
|
this.selectTarget(); |
|
} |
|
} |
|
|
|
/** |
|
* Creates a fake textarea element, sets its value from `text` property, |
|
* and makes a selection on it. |
|
*/ |
|
|
|
}, { |
|
key: 'selectFake', |
|
value: function selectFake() { |
|
var _this = this; |
|
|
|
var isRTL = document.documentElement.getAttribute('dir') == 'rtl'; |
|
|
|
this.removeFake(); |
|
|
|
this.fakeHandlerCallback = function () { |
|
return _this.removeFake(); |
|
}; |
|
this.fakeHandler = this.container.addEventListener('click', this.fakeHandlerCallback) || true; |
|
|
|
this.fakeElem = document.createElement('textarea'); |
|
// Prevent zooming on iOS |
|
this.fakeElem.style.fontSize = '12pt'; |
|
// Reset box model |
|
this.fakeElem.style.border = '0'; |
|
this.fakeElem.style.padding = '0'; |
|
this.fakeElem.style.margin = '0'; |
|
// Move element out of screen horizontally |
|
this.fakeElem.style.position = 'absolute'; |
|
this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px'; |
|
// Move element to the same position vertically |
|
var yPosition = window.pageYOffset || document.documentElement.scrollTop; |
|
this.fakeElem.style.top = yPosition + 'px'; |
|
|
|
this.fakeElem.setAttribute('readonly', ''); |
|
this.fakeElem.value = this.text; |
|
|
|
this.container.appendChild(this.fakeElem); |
|
|
|
this.selectedText = (0, _select2.default)(this.fakeElem); |
|
this.copyText(); |
|
} |
|
|
|
/** |
|
* Only removes the fake element after another click event, that way |
|
* a user can hit `Ctrl+C` to copy because selection still exists. |
|
*/ |
|
|
|
}, { |
|
key: 'removeFake', |
|
value: function removeFake() { |
|
if (this.fakeHandler) { |
|
this.container.removeEventListener('click', this.fakeHandlerCallback); |
|
this.fakeHandler = null; |
|
this.fakeHandlerCallback = null; |
|
} |
|
|
|
if (this.fakeElem) { |
|
this.container.removeChild(this.fakeElem); |
|
this.fakeElem = null; |
|
} |
|
} |
|
|
|
/** |
|
* Selects the content from element passed on `target` property. |
|
*/ |
|
|
|
}, { |
|
key: 'selectTarget', |
|
value: function selectTarget() { |
|
this.selectedText = (0, _select2.default)(this.target); |
|
this.copyText(); |
|
} |
|
|
|
/** |
|
* Executes the copy operation based on the current selection. |
|
*/ |
|
|
|
}, { |
|
key: 'copyText', |
|
value: function copyText() { |
|
var succeeded = void 0; |
|
|
|
try { |
|
succeeded = document.execCommand(this.action); |
|
} catch (err) { |
|
succeeded = false; |
|
} |
|
|
|
this.handleResult(succeeded); |
|
} |
|
|
|
/** |
|
* Fires an event based on the copy operation result. |
|
* @param {Boolean} succeeded |
|
*/ |
|
|
|
}, { |
|
key: 'handleResult', |
|
value: function handleResult(succeeded) { |
|
this.emitter.emit(succeeded ? 'success' : 'error', { |
|
action: this.action, |
|
text: this.selectedText, |
|
trigger: this.trigger, |
|
clearSelection: this.clearSelection.bind(this) |
|
}); |
|
} |
|
|
|
/** |
|
* Moves focus away from `target` and back to the trigger, removes current selection. |
|
*/ |
|
|
|
}, { |
|
key: 'clearSelection', |
|
value: function clearSelection() { |
|
if (this.trigger) { |
|
this.trigger.focus(); |
|
} |
|
|
|
window.getSelection().removeAllRanges(); |
|
} |
|
|
|
/** |
|
* Sets the `action` to be performed which can be either 'copy' or 'cut'. |
|
* @param {String} action |
|
*/ |
|
|
|
}, { |
|
key: 'destroy', |
|
|
|
|
|
/** |
|
* Destroy lifecycle. |
|
*/ |
|
value: function destroy() { |
|
this.removeFake(); |
|
} |
|
}, { |
|
key: 'action', |
|
set: function set() { |
|
var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy'; |
|
|
|
this._action = action; |
|
|
|
if (this._action !== 'copy' && this._action !== 'cut') { |
|
throw new Error('Invalid "action" value, use either "copy" or "cut"'); |
|
} |
|
} |
|
|
|
/** |
|
* Gets the `action` property. |
|
* @return {String} |
|
*/ |
|
, |
|
get: function get() { |
|
return this._action; |
|
} |
|
|
|
/** |
|
* Sets the `target` property using an element |
|
* that will be have its content copied. |
|
* @param {Element} target |
|
*/ |
|
|
|
}, { |
|
key: 'target', |
|
set: function set(target) { |
|
if (target !== undefined) { |
|
if (target && (typeof target === 'undefined' ? 'undefined' : _typeof(target)) === 'object' && target.nodeType === 1) { |
|
if (this.action === 'copy' && target.hasAttribute('disabled')) { |
|
throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute'); |
|
} |
|
|
|
if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) { |
|
throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes'); |
|
} |
|
|
|
this._target = target; |
|
} else { |
|
throw new Error('Invalid "target" value, use a valid Element'); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Gets the `target` property. |
|
* @return {String|HTMLElement} |
|
*/ |
|
, |
|
get: function get() { |
|
return this._target; |
|
} |
|
}]); |
|
|
|
return ClipboardAction; |
|
}(); |
|
|
|
module.exports = ClipboardAction; |
|
|
|
/***/ }), |
|
/* 2 */ |
|
/***/ (function(module, exports) { |
|
|
|
function select(element) { |
|
var selectedText; |
|
|
|
if (element.nodeName === 'SELECT') { |
|
element.focus(); |
|
|
|
selectedText = element.value; |
|
} |
|
else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') { |
|
var isReadOnly = element.hasAttribute('readonly'); |
|
|
|
if (!isReadOnly) { |
|
element.setAttribute('readonly', ''); |
|
} |
|
|
|
element.select(); |
|
element.setSelectionRange(0, element.value.length); |
|
|
|
if (!isReadOnly) { |
|
element.removeAttribute('readonly'); |
|
} |
|
|
|
selectedText = element.value; |
|
} |
|
else { |
|
if (element.hasAttribute('contenteditable')) { |
|
element.focus(); |
|
} |
|
|
|
var selection = window.getSelection(); |
|
var range = document.createRange(); |
|
|
|
range.selectNodeContents(element); |
|
selection.removeAllRanges(); |
|
selection.addRange(range); |
|
|
|
selectedText = selection.toString(); |
|
} |
|
|
|
return selectedText; |
|
} |
|
|
|
module.exports = select; |
|
|
|
|
|
/***/ }), |
|
/* 3 */ |
|
/***/ (function(module, exports) { |
|
|
|
function E () { |
|
// Keep this empty so it's easier to inherit from |
|
// (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3) |
|
} |
|
|
|
E.prototype = { |
|
on: function (name, callback, ctx) { |
|
var e = this.e || (this.e = {}); |
|
|
|
(e[name] || (e[name] = [])).push({ |
|
fn: callback, |
|
ctx: ctx |
|
}); |
|
|
|
return this; |
|
}, |
|
|
|
once: function (name, callback, ctx) { |
|
var self = this; |
|
function listener () { |
|
self.off(name, listener); |
|
callback.apply(ctx, arguments); |
|
}; |
|
|
|
listener._ = callback |
|
return this.on(name, listener, ctx); |
|
}, |
|
|
|
emit: function (name) { |
|
var data = [].slice.call(arguments, 1); |
|
var evtArr = ((this.e || (this.e = {}))[name] || []).slice(); |
|
var i = 0; |
|
var len = evtArr.length; |
|
|
|
for (i; i < len; i++) { |
|
evtArr[i].fn.apply(evtArr[i].ctx, data); |
|
} |
|
|
|
return this; |
|
}, |
|
|
|
off: function (name, callback) { |
|
var e = this.e || (this.e = {}); |
|
var evts = e[name]; |
|
var liveEvents = []; |
|
|
|
if (evts && callback) { |
|
for (var i = 0, len = evts.length; i < len; i++) { |
|
if (evts[i].fn !== callback && evts[i].fn._ !== callback) |
|
liveEvents.push(evts[i]); |
|
} |
|
} |
|
|
|
// Remove event from queue to prevent memory leak |
|
// Suggested by https://github.com/lazd |
|
// Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910 |
|
|
|
(liveEvents.length) |
|
? e[name] = liveEvents |
|
: delete e[name]; |
|
|
|
return this; |
|
} |
|
}; |
|
|
|
module.exports = E; |
|
|
|
|
|
/***/ }), |
|
/* 4 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var is = __webpack_require__(5); |
|
var delegate = __webpack_require__(6); |
|
|
|
/** |
|
* Validates all params and calls the right |
|
* listener function based on its target type. |
|
* |
|
* @param {String|HTMLElement|HTMLCollection|NodeList} target |
|
* @param {String} type |
|
* @param {Function} callback |
|
* @return {Object} |
|
*/ |
|
function listen(target, type, callback) { |
|
if (!target && !type && !callback) { |
|
throw new Error('Missing required arguments'); |
|
} |
|
|
|
if (!is.string(type)) { |
|
throw new TypeError('Second argument must be a String'); |
|
} |
|
|
|
if (!is.fn(callback)) { |
|
throw new TypeError('Third argument must be a Function'); |
|
} |
|
|
|
if (is.node(target)) { |
|
return listenNode(target, type, callback); |
|
} |
|
else if (is.nodeList(target)) { |
|
return listenNodeList(target, type, callback); |
|
} |
|
else if (is.string(target)) { |
|
return listenSelector(target, type, callback); |
|
} |
|
else { |
|
throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList'); |
|
} |
|
} |
|
|
|
/** |
|
* Adds an event listener to a HTML element |
|
* and returns a remove listener function. |
|
* |
|
* @param {HTMLElement} node |
|
* @param {String} type |
|
* @param {Function} callback |
|
* @return {Object} |
|
*/ |
|
function listenNode(node, type, callback) { |
|
node.addEventListener(type, callback); |
|
|
|
return { |
|
destroy: function() { |
|
node.removeEventListener(type, callback); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Add an event listener to a list of HTML elements |
|
* and returns a remove listener function. |
|
* |
|
* @param {NodeList|HTMLCollection} nodeList |
|
* @param {String} type |
|
* @param {Function} callback |
|
* @return {Object} |
|
*/ |
|
function listenNodeList(nodeList, type, callback) { |
|
Array.prototype.forEach.call(nodeList, function(node) { |
|
node.addEventListener(type, callback); |
|
}); |
|
|
|
return { |
|
destroy: function() { |
|
Array.prototype.forEach.call(nodeList, function(node) { |
|
node.removeEventListener(type, callback); |
|
}); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Add an event listener to a selector |
|
* and returns a remove listener function. |
|
* |
|
* @param {String} selector |
|
* @param {String} type |
|
* @param {Function} callback |
|
* @return {Object} |
|
*/ |
|
function listenSelector(selector, type, callback) { |
|
return delegate(document.body, selector, type, callback); |
|
} |
|
|
|
module.exports = listen; |
|
|
|
|
|
/***/ }), |
|
/* 5 */ |
|
/***/ (function(module, exports) { |
|
|
|
/** |
|
* Check if argument is a HTML element. |
|
* |
|
* @param {Object} value |
|
* @return {Boolean} |
|
*/ |
|
exports.node = function(value) { |
|
return value !== undefined |
|
&& value instanceof HTMLElement |
|
&& value.nodeType === 1; |
|
}; |
|
|
|
/** |
|
* Check if argument is a list of HTML elements. |
|
* |
|
* @param {Object} value |
|
* @return {Boolean} |
|
*/ |
|
exports.nodeList = function(value) { |
|
var type = Object.prototype.toString.call(value); |
|
|
|
return value !== undefined |
|
&& (type === '[object NodeList]' || type === '[object HTMLCollection]') |
|
&& ('length' in value) |
|
&& (value.length === 0 || exports.node(value[0])); |
|
}; |
|
|
|
/** |
|
* Check if argument is a string. |
|
* |
|
* @param {Object} value |
|
* @return {Boolean} |
|
*/ |
|
exports.string = function(value) { |
|
return typeof value === 'string' |
|
|| value instanceof String; |
|
}; |
|
|
|
/** |
|
* Check if argument is a function. |
|
* |
|
* @param {Object} value |
|
* @return {Boolean} |
|
*/ |
|
exports.fn = function(value) { |
|
var type = Object.prototype.toString.call(value); |
|
|
|
return type === '[object Function]'; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 6 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var closest = __webpack_require__(7); |
|
|
|
/** |
|
* Delegates event to a selector. |
|
* |
|
* @param {Element} element |
|
* @param {String} selector |
|
* @param {String} type |
|
* @param {Function} callback |
|
* @param {Boolean} useCapture |
|
* @return {Object} |
|
*/ |
|
function _delegate(element, selector, type, callback, useCapture) { |
|
var listenerFn = listener.apply(this, arguments); |
|
|
|
element.addEventListener(type, listenerFn, useCapture); |
|
|
|
return { |
|
destroy: function() { |
|
element.removeEventListener(type, listenerFn, useCapture); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Delegates event to a selector. |
|
* |
|
* @param {Element|String|Array} [elements] |
|
* @param {String} selector |
|
* @param {String} type |
|
* @param {Function} callback |
|
* @param {Boolean} useCapture |
|
* @return {Object} |
|
*/ |
|
function delegate(elements, selector, type, callback, useCapture) { |
|
// Handle the regular Element usage |
|
if (typeof elements.addEventListener === 'function') { |
|
return _delegate.apply(null, arguments); |
|
} |
|
|
|
// Handle Element-less usage, it defaults to global delegation |
|
if (typeof type === 'function') { |
|
// Use `document` as the first parameter, then apply arguments |
|
// This is a short way to .unshift `arguments` without running into deoptimizations |
|
return _delegate.bind(null, document).apply(null, arguments); |
|
} |
|
|
|
// Handle Selector-based usage |
|
if (typeof elements === 'string') { |
|
elements = document.querySelectorAll(elements); |
|
} |
|
|
|
// Handle Array-like based usage |
|
return Array.prototype.map.call(elements, function (element) { |
|
return _delegate(element, selector, type, callback, useCapture); |
|
}); |
|
} |
|
|
|
/** |
|
* Finds closest match and invokes callback. |
|
* |
|
* @param {Element} element |
|
* @param {String} selector |
|
* @param {String} type |
|
* @param {Function} callback |
|
* @return {Function} |
|
*/ |
|
function listener(element, selector, type, callback) { |
|
return function(e) { |
|
e.delegateTarget = closest(e.target, selector); |
|
|
|
if (e.delegateTarget) { |
|
callback.call(element, e); |
|
} |
|
} |
|
} |
|
|
|
module.exports = delegate; |
|
|
|
|
|
/***/ }), |
|
/* 7 */ |
|
/***/ (function(module, exports) { |
|
|
|
var DOCUMENT_NODE_TYPE = 9; |
|
|
|
/** |
|
* A polyfill for Element.matches() |
|
*/ |
|
if (typeof Element !== 'undefined' && !Element.prototype.matches) { |
|
var proto = Element.prototype; |
|
|
|
proto.matches = proto.matchesSelector || |
|
proto.mozMatchesSelector || |
|
proto.msMatchesSelector || |
|
proto.oMatchesSelector || |
|
proto.webkitMatchesSelector; |
|
} |
|
|
|
/** |
|
* Finds the closest parent that matches a selector. |
|
* |
|
* @param {Element} element |
|
* @param {String} selector |
|
* @return {Function} |
|
*/ |
|
function closest (element, selector) { |
|
while (element && element.nodeType !== DOCUMENT_NODE_TYPE) { |
|
if (typeof element.matches === 'function' && |
|
element.matches(selector)) { |
|
return element; |
|
} |
|
element = element.parentNode; |
|
} |
|
} |
|
|
|
module.exports = closest; |
|
|
|
|
|
/***/ }) |
|
/******/ ]); |
|
}); |
|
|
|
/***/ }), |
|
/* 225 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var __WEBPACK_AMD_DEFINE_RESULT__;/*global define:false */ |
|
/** |
|
* Copyright 2012-2017 Craig Campbell |
|
* |
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
|
* you may not use this file except in compliance with the License. |
|
* You may obtain a copy of the License at |
|
* |
|
* http://www.apache.org/licenses/LICENSE-2.0 |
|
* |
|
* Unless required by applicable law or agreed to in writing, software |
|
* distributed under the License is distributed on an "AS IS" BASIS, |
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
* See the License for the specific language governing permissions and |
|
* limitations under the License. |
|
* |
|
* Mousetrap is a simple keyboard shortcut library for Javascript with |
|
* no external dependencies |
|
* |
|
* @version 1.6.3 |
|
* @url craig.is/killing/mice |
|
*/ |
|
(function(window, document, undefined) { |
|
|
|
// Check if mousetrap is used inside browser, if not, return |
|
if (!window) { |
|
return; |
|
} |
|
|
|
/** |
|
* mapping of special keycodes to their corresponding keys |
|
* |
|
* everything in this dictionary cannot use keypress events |
|
* so it has to be here to map to the correct keycodes for |
|
* keyup/keydown events |
|
* |
|
* @type {Object} |
|
*/ |
|
var _MAP = { |
|
8: 'backspace', |
|
9: 'tab', |
|
13: 'enter', |
|
16: 'shift', |
|
17: 'ctrl', |
|
18: 'alt', |
|
20: 'capslock', |
|
27: 'esc', |
|
32: 'space', |
|
33: 'pageup', |
|
34: 'pagedown', |
|
35: 'end', |
|
36: 'home', |
|
37: 'left', |
|
38: 'up', |
|
39: 'right', |
|
40: 'down', |
|
45: 'ins', |
|
46: 'del', |
|
91: 'meta', |
|
93: 'meta', |
|
224: 'meta' |
|
}; |
|
|
|
/** |
|
* mapping for special characters so they can support |
|
* |
|
* this dictionary is only used incase you want to bind a |
|
* keyup or keydown event to one of these keys |
|
* |
|
* @type {Object} |
|
*/ |
|
var _KEYCODE_MAP = { |
|
106: '*', |
|
107: '+', |
|
109: '-', |
|
110: '.', |
|
111 : '/', |
|
186: ';', |
|
187: '=', |
|
188: ',', |
|
189: '-', |
|
190: '.', |
|
191: '/', |
|
192: '`', |
|
219: '[', |
|
220: '\\', |
|
221: ']', |
|
222: '\'' |
|
}; |
|
|
|
/** |
|
* this is a mapping of keys that require shift on a US keypad |
|
* back to the non shift equivelents |
|
* |
|
* this is so you can use keyup events with these keys |
|
* |
|
* note that this will only work reliably on US keyboards |
|
* |
|
* @type {Object} |
|
*/ |
|
var _SHIFT_MAP = { |
|
'~': '`', |
|
'!': '1', |
|
'@': '2', |
|
'#': '3', |
|
'$': '4', |
|
'%': '5', |
|
'^': '6', |
|
'&': '7', |
|
'*': '8', |
|
'(': '9', |
|
')': '0', |
|
'_': '-', |
|
'+': '=', |
|
':': ';', |
|
'\"': '\'', |
|
'<': ',', |
|
'>': '.', |
|
'?': '/', |
|
'|': '\\' |
|
}; |
|
|
|
/** |
|
* this is a list of special strings you can use to map |
|
* to modifier keys when you specify your keyboard shortcuts |
|
* |
|
* @type {Object} |
|
*/ |
|
var _SPECIAL_ALIASES = { |
|
'option': 'alt', |
|
'command': 'meta', |
|
'return': 'enter', |
|
'escape': 'esc', |
|
'plus': '+', |
|
'mod': /Mac|iPod|iPhone|iPad/.test(navigator.platform) ? 'meta' : 'ctrl' |
|
}; |
|
|
|
/** |
|
* variable to store the flipped version of _MAP from above |
|
* needed to check if we should use keypress or not when no action |
|
* is specified |
|
* |
|
* @type {Object|undefined} |
|
*/ |
|
var _REVERSE_MAP; |
|
|
|
/** |
|
* loop through the f keys, f1 to f19 and add them to the map |
|
* programatically |
|
*/ |
|
for (var i = 1; i < 20; ++i) { |
|
_MAP[111 + i] = 'f' + i; |
|
} |
|
|
|
/** |
|
* loop through to map numbers on the numeric keypad |
|
*/ |
|
for (i = 0; i <= 9; ++i) { |
|
|
|
// This needs to use a string cause otherwise since 0 is falsey |
|
// mousetrap will never fire for numpad 0 pressed as part of a keydown |
|
// event. |
|
// |
|
// @see https://github.com/ccampbell/mousetrap/pull/258 |
|
_MAP[i + 96] = i.toString(); |
|
} |
|
|
|
/** |
|
* cross browser add event method |
|
* |
|
* @param {Element|HTMLDocument} object |
|
* @param {string} type |
|
* @param {Function} callback |
|
* @returns void |
|
*/ |
|
function _addEvent(object, type, callback) { |
|
if (object.addEventListener) { |
|
object.addEventListener(type, callback, false); |
|
return; |
|
} |
|
|
|
object.attachEvent('on' + type, callback); |
|
} |
|
|
|
/** |
|
* takes the event and returns the key character |
|
* |
|
* @param {Event} e |
|
* @return {string} |
|
*/ |
|
function _characterFromEvent(e) { |
|
|
|
// for keypress events we should return the character as is |
|
if (e.type == 'keypress') { |
|
var character = String.fromCharCode(e.which); |
|
|
|
// if the shift key is not pressed then it is safe to assume |
|
// that we want the character to be lowercase. this means if |
|
// you accidentally have caps lock on then your key bindings |
|
// will continue to work |
|
// |
|
// the only side effect that might not be desired is if you |
|
// bind something like 'A' cause you want to trigger an |
|
// event when capital A is pressed caps lock will no longer |
|
// trigger the event. shift+a will though. |
|
if (!e.shiftKey) { |
|
character = character.toLowerCase(); |
|
} |
|
|
|
return character; |
|
} |
|
|
|
// for non keypress events the special maps are needed |
|
if (_MAP[e.which]) { |
|
return _MAP[e.which]; |
|
} |
|
|
|
if (_KEYCODE_MAP[e.which]) { |
|
return _KEYCODE_MAP[e.which]; |
|
} |
|
|
|
// if it is not in the special map |
|
|
|
// with keydown and keyup events the character seems to always |
|
// come in as an uppercase character whether you are pressing shift |
|
// or not. we should make sure it is always lowercase for comparisons |
|
return String.fromCharCode(e.which).toLowerCase(); |
|
} |
|
|
|
/** |
|
* checks if two arrays are equal |
|
* |
|
* @param {Array} modifiers1 |
|
* @param {Array} modifiers2 |
|
* @returns {boolean} |
|
*/ |
|
function _modifiersMatch(modifiers1, modifiers2) { |
|
return modifiers1.sort().join(',') === modifiers2.sort().join(','); |
|
} |
|
|
|
/** |
|
* takes a key event and figures out what the modifiers are |
|
* |
|
* @param {Event} e |
|
* @returns {Array} |
|
*/ |
|
function _eventModifiers(e) { |
|
var modifiers = []; |
|
|
|
if (e.shiftKey) { |
|
modifiers.push('shift'); |
|
} |
|
|
|
if (e.altKey) { |
|
modifiers.push('alt'); |
|
} |
|
|
|
if (e.ctrlKey) { |
|
modifiers.push('ctrl'); |
|
} |
|
|
|
if (e.metaKey) { |
|
modifiers.push('meta'); |
|
} |
|
|
|
return modifiers; |
|
} |
|
|
|
/** |
|
* prevents default for this event |
|
* |
|
* @param {Event} e |
|
* @returns void |
|
*/ |
|
function _preventDefault(e) { |
|
if (e.preventDefault) { |
|
e.preventDefault(); |
|
return; |
|
} |
|
|
|
e.returnValue = false; |
|
} |
|
|
|
/** |
|
* stops propogation for this event |
|
* |
|
* @param {Event} e |
|
* @returns void |
|
*/ |
|
function _stopPropagation(e) { |
|
if (e.stopPropagation) { |
|
e.stopPropagation(); |
|
return; |
|
} |
|
|
|
e.cancelBubble = true; |
|
} |
|
|
|
/** |
|
* determines if the keycode specified is a modifier key or not |
|
* |
|
* @param {string} key |
|
* @returns {boolean} |
|
*/ |
|
function _isModifier(key) { |
|
return key == 'shift' || key == 'ctrl' || key == 'alt' || key == 'meta'; |
|
} |
|
|
|
/** |
|
* reverses the map lookup so that we can look for specific keys |
|
* to see what can and can't use keypress |
|
* |
|
* @return {Object} |
|
*/ |
|
function _getReverseMap() { |
|
if (!_REVERSE_MAP) { |
|
_REVERSE_MAP = {}; |
|
for (var key in _MAP) { |
|
|
|
// pull out the numeric keypad from here cause keypress should |
|
// be able to detect the keys from the character |
|
if (key > 95 && key < 112) { |
|
continue; |
|
} |
|
|
|
if (_MAP.hasOwnProperty(key)) { |
|
_REVERSE_MAP[_MAP[key]] = key; |
|
} |
|
} |
|
} |
|
return _REVERSE_MAP; |
|
} |
|
|
|
/** |
|
* picks the best action based on the key combination |
|
* |
|
* @param {string} key - character for key |
|
* @param {Array} modifiers |
|
* @param {string=} action passed in |
|
*/ |
|
function _pickBestAction(key, modifiers, action) { |
|
|
|
// if no action was picked in we should try to pick the one |
|
// that we think would work best for this key |
|
if (!action) { |
|
action = _getReverseMap()[key] ? 'keydown' : 'keypress'; |
|
} |
|
|
|
// modifier keys don't work as expected with keypress, |
|
// switch to keydown |
|
if (action == 'keypress' && modifiers.length) { |
|
action = 'keydown'; |
|
} |
|
|
|
return action; |
|
} |
|
|
|
/** |
|
* Converts from a string key combination to an array |
|
* |
|
* @param {string} combination like "command+shift+l" |
|
* @return {Array} |
|
*/ |
|
function _keysFromString(combination) { |
|
if (combination === '+') { |
|
return ['+']; |
|
} |
|
|
|
combination = combination.replace(/\+{2}/g, '+plus'); |
|
return combination.split('+'); |
|
} |
|
|
|
/** |
|
* Gets info for a specific key combination |
|
* |
|
* @param {string} combination key combination ("command+s" or "a" or "*") |
|
* @param {string=} action |
|
* @returns {Object} |
|
*/ |
|
function _getKeyInfo(combination, action) { |
|
var keys; |
|
var key; |
|
var i; |
|
var modifiers = []; |
|
|
|
// take the keys from this pattern and figure out what the actual |
|
// pattern is all about |
|
keys = _keysFromString(combination); |
|
|
|
for (i = 0; i < keys.length; ++i) { |
|
key = keys[i]; |
|
|
|
// normalize key names |
|
if (_SPECIAL_ALIASES[key]) { |
|
key = _SPECIAL_ALIASES[key]; |
|
} |
|
|
|
// if this is not a keypress event then we should |
|
// be smart about using shift keys |
|
// this will only work for US keyboards however |
|
if (action && action != 'keypress' && _SHIFT_MAP[key]) { |
|
key = _SHIFT_MAP[key]; |
|
modifiers.push('shift'); |
|
} |
|
|
|
// if this key is a modifier then add it to the list of modifiers |
|
if (_isModifier(key)) { |
|
modifiers.push(key); |
|
} |
|
} |
|
|
|
// depending on what the key combination is |
|
// we will try to pick the best event for it |
|
action = _pickBestAction(key, modifiers, action); |
|
|
|
return { |
|
key: key, |
|
modifiers: modifiers, |
|
action: action |
|
}; |
|
} |
|
|
|
function _belongsTo(element, ancestor) { |
|
if (element === null || element === document) { |
|
return false; |
|
} |
|
|
|
if (element === ancestor) { |
|
return true; |
|
} |
|
|
|
return _belongsTo(element.parentNode, ancestor); |
|
} |
|
|
|
function Mousetrap(targetElement) { |
|
var self = this; |
|
|
|
targetElement = targetElement || document; |
|
|
|
if (!(self instanceof Mousetrap)) { |
|
return new Mousetrap(targetElement); |
|
} |
|
|
|
/** |
|
* element to attach key events to |
|
* |
|
* @type {Element} |
|
*/ |
|
self.target = targetElement; |
|
|
|
/** |
|
* a list of all the callbacks setup via Mousetrap.bind() |
|
* |
|
* @type {Object} |
|
*/ |
|
self._callbacks = {}; |
|
|
|
/** |
|
* direct map of string combinations to callbacks used for trigger() |
|
* |
|
* @type {Object} |
|
*/ |
|
self._directMap = {}; |
|
|
|
/** |
|
* keeps track of what level each sequence is at since multiple |
|
* sequences can start out with the same sequence |
|
* |
|
* @type {Object} |
|
*/ |
|
var _sequenceLevels = {}; |
|
|
|
/** |
|
* variable to store the setTimeout call |
|
* |
|
* @type {null|number} |
|
*/ |
|
var _resetTimer; |
|
|
|
/** |
|
* temporary state where we will ignore the next keyup |
|
* |
|
* @type {boolean|string} |
|
*/ |
|
var _ignoreNextKeyup = false; |
|
|
|
/** |
|
* temporary state where we will ignore the next keypress |
|
* |
|
* @type {boolean} |
|
*/ |
|
var _ignoreNextKeypress = false; |
|
|
|
/** |
|
* are we currently inside of a sequence? |
|
* type of action ("keyup" or "keydown" or "keypress") or false |
|
* |
|
* @type {boolean|string} |
|
*/ |
|
var _nextExpectedAction = false; |
|
|
|
/** |
|
* resets all sequence counters except for the ones passed in |
|
* |
|
* @param {Object} doNotReset |
|
* @returns void |
|
*/ |
|
function _resetSequences(doNotReset) { |
|
doNotReset = doNotReset || {}; |
|
|
|
var activeSequences = false, |
|
key; |
|
|
|
for (key in _sequenceLevels) { |
|
if (doNotReset[key]) { |
|
activeSequences = true; |
|
continue; |
|
} |
|
_sequenceLevels[key] = 0; |
|
} |
|
|
|
if (!activeSequences) { |
|
_nextExpectedAction = false; |
|
} |
|
} |
|
|
|
/** |
|
* finds all callbacks that match based on the keycode, modifiers, |
|
* and action |
|
* |
|
* @param {string} character |
|
* @param {Array} modifiers |
|
* @param {Event|Object} e |
|
* @param {string=} sequenceName - name of the sequence we are looking for |
|
* @param {string=} combination |
|
* @param {number=} level |
|
* @returns {Array} |
|
*/ |
|
function _getMatches(character, modifiers, e, sequenceName, combination, level) { |
|
var i; |
|
var callback; |
|
var matches = []; |
|
var action = e.type; |
|
|
|
// if there are no events related to this keycode |
|
if (!self._callbacks[character]) { |
|
return []; |
|
} |
|
|
|
// if a modifier key is coming up on its own we should allow it |
|
if (action == 'keyup' && _isModifier(character)) { |
|
modifiers = [character]; |
|
} |
|
|
|
// loop through all callbacks for the key that was pressed |
|
// and see if any of them match |
|
for (i = 0; i < self._callbacks[character].length; ++i) { |
|
callback = self._callbacks[character][i]; |
|
|
|
// if a sequence name is not specified, but this is a sequence at |
|
// the wrong level then move onto the next match |
|
if (!sequenceName && callback.seq && _sequenceLevels[callback.seq] != callback.level) { |
|
continue; |
|
} |
|
|
|
// if the action we are looking for doesn't match the action we got |
|
// then we should keep going |
|
if (action != callback.action) { |
|
continue; |
|
} |
|
|
|
// if this is a keypress event and the meta key and control key |
|
// are not pressed that means that we need to only look at the |
|
// character, otherwise check the modifiers as well |
|
// |
|
// chrome will not fire a keypress if meta or control is down |
|
// safari will fire a keypress if meta or meta+shift is down |
|
// firefox will fire a keypress if meta or control is down |
|
if ((action == 'keypress' && !e.metaKey && !e.ctrlKey) || _modifiersMatch(modifiers, callback.modifiers)) { |
|
|
|
// when you bind a combination or sequence a second time it |
|
// should overwrite the first one. if a sequenceName or |
|
// combination is specified in this call it does just that |
|
// |
|
// @todo make deleting its own method? |
|
var deleteCombo = !sequenceName && callback.combo == combination; |
|
var deleteSequence = sequenceName && callback.seq == sequenceName && callback.level == level; |
|
if (deleteCombo || deleteSequence) { |
|
self._callbacks[character].splice(i, 1); |
|
} |
|
|
|
matches.push(callback); |
|
} |
|
} |
|
|
|
return matches; |
|
} |
|
|
|
/** |
|
* actually calls the callback function |
|
* |
|
* if your callback function returns false this will use the jquery |
|
* convention - prevent default and stop propogation on the event |
|
* |
|
* @param {Function} callback |
|
* @param {Event} e |
|
* @returns void |
|
*/ |
|
function _fireCallback(callback, e, combo, sequence) { |
|
|
|
// if this event should not happen stop here |
|
if (self.stopCallback(e, e.target || e.srcElement, combo, sequence)) { |
|
return; |
|
} |
|
|
|
if (callback(e, combo) === false) { |
|
_preventDefault(e); |
|
_stopPropagation(e); |
|
} |
|
} |
|
|
|
/** |
|
* handles a character key event |
|
* |
|
* @param {string} character |
|
* @param {Array} modifiers |
|
* @param {Event} e |
|
* @returns void |
|
*/ |
|
self._handleKey = function(character, modifiers, e) { |
|
var callbacks = _getMatches(character, modifiers, e); |
|
var i; |
|
var doNotReset = {}; |
|
var maxLevel = 0; |
|
var processedSequenceCallback = false; |
|
|
|
// Calculate the maxLevel for sequences so we can only execute the longest callback sequence |
|
for (i = 0; i < callbacks.length; ++i) { |
|
if (callbacks[i].seq) { |
|
maxLevel = Math.max(maxLevel, callbacks[i].level); |
|
} |
|
} |
|
|
|
// loop through matching callbacks for this key event |
|
for (i = 0; i < callbacks.length; ++i) { |
|
|
|
// fire for all sequence callbacks |
|
// this is because if for example you have multiple sequences |
|
// bound such as "g i" and "g t" they both need to fire the |
|
// callback for matching g cause otherwise you can only ever |
|
// match the first one |
|
if (callbacks[i].seq) { |
|
|
|
// only fire callbacks for the maxLevel to prevent |
|
// subsequences from also firing |
|
// |
|
// for example 'a option b' should not cause 'option b' to fire |
|
// even though 'option b' is part of the other sequence |
|
// |
|
// any sequences that do not match here will be discarded |
|
// below by the _resetSequences call |
|
if (callbacks[i].level != maxLevel) { |
|
continue; |
|
} |
|
|
|
processedSequenceCallback = true; |
|
|
|
// keep a list of which sequences were matches for later |
|
doNotReset[callbacks[i].seq] = 1; |
|
_fireCallback(callbacks[i].callback, e, callbacks[i].combo, callbacks[i].seq); |
|
continue; |
|
} |
|
|
|
// if there were no sequence matches but we are still here |
|
// that means this is a regular match so we should fire that |
|
if (!processedSequenceCallback) { |
|
_fireCallback(callbacks[i].callback, e, callbacks[i].combo); |
|
} |
|
} |
|
|
|
// if the key you pressed matches the type of sequence without |
|
// being a modifier (ie "keyup" or "keypress") then we should |
|
// reset all sequences that were not matched by this event |
|
// |
|
// this is so, for example, if you have the sequence "h a t" and you |
|
// type "h e a r t" it does not match. in this case the "e" will |
|
// cause the sequence to reset |
|
// |
|
// modifier keys are ignored because you can have a sequence |
|
// that contains modifiers such as "enter ctrl+space" and in most |
|
// cases the modifier key will be pressed before the next key |
|
// |
|
// also if you have a sequence such as "ctrl+b a" then pressing the |
|
// "b" key will trigger a "keypress" and a "keydown" |
|
// |
|
// the "keydown" is expected when there is a modifier, but the |
|
// "keypress" ends up matching the _nextExpectedAction since it occurs |
|
// after and that causes the sequence to reset |
|
// |
|
// we ignore keypresses in a sequence that directly follow a keydown |
|
// for the same character |
|
var ignoreThisKeypress = e.type == 'keypress' && _ignoreNextKeypress; |
|
if (e.type == _nextExpectedAction && !_isModifier(character) && !ignoreThisKeypress) { |
|
_resetSequences(doNotReset); |
|
} |
|
|
|
_ignoreNextKeypress = processedSequenceCallback && e.type == 'keydown'; |
|
}; |
|
|
|
/** |
|
* handles a keydown event |
|
* |
|
* @param {Event} e |
|
* @returns void |
|
*/ |
|
function _handleKeyEvent(e) { |
|
|
|
// normalize e.which for key events |
|
// @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion |
|
if (typeof e.which !== 'number') { |
|
e.which = e.keyCode; |
|
} |
|
|
|
var character = _characterFromEvent(e); |
|
|
|
// no character found then stop |
|
if (!character) { |
|
return; |
|
} |
|
|
|
// need to use === for the character check because the character can be 0 |
|
if (e.type == 'keyup' && _ignoreNextKeyup === character) { |
|
_ignoreNextKeyup = false; |
|
return; |
|
} |
|
|
|
self.handleKey(character, _eventModifiers(e), e); |
|
} |
|
|
|
/** |
|
* called to set a 1 second timeout on the specified sequence |
|
* |
|
* this is so after each key press in the sequence you have 1 second |
|
* to press the next key before you have to start over |
|
* |
|
* @returns void |
|
*/ |
|
function _resetSequenceTimer() { |
|
clearTimeout(_resetTimer); |
|
_resetTimer = setTimeout(_resetSequences, 1000); |
|
} |
|
|
|
/** |
|
* binds a key sequence to an event |
|
* |
|
* @param {string} combo - combo specified in bind call |
|
* @param {Array} keys |
|
* @param {Function} callback |
|
* @param {string=} action |
|
* @returns void |
|
*/ |
|
function _bindSequence(combo, keys, callback, action) { |
|
|
|
// start off by adding a sequence level record for this combination |
|
// and setting the level to 0 |
|
_sequenceLevels[combo] = 0; |
|
|
|
/** |
|
* callback to increase the sequence level for this sequence and reset |
|
* all other sequences that were active |
|
* |
|
* @param {string} nextAction |
|
* @returns {Function} |
|
*/ |
|
function _increaseSequence(nextAction) { |
|
return function() { |
|
_nextExpectedAction = nextAction; |
|
++_sequenceLevels[combo]; |
|
_resetSequenceTimer(); |
|
}; |
|
} |
|
|
|
/** |
|
* wraps the specified callback inside of another function in order |
|
* to reset all sequence counters as soon as this sequence is done |
|
* |
|
* @param {Event} e |
|
* @returns void |
|
*/ |
|
function _callbackAndReset(e) { |
|
_fireCallback(callback, e, combo); |
|
|
|
// we should ignore the next key up if the action is key down |
|
// or keypress. this is so if you finish a sequence and |
|
// release the key the final key will not trigger a keyup |
|
if (action !== 'keyup') { |
|
_ignoreNextKeyup = _characterFromEvent(e); |
|
} |
|
|
|
// weird race condition if a sequence ends with the key |
|
// another sequence begins with |
|
setTimeout(_resetSequences, 10); |
|
} |
|
|
|
// loop through keys one at a time and bind the appropriate callback |
|
// function. for any key leading up to the final one it should |
|
// increase the sequence. after the final, it should reset all sequences |
|
// |
|
// if an action is specified in the original bind call then that will |
|
// be used throughout. otherwise we will pass the action that the |
|
// next key in the sequence should match. this allows a sequence |
|
// to mix and match keypress and keydown events depending on which |
|
// ones are better suited to the key provided |
|
for (var i = 0; i < keys.length; ++i) { |
|
var isFinal = i + 1 === keys.length; |
|
var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence(action || _getKeyInfo(keys[i + 1]).action); |
|
_bindSingle(keys[i], wrappedCallback, action, combo, i); |
|
} |
|
} |
|
|
|
/** |
|
* binds a single keyboard combination |
|
* |
|
* @param {string} combination |
|
* @param {Function} callback |
|
* @param {string=} action |
|
* @param {string=} sequenceName - name of sequence if part of sequence |
|
* @param {number=} level - what part of the sequence the command is |
|
* @returns void |
|
*/ |
|
function _bindSingle(combination, callback, action, sequenceName, level) { |
|
|
|
// store a direct mapped reference for use with Mousetrap.trigger |
|
self._directMap[combination + ':' + action] = callback; |
|
|
|
// make sure multiple spaces in a row become a single space |
|
combination = combination.replace(/\s+/g, ' '); |
|
|
|
var sequence = combination.split(' '); |
|
var info; |
|
|
|
// if this pattern is a sequence of keys then run through this method |
|
// to reprocess each pattern one key at a time |
|
if (sequence.length > 1) { |
|
_bindSequence(combination, sequence, callback, action); |
|
return; |
|
} |
|
|
|
info = _getKeyInfo(combination, action); |
|
|
|
// make sure to initialize array if this is the first time |
|
// a callback is added for this key |
|
self._callbacks[info.key] = self._callbacks[info.key] || []; |
|
|
|
// remove an existing match if there is one |
|
_getMatches(info.key, info.modifiers, {type: info.action}, sequenceName, combination, level); |
|
|
|
// add this call back to the array |
|
// if it is a sequence put it at the beginning |
|
// if not put it at the end |
|
// |
|
// this is important because the way these are processed expects |
|
// the sequence ones to come first |
|
self._callbacks[info.key][sequenceName ? 'unshift' : 'push']({ |
|
callback: callback, |
|
modifiers: info.modifiers, |
|
action: info.action, |
|
seq: sequenceName, |
|
level: level, |
|
combo: combination |
|
}); |
|
} |
|
|
|
/** |
|
* binds multiple combinations to the same callback |
|
* |
|
* @param {Array} combinations |
|
* @param {Function} callback |
|
* @param {string|undefined} action |
|
* @returns void |
|
*/ |
|
self._bindMultiple = function(combinations, callback, action) { |
|
for (var i = 0; i < combinations.length; ++i) { |
|
_bindSingle(combinations[i], callback, action); |
|
} |
|
}; |
|
|
|
// start! |
|
_addEvent(targetElement, 'keypress', _handleKeyEvent); |
|
_addEvent(targetElement, 'keydown', _handleKeyEvent); |
|
_addEvent(targetElement, 'keyup', _handleKeyEvent); |
|
} |
|
|
|
/** |
|
* binds an event to mousetrap |
|
* |
|
* can be a single key, a combination of keys separated with +, |
|
* an array of keys, or a sequence of keys separated by spaces |
|
* |
|
* be sure to list the modifier keys first to make sure that the |
|
* correct key ends up getting bound (the last key in the pattern) |
|
* |
|
* @param {string|Array} keys |
|
* @param {Function} callback |
|
* @param {string=} action - 'keypress', 'keydown', or 'keyup' |
|
* @returns void |
|
*/ |
|
Mousetrap.prototype.bind = function(keys, callback, action) { |
|
var self = this; |
|
keys = keys instanceof Array ? keys : [keys]; |
|
self._bindMultiple.call(self, keys, callback, action); |
|
return self; |
|
}; |
|
|
|
/** |
|
* unbinds an event to mousetrap |
|
* |
|
* the unbinding sets the callback function of the specified key combo |
|
* to an empty function and deletes the corresponding key in the |
|
* _directMap dict. |
|
* |
|
* TODO: actually remove this from the _callbacks dictionary instead |
|
* of binding an empty function |
|
* |
|
* the keycombo+action has to be exactly the same as |
|
* it was defined in the bind method |
|
* |
|
* @param {string|Array} keys |
|
* @param {string} action |
|
* @returns void |
|
*/ |
|
Mousetrap.prototype.unbind = function(keys, action) { |
|
var self = this; |
|
return self.bind.call(self, keys, function() {}, action); |
|
}; |
|
|
|
/** |
|
* triggers an event that has already been bound |
|
* |
|
* @param {string} keys |
|
* @param {string=} action |
|
* @returns void |
|
*/ |
|
Mousetrap.prototype.trigger = function(keys, action) { |
|
var self = this; |
|
if (self._directMap[keys + ':' + action]) { |
|
self._directMap[keys + ':' + action]({}, keys); |
|
} |
|
return self; |
|
}; |
|
|
|
/** |
|
* resets the library back to its initial state. this is useful |
|
* if you want to clear out the current keyboard shortcuts and bind |
|
* new ones - for example if you switch to another page |
|
* |
|
* @returns void |
|
*/ |
|
Mousetrap.prototype.reset = function() { |
|
var self = this; |
|
self._callbacks = {}; |
|
self._directMap = {}; |
|
return self; |
|
}; |
|
|
|
/** |
|
* should we stop this event before firing off callbacks |
|
* |
|
* @param {Event} e |
|
* @param {Element} element |
|
* @return {boolean} |
|
*/ |
|
Mousetrap.prototype.stopCallback = function(e, element) { |
|
var self = this; |
|
|
|
// if the element has the class "mousetrap" then no need to stop |
|
if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) { |
|
return false; |
|
} |
|
|
|
if (_belongsTo(element, self.target)) { |
|
return false; |
|
} |
|
|
|
// Events originating from a shadow DOM are re-targetted and `e.target` is the shadow host, |
|
// not the initial event target in the shadow tree. Note that not all events cross the |
|
// shadow boundary. |
|
// For shadow trees with `mode: 'open'`, the initial event target is the first element in |
|
// the event’s composed path. For shadow trees with `mode: 'closed'`, the initial event |
|
// target cannot be obtained. |
|
if ('composedPath' in e && typeof e.composedPath === 'function') { |
|
// For open shadow trees, update `element` so that the following check works. |
|
var initialEventTarget = e.composedPath()[0]; |
|
if (initialEventTarget !== e.target) { |
|
element = initialEventTarget; |
|
} |
|
} |
|
|
|
// stop for input, select, and textarea |
|
return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || element.isContentEditable; |
|
}; |
|
|
|
/** |
|
* exposes _handleKey publicly so it can be overwritten by extensions |
|
*/ |
|
Mousetrap.prototype.handleKey = function() { |
|
var self = this; |
|
return self._handleKey.apply(self, arguments); |
|
}; |
|
|
|
/** |
|
* allow custom key mappings |
|
*/ |
|
Mousetrap.addKeycodes = function(object) { |
|
for (var key in object) { |
|
if (object.hasOwnProperty(key)) { |
|
_MAP[key] = object[key]; |
|
} |
|
} |
|
_REVERSE_MAP = null; |
|
}; |
|
|
|
/** |
|
* Init the global mousetrap functions |
|
* |
|
* This method is needed to allow the global mousetrap functions to work |
|
* now that mousetrap is a constructor function. |
|
*/ |
|
Mousetrap.init = function() { |
|
var documentMousetrap = Mousetrap(document); |
|
for (var method in documentMousetrap) { |
|
if (method.charAt(0) !== '_') { |
|
Mousetrap[method] = (function(method) { |
|
return function() { |
|
return documentMousetrap[method].apply(documentMousetrap, arguments); |
|
}; |
|
} (method)); |
|
} |
|
} |
|
}; |
|
|
|
Mousetrap.init(); |
|
|
|
// expose mousetrap to the global object |
|
window.Mousetrap = Mousetrap; |
|
|
|
// expose as a common js module |
|
if ( true && module.exports) { |
|
module.exports = Mousetrap; |
|
} |
|
|
|
// expose mousetrap as an AMD module |
|
if (true) { |
|
!(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { |
|
return Mousetrap; |
|
}).call(exports, __webpack_require__, exports, module), |
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); |
|
} |
|
}) (typeof window !== 'undefined' ? window : null, typeof window !== 'undefined' ? document : null); |
|
|
|
|
|
/***/ }), |
|
/* 226 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
// eslint-disable-next-line import/no-unresolved |
|
module.exports = __webpack_require__(266); |
|
|
|
|
|
/***/ }), |
|
/* 227 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
var __extends = (this && this.__extends) || (function () { |
|
var extendStatics = function (d, b) { |
|
extendStatics = Object.setPrototypeOf || |
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || |
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; |
|
return extendStatics(d, b); |
|
}; |
|
return function (d, b) { |
|
extendStatics(d, b); |
|
function __() { this.constructor = d; } |
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); |
|
}; |
|
})(); |
|
var __assign = (this && this.__assign) || function () { |
|
__assign = Object.assign || function(t) { |
|
for (var s, i = 1, n = arguments.length; i < n; i++) { |
|
s = arguments[i]; |
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) |
|
t[p] = s[p]; |
|
} |
|
return t; |
|
}; |
|
return __assign.apply(this, arguments); |
|
}; |
|
var __importStar = (this && this.__importStar) || function (mod) { |
|
if (mod && mod.__esModule) return mod; |
|
var result = {}; |
|
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; |
|
result["default"] = mod; |
|
return result; |
|
}; |
|
var __importDefault = (this && this.__importDefault) || function (mod) { |
|
return (mod && mod.__esModule) ? mod : { "default": mod }; |
|
}; |
|
Object.defineProperty(exports, "__esModule", { value: true }); |
|
var React = __importStar(__webpack_require__(28)); |
|
var resizer_1 = __webpack_require__(314); |
|
var fast_memoize_1 = __importDefault(__webpack_require__(315)); |
|
var DEFAULT_SIZE = { |
|
width: 'auto', |
|
height: 'auto', |
|
}; |
|
var clamp = fast_memoize_1.default(function (n, min, max) { return Math.max(Math.min(n, max), min); }); |
|
var snap = fast_memoize_1.default(function (n, size) { return Math.round(n / size) * size; }); |
|
var hasDirection = fast_memoize_1.default(function (dir, target) { return new RegExp(dir, 'i').test(target); }); |
|
var findClosestSnap = fast_memoize_1.default(function (n, snapArray, snapGap) { |
|
if (snapGap === void 0) { snapGap = 0; } |
|
var closestGapIndex = snapArray.reduce(function (prev, curr, index) { return (Math.abs(curr - n) < Math.abs(snapArray[prev] - n) ? index : prev); }, 0); |
|
var gap = Math.abs(snapArray[closestGapIndex] - n); |
|
return snapGap === 0 || gap < snapGap ? snapArray[closestGapIndex] : n; |
|
}); |
|
var endsWith = fast_memoize_1.default(function (str, searchStr) { |
|
return str.substr(str.length - searchStr.length, searchStr.length) === searchStr; |
|
}); |
|
var getStringSize = fast_memoize_1.default(function (n) { |
|
n = n.toString(); |
|
if (n === 'auto') { |
|
return n; |
|
} |
|
if (endsWith(n, 'px')) { |
|
return n; |
|
} |
|
if (endsWith(n, '%')) { |
|
return n; |
|
} |
|
if (endsWith(n, 'vh')) { |
|
return n; |
|
} |
|
if (endsWith(n, 'vw')) { |
|
return n; |
|
} |
|
if (endsWith(n, 'vmax')) { |
|
return n; |
|
} |
|
if (endsWith(n, 'vmin')) { |
|
return n; |
|
} |
|
return n + "px"; |
|
}); |
|
var getPixelSize = function (size, parentSize) { |
|
if (size && typeof size === 'string') { |
|
if (endsWith(size, '%')) { |
|
var ratio = Number(size.replace('%', '')) / 100; |
|
return parentSize * ratio; |
|
} |
|
else if (endsWith(size, 'vw')) { |
|
var ratio = Number(size.replace('vw', '')) / 100; |
|
return window.innerWidth * ratio; |
|
} |
|
else if (endsWith(size, 'vh')) { |
|
var ratio = Number(size.replace('vh', '')) / 100; |
|
return window.innerHeight * ratio; |
|
} |
|
} |
|
return size; |
|
}; |
|
var calculateNewMax = fast_memoize_1.default(function (parentSize, maxWidth, maxHeight, minWidth, minHeight) { |
|
maxWidth = getPixelSize(maxWidth, parentSize.width); |
|
maxHeight = getPixelSize(maxHeight, parentSize.height); |
|
minWidth = getPixelSize(minWidth, parentSize.width); |
|
minHeight = getPixelSize(minHeight, parentSize.height); |
|
return { |
|
maxWidth: typeof maxWidth === 'undefined' ? undefined : Number(maxWidth), |
|
maxHeight: typeof maxHeight === 'undefined' ? undefined : Number(maxHeight), |
|
minWidth: typeof minWidth === 'undefined' ? undefined : Number(minWidth), |
|
minHeight: typeof minHeight === 'undefined' ? undefined : Number(minHeight), |
|
}; |
|
}); |
|
var definedProps = [ |
|
'style', |
|
'className', |
|
'grid', |
|
'snap', |
|
'bounds', |
|
'size', |
|
'defaultSize', |
|
'minWidth', |
|
'minHeight', |
|
'maxWidth', |
|
'maxHeight', |
|
'lockAspectRatio', |
|
'lockAspectRatioExtraWidth', |
|
'lockAspectRatioExtraHeight', |
|
'enable', |
|
'handleStyles', |
|
'handleClasses', |
|
'handleWrapperStyle', |
|
'handleWrapperClass', |
|
'children', |
|
'onResizeStart', |
|
'onResize', |
|
'onResizeStop', |
|
'handleComponent', |
|
'scale', |
|
'resizeRatio', |
|
'snapGap', |
|
]; |
|
// HACK: This class is used to calculate % size. |
|
var baseClassName = '__resizable_base__'; |
|
var Resizable = /** @class */ (function (_super) { |
|
__extends(Resizable, _super); |
|
function Resizable(props) { |
|
var _this = _super.call(this, props) || this; |
|
_this.ratio = 1; |
|
_this.resizable = null; |
|
// For parent boundary |
|
_this.parentLeft = 0; |
|
_this.parentTop = 0; |
|
// For boundary |
|
_this.resizableLeft = 0; |
|
_this.resizableTop = 0; |
|
// For target boundary |
|
_this.targetLeft = 0; |
|
_this.targetTop = 0; |
|
_this.state = { |
|
isResizing: false, |
|
resizeCursor: 'auto', |
|
width: typeof (_this.propsSize && _this.propsSize.width) === 'undefined' |
|
? 'auto' |
|
: _this.propsSize && _this.propsSize.width, |
|
height: typeof (_this.propsSize && _this.propsSize.height) === 'undefined' |
|
? 'auto' |
|
: _this.propsSize && _this.propsSize.height, |
|
direction: 'right', |
|
original: { |
|
x: 0, |
|
y: 0, |
|
width: 0, |
|
height: 0, |
|
}, |
|
}; |
|
_this.onResizeStart = _this.onResizeStart.bind(_this); |
|
_this.onMouseMove = _this.onMouseMove.bind(_this); |
|
_this.onMouseUp = _this.onMouseUp.bind(_this); |
|
return _this; |
|
} |
|
Object.defineProperty(Resizable.prototype, "parentNode", { |
|
get: function () { |
|
if (!this.resizable) { |
|
return null; |
|
} |
|
return this.resizable.parentNode; |
|
}, |
|
enumerable: true, |
|
configurable: true |
|
}); |
|
Object.defineProperty(Resizable.prototype, "propsSize", { |
|
get: function () { |
|
return this.props.size || this.props.defaultSize || DEFAULT_SIZE; |
|
}, |
|
enumerable: true, |
|
configurable: true |
|
}); |
|
Object.defineProperty(Resizable.prototype, "base", { |
|
get: function () { |
|
var parent = this.parentNode; |
|
if (!parent) { |
|
return undefined; |
|
} |
|
var children = [].slice.call(parent.children); |
|
for (var _i = 0, children_1 = children; _i < children_1.length; _i++) { |
|
var n = children_1[_i]; |
|
if (n instanceof HTMLElement) { |
|
if (n.classList.contains(baseClassName)) { |
|
return n; |
|
} |
|
} |
|
} |
|
return undefined; |
|
}, |
|
enumerable: true, |
|
configurable: true |
|
}); |
|
Object.defineProperty(Resizable.prototype, "size", { |
|
get: function () { |
|
var width = 0; |
|
var height = 0; |
|
if (typeof window !== 'undefined' && this.resizable) { |
|
var orgWidth = this.resizable.offsetWidth; |
|
var orgHeight = this.resizable.offsetHeight; |
|
// HACK: Set position `relative` to get parent size. |
|
// This is because when re-resizable set `absolute`, I can not get base width correctly. |
|
var orgPosition = this.resizable.style.position; |
|
if (orgPosition !== 'relative') { |
|
this.resizable.style.position = 'relative'; |
|
} |
|
// INFO: Use original width or height if set auto. |
|
width = this.resizable.style.width !== 'auto' ? this.resizable.offsetWidth : orgWidth; |
|
height = this.resizable.style.height !== 'auto' ? this.resizable.offsetHeight : orgHeight; |
|
// Restore original position |
|
this.resizable.style.position = orgPosition; |
|
} |
|
return { width: width, height: height }; |
|
}, |
|
enumerable: true, |
|
configurable: true |
|
}); |
|
Object.defineProperty(Resizable.prototype, "sizeStyle", { |
|
get: function () { |
|
var _this = this; |
|
var size = this.props.size; |
|
var getSize = function (key) { |
|
if (typeof _this.state[key] === 'undefined' || _this.state[key] === 'auto') { |
|
return 'auto'; |
|
} |
|
if (_this.propsSize && _this.propsSize[key] && endsWith(_this.propsSize[key].toString(), '%')) { |
|
if (endsWith(_this.state[key].toString(), '%')) { |
|
return _this.state[key].toString(); |
|
} |
|
var parentSize = _this.getParentSize(); |
|
var value = Number(_this.state[key].toString().replace('px', '')); |
|
var percent = (value / parentSize[key]) * 100; |
|
return percent + "%"; |
|
} |
|
return getStringSize(_this.state[key]); |
|
}; |
|
var width = size && typeof size.width !== 'undefined' && !this.state.isResizing |
|
? getStringSize(size.width) |
|
: getSize('width'); |
|
var height = size && typeof size.height !== 'undefined' && !this.state.isResizing |
|
? getStringSize(size.height) |
|
: getSize('height'); |
|
return { width: width, height: height }; |
|
}, |
|
enumerable: true, |
|
configurable: true |
|
}); |
|
Resizable.prototype.getParentSize = function () { |
|
if (!this.base || !this.parentNode) { |
|
return { width: window.innerWidth, height: window.innerHeight }; |
|
} |
|
// INFO: To calculate parent width with flex layout |
|
var wrapChanged = false; |
|
var wrap = this.parentNode.style.flexWrap; |
|
var minWidth = this.base.style.minWidth; |
|
if (wrap !== 'wrap') { |
|
wrapChanged = true; |
|
this.parentNode.style.flexWrap = 'wrap'; |
|
// HACK: Use relative to get parent padding size |
|
} |
|
this.base.style.position = 'relative'; |
|
this.base.style.minWidth = '100%'; |
|
var size = { |
|
width: this.base.offsetWidth, |
|
height: this.base.offsetHeight, |
|
}; |
|
this.base.style.position = 'absolute'; |
|
if (wrapChanged) { |
|
this.parentNode.style.flexWrap = wrap; |
|
} |
|
this.base.style.minWidth = minWidth; |
|
return size; |
|
}; |
|
Resizable.prototype.bindEvents = function () { |
|
if (typeof window !== 'undefined') { |
|
window.addEventListener('mouseup', this.onMouseUp); |
|
window.addEventListener('mousemove', this.onMouseMove); |
|
window.addEventListener('mouseleave', this.onMouseUp); |
|
window.addEventListener('touchmove', this.onMouseMove); |
|
window.addEventListener('touchend', this.onMouseUp); |
|
} |
|
}; |
|
Resizable.prototype.unbindEvents = function () { |
|
if (typeof window !== 'undefined') { |
|
window.removeEventListener('mouseup', this.onMouseUp); |
|
window.removeEventListener('mousemove', this.onMouseMove); |
|
window.removeEventListener('mouseleave', this.onMouseUp); |
|
window.removeEventListener('touchmove', this.onMouseMove); |
|
window.removeEventListener('touchend', this.onMouseUp); |
|
} |
|
}; |
|
Resizable.prototype.componentDidMount = function () { |
|
this.setState({ |
|
width: this.state.width || this.size.width, |
|
height: this.state.height || this.size.height, |
|
}); |
|
var parent = this.parentNode; |
|
if (!(parent instanceof HTMLElement)) { |
|
return; |
|
} |
|
if (this.base) { |
|
return; |
|
} |
|
var element = document.createElement('div'); |
|
element.style.width = '100%'; |
|
element.style.height = '100%'; |
|
element.style.position = 'absolute'; |
|
element.style.transform = 'scale(0, 0)'; |
|
element.style.left = '0'; |
|
element.style.flex = '0'; |
|
if (element.classList) { |
|
element.classList.add(baseClassName); |
|
} |
|
else { |
|
element.className += baseClassName; |
|
} |
|
parent.appendChild(element); |
|
}; |
|
Resizable.prototype.componentWillUnmount = function () { |
|
if (typeof window !== 'undefined') { |
|
this.unbindEvents(); |
|
var parent_1 = this.parentNode; |
|
if (!this.base || !parent_1) { |
|
return; |
|
} |
|
if (!(parent_1 instanceof HTMLElement) || !(this.base instanceof Node)) { |
|
return; |
|
} |
|
parent_1.removeChild(this.base); |
|
} |
|
}; |
|
Resizable.prototype.createSizeForCssProperty = function (newSize, kind) { |
|
var propsSize = this.propsSize && this.propsSize[kind]; |
|
return this.state[kind] === 'auto' && |
|
this.state.original[kind] === newSize && |
|
(typeof propsSize === 'undefined' || propsSize === 'auto') |
|
? 'auto' |
|
: newSize; |
|
}; |
|
Resizable.prototype.calculateNewMaxFromBoundary = function (maxWidth, maxHeight) { |
|
if (this.props.bounds === 'parent') { |
|
var parent_2 = this.parentNode; |
|
if (parent_2 instanceof HTMLElement) { |
|
var boundWidth = parent_2.offsetWidth + (this.parentLeft - this.resizableLeft); |
|
var boundHeight = parent_2.offsetHeight + (this.parentTop - this.resizableTop); |
|
maxWidth = maxWidth && maxWidth < boundWidth ? maxWidth : boundWidth; |
|
maxHeight = maxHeight && maxHeight < boundHeight ? maxHeight : boundHeight; |
|
} |
|
} |
|
else if (this.props.bounds === 'window') { |
|
if (typeof window !== 'undefined') { |
|
var boundWidth = window.innerWidth - this.resizableLeft; |
|
var boundHeight = window.innerHeight - this.resizableTop; |
|
maxWidth = maxWidth && maxWidth < boundWidth ? maxWidth : boundWidth; |
|
maxHeight = maxHeight && maxHeight < boundHeight ? maxHeight : boundHeight; |
|
} |
|
} |
|
else if (this.props.bounds instanceof HTMLElement) { |
|
var boundWidth = this.props.bounds.offsetWidth + (this.targetLeft - this.resizableLeft); |
|
var boundHeight = this.props.bounds.offsetHeight + (this.targetTop - this.resizableTop); |
|
maxWidth = maxWidth && maxWidth < boundWidth ? maxWidth : boundWidth; |
|
maxHeight = maxHeight && maxHeight < boundHeight ? maxHeight : boundHeight; |
|
} |
|
return { maxWidth: maxWidth, maxHeight: maxHeight }; |
|
}; |
|
Resizable.prototype.calculateNewSizeFromDirection = function (clientX, clientY) { |
|
var scale = this.props.scale || 1; |
|
var resizeRatio = this.props.resizeRatio || 1; |
|
var _a = this.state, direction = _a.direction, original = _a.original; |
|
var _b = this.props, lockAspectRatio = _b.lockAspectRatio, lockAspectRatioExtraHeight = _b.lockAspectRatioExtraHeight, lockAspectRatioExtraWidth = _b.lockAspectRatioExtraWidth; |
|
var newWidth = original.width; |
|
var newHeight = original.height; |
|
var extraHeight = lockAspectRatioExtraHeight || 0; |
|
var extraWidth = lockAspectRatioExtraWidth || 0; |
|
if (hasDirection('right', direction)) { |
|
newWidth = original.width + ((clientX - original.x) * resizeRatio) / scale; |
|
if (lockAspectRatio) { |
|
newHeight = (newWidth - extraWidth) / this.ratio + extraHeight; |
|
} |
|
} |
|
if (hasDirection('left', direction)) { |
|
newWidth = original.width - ((clientX - original.x) * resizeRatio) / scale; |
|
if (lockAspectRatio) { |
|
newHeight = (newWidth - extraWidth) / this.ratio + extraHeight; |
|
} |
|
} |
|
if (hasDirection('bottom', direction)) { |
|
newHeight = original.height + ((clientY - original.y) * resizeRatio) / scale; |
|
if (lockAspectRatio) { |
|
newWidth = (newHeight - extraHeight) * this.ratio + extraWidth; |
|
} |
|
} |
|
if (hasDirection('top', direction)) { |
|
newHeight = original.height - ((clientY - original.y) * resizeRatio) / scale; |
|
if (lockAspectRatio) { |
|
newWidth = (newHeight - extraHeight) * this.ratio + extraWidth; |
|
} |
|
} |
|
return { newWidth: newWidth, newHeight: newHeight }; |
|
}; |
|
Resizable.prototype.calculateNewSizeFromAspectRatio = function (newWidth, newHeight, max, min) { |
|
var _a = this.props, lockAspectRatio = _a.lockAspectRatio, lockAspectRatioExtraHeight = _a.lockAspectRatioExtraHeight, lockAspectRatioExtraWidth = _a.lockAspectRatioExtraWidth; |
|
var computedMinWidth = typeof min.width === 'undefined' ? 10 : min.width; |
|
var computedMaxWidth = typeof max.width === 'undefined' || max.width < 0 ? newWidth : max.width; |
|
var computedMinHeight = typeof min.height === 'undefined' ? 10 : min.height; |
|
var computedMaxHeight = typeof max.height === 'undefined' || max.height < 0 ? newHeight : max.height; |
|
var extraHeight = lockAspectRatioExtraHeight || 0; |
|
var extraWidth = lockAspectRatioExtraWidth || 0; |
|
if (lockAspectRatio) { |
|
var extraMinWidth = (computedMinHeight - extraHeight) * this.ratio + extraWidth; |
|
var extraMaxWidth = (computedMaxHeight - extraHeight) * this.ratio + extraWidth; |
|
var extraMinHeight = (computedMinWidth - extraWidth) / this.ratio + extraHeight; |
|
var extraMaxHeight = (computedMaxWidth - extraWidth) / this.ratio + extraHeight; |
|
var lockedMinWidth = Math.max(computedMinWidth, extraMinWidth); |
|
var lockedMaxWidth = Math.min(computedMaxWidth, extraMaxWidth); |
|
var lockedMinHeight = Math.max(computedMinHeight, extraMinHeight); |
|
var lockedMaxHeight = Math.min(computedMaxHeight, extraMaxHeight); |
|
newWidth = clamp(newWidth, lockedMinWidth, lockedMaxWidth); |
|
newHeight = clamp(newHeight, lockedMinHeight, lockedMaxHeight); |
|
} |
|
else { |
|
newWidth = clamp(newWidth, computedMinWidth, computedMaxWidth); |
|
newHeight = clamp(newHeight, computedMinHeight, computedMaxHeight); |
|
} |
|
return { newWidth: newWidth, newHeight: newHeight }; |
|
}; |
|
Resizable.prototype.setBoundingClientRect = function () { |
|
// For parent boundary |
|
if (this.props.bounds === 'parent') { |
|
var parent_3 = this.parentNode; |
|
if (parent_3 instanceof HTMLElement) { |
|
var parentRect = parent_3.getBoundingClientRect(); |
|
this.parentLeft = parentRect.left; |
|
this.parentTop = parentRect.top; |
|
} |
|
} |
|
// For target(html element) boundary |
|
if (this.props.bounds instanceof HTMLElement) { |
|
var targetRect = this.props.bounds.getBoundingClientRect(); |
|
this.targetLeft = targetRect.left; |
|
this.targetTop = targetRect.top; |
|
} |
|
// For boundary |
|
if (this.resizable) { |
|
var _a = this.resizable.getBoundingClientRect(), left = _a.left, top_1 = _a.top; |
|
this.resizableLeft = left; |
|
this.resizableTop = top_1; |
|
} |
|
}; |
|
Resizable.prototype.onResizeStart = function (event, direction) { |
|
var clientX = 0; |
|
var clientY = 0; |
|
if (event.nativeEvent instanceof MouseEvent) { |
|
clientX = event.nativeEvent.clientX; |
|
clientY = event.nativeEvent.clientY; |
|
// When user click with right button the resize is stuck in resizing mode |
|
// until users clicks again, dont continue if right click is used. |
|
// HACK: MouseEvent does not have `which` from flow-bin v0.68. |
|
if (event.nativeEvent.which === 3) { |
|
return; |
|
} |
|
} |
|
else if (event.nativeEvent instanceof TouchEvent) { |
|
clientX = event.nativeEvent.touches[0].clientX; |
|
clientY = event.nativeEvent.touches[0].clientY; |
|
} |
|
if (this.props.onResizeStart) { |
|
if (this.resizable) { |
|
var startResize = this.props.onResizeStart(event, direction, this.resizable); |
|
if (startResize === false) { |
|
return; |
|
} |
|
} |
|
} |
|
// Fix #168 |
|
if (this.props.size) { |
|
if (typeof this.props.size.height !== 'undefined' && this.props.size.height !== this.state.height) { |
|
this.setState({ height: this.props.size.height }); |
|
} |
|
if (typeof this.props.size.width !== 'undefined' && this.props.size.width !== this.state.width) { |
|
this.setState({ width: this.props.size.width }); |
|
} |
|
} |
|
// For lockAspectRatio case |
|
this.ratio = |
|
typeof this.props.lockAspectRatio === 'number' ? this.props.lockAspectRatio : this.size.width / this.size.height; |
|
// For boundary |
|
this.setBoundingClientRect(); |
|
this.bindEvents(); |
|
this.setState({ |
|
original: { |
|
x: clientX, |
|
y: clientY, |
|
width: this.size.width, |
|
height: this.size.height, |
|
}, |
|
isResizing: true, |
|
resizeCursor: window.getComputedStyle(event.target).cursor || 'auto', |
|
direction: direction, |
|
}); |
|
}; |
|
Resizable.prototype.onMouseMove = function (event) { |
|
if (!this.state.isResizing || !this.resizable) { |
|
return; |
|
} |
|
var _a = this.props, maxWidth = _a.maxWidth, maxHeight = _a.maxHeight, minWidth = _a.minWidth, minHeight = _a.minHeight; |
|
var clientX = event instanceof MouseEvent ? event.clientX : event.touches[0].clientX; |
|
var clientY = event instanceof MouseEvent ? event.clientY : event.touches[0].clientY; |
|
var _b = this.state, direction = _b.direction, original = _b.original, width = _b.width, height = _b.height; |
|
var parentSize = this.getParentSize(); |
|
var max = calculateNewMax(parentSize, maxWidth, maxHeight, minWidth, minHeight); |
|
maxWidth = max.maxWidth; |
|
maxHeight = max.maxHeight; |
|
minWidth = max.minWidth; |
|
minHeight = max.minHeight; |
|
// Calculate new size |
|
var _c = this.calculateNewSizeFromDirection(clientX, clientY), newHeight = _c.newHeight, newWidth = _c.newWidth; |
|
// Calculate max size from boundary settings |
|
var boundaryMax = this.calculateNewMaxFromBoundary(maxWidth, maxHeight); |
|
// Calculate new size from aspect ratio |
|
var newSize = this.calculateNewSizeFromAspectRatio(newWidth, newHeight, { width: boundaryMax.maxWidth, height: boundaryMax.maxHeight }, { width: minWidth, height: minHeight }); |
|
newWidth = newSize.newWidth; |
|
newHeight = newSize.newHeight; |
|
if (this.props.grid) { |
|
var newGridWidth = snap(newWidth, this.props.grid[0]); |
|
var newGridHeight = snap(newHeight, this.props.grid[1]); |
|
var gap = this.props.snapGap || 0; |
|
newWidth = gap === 0 || Math.abs(newGridWidth - newWidth) <= gap ? newGridWidth : newWidth; |
|
newHeight = gap === 0 || Math.abs(newGridHeight - newHeight) <= gap ? newGridHeight : newHeight; |
|
} |
|
if (this.props.snap && this.props.snap.x) { |
|
newWidth = findClosestSnap(newWidth, this.props.snap.x, this.props.snapGap); |
|
} |
|
if (this.props.snap && this.props.snap.y) { |
|
newHeight = findClosestSnap(newHeight, this.props.snap.y, this.props.snapGap); |
|
} |
|
var delta = { |
|
width: newWidth - original.width, |
|
height: newHeight - original.height, |
|
}; |
|
if (width && typeof width === 'string') { |
|
if (endsWith(width, '%')) { |
|
var percent = (newWidth / parentSize.width) * 100; |
|
newWidth = percent + "%"; |
|
} |
|
else if (endsWith(width, 'vw')) { |
|
var vw = (newWidth / window.innerWidth) * 100; |
|
newWidth = vw + "vw"; |
|
} |
|
else if (endsWith(width, 'vh')) { |
|
var vh = (newWidth / window.innerHeight) * 100; |
|
newWidth = vh + "vh"; |
|
} |
|
} |
|
if (height && typeof height === 'string') { |
|
if (endsWith(height, '%')) { |
|
var percent = (newHeight / parentSize.height) * 100; |
|
newHeight = percent + "%"; |
|
} |
|
else if (endsWith(height, 'vw')) { |
|
var vw = (newHeight / window.innerWidth) * 100; |
|
newHeight = vw + "vw"; |
|
} |
|
else if (endsWith(height, 'vh')) { |
|
var vh = (newHeight / window.innerHeight) * 100; |
|
newHeight = vh + "vh"; |
|
} |
|
} |
|
this.setState({ |
|
width: this.createSizeForCssProperty(newWidth, 'width'), |
|
height: this.createSizeForCssProperty(newHeight, 'height'), |
|
}); |
|
if (this.props.onResize) { |
|
this.props.onResize(event, direction, this.resizable, delta); |
|
} |
|
}; |
|
Resizable.prototype.onMouseUp = function (event) { |
|
var _a = this.state, isResizing = _a.isResizing, direction = _a.direction, original = _a.original; |
|
if (!isResizing || !this.resizable) { |
|
return; |
|
} |
|
var delta = { |
|
width: this.size.width - original.width, |
|
height: this.size.height - original.height, |
|
}; |
|
if (this.props.onResizeStop) { |
|
this.props.onResizeStop(event, direction, this.resizable, delta); |
|
} |
|
if (this.props.size) { |
|
this.setState(this.props.size); |
|
} |
|
this.unbindEvents(); |
|
this.setState({ isResizing: false, resizeCursor: 'auto' }); |
|
}; |
|
Resizable.prototype.updateSize = function (size) { |
|
this.setState({ width: size.width, height: size.height }); |
|
}; |
|
Resizable.prototype.renderResizer = function () { |
|
var _this = this; |
|
var _a = this.props, enable = _a.enable, handleStyles = _a.handleStyles, handleClasses = _a.handleClasses, handleWrapperStyle = _a.handleWrapperStyle, handleWrapperClass = _a.handleWrapperClass, handleComponent = _a.handleComponent; |
|
if (!enable) { |
|
return null; |
|
} |
|
var resizers = Object.keys(enable).map(function (dir) { |
|
if (enable[dir] !== false) { |
|
return (React.createElement(resizer_1.Resizer, { key: dir, direction: dir, onResizeStart: _this.onResizeStart, replaceStyles: handleStyles && handleStyles[dir], className: handleClasses && handleClasses[dir] }, handleComponent && handleComponent[dir] ? handleComponent[dir] : null)); |
|
} |
|
return null; |
|
}); |
|
// #93 Wrap the resize box in span (will not break 100% width/height) |
|
return (React.createElement("span", { className: handleWrapperClass, style: handleWrapperStyle }, resizers)); |
|
}; |
|
Resizable.prototype.render = function () { |
|
var _this = this; |
|
var extendsProps = Object.keys(this.props).reduce(function (acc, key) { |
|
if (definedProps.indexOf(key) !== -1) { |
|
return acc; |
|
} |
|
acc[key] = _this.props[key]; |
|
return acc; |
|
}, {}); |
|
return (React.createElement("div", __assign({ ref: function (c) { |
|
if (c) { |
|
_this.resizable = c; |
|
} |
|
}, style: __assign({ position: 'relative', userSelect: this.state.isResizing ? 'none' : 'auto' }, this.props.style, this.sizeStyle, { maxWidth: this.props.maxWidth, maxHeight: this.props.maxHeight, minWidth: this.props.minWidth, minHeight: this.props.minHeight, boxSizing: 'border-box' }), className: this.props.className }, extendsProps), |
|
this.state.isResizing && (React.createElement("div", { style: { |
|
height: '100%', |
|
width: '100%', |
|
backgroundColor: 'rgba(0,0,0,0)', |
|
cursor: "" + (this.state.resizeCursor || 'auto'), |
|
opacity: 0, |
|
position: 'fixed', |
|
zIndex: 9999, |
|
top: '0', |
|
left: '0', |
|
bottom: '0', |
|
right: '0', |
|
} })), |
|
this.props.children, |
|
this.renderResizer())); |
|
}; |
|
Resizable.defaultProps = { |
|
onResizeStart: function () { }, |
|
onResize: function () { }, |
|
onResizeStop: function () { }, |
|
enable: { |
|
top: true, |
|
right: true, |
|
bottom: true, |
|
left: true, |
|
topRight: true, |
|
bottomRight: true, |
|
bottomLeft: true, |
|
topLeft: true, |
|
}, |
|
style: {}, |
|
grid: [1, 1], |
|
lockAspectRatio: false, |
|
lockAspectRatioExtraWidth: 0, |
|
lockAspectRatioExtraHeight: 0, |
|
scale: 1, |
|
resizeRatio: 1, |
|
snapGap: 0, |
|
}; |
|
return Resizable; |
|
}(React.PureComponent)); |
|
exports.Resizable = Resizable; |
|
|
|
|
|
/***/ }), |
|
/* 228 */, |
|
/* 229 */, |
|
/* 230 */, |
|
/* 231 */, |
|
/* 232 */, |
|
/* 233 */, |
|
/* 234 */, |
|
/* 235 */, |
|
/* 236 */ |
|
/***/ (function(module, exports) { |
|
|
|
/** |
|
* adds a bindGlobal method to Mousetrap that allows you to |
|
* bind specific keyboard shortcuts that will still work |
|
* inside a text input field |
|
* |
|
* usage: |
|
* Mousetrap.bindGlobal('ctrl+s', _saveChanges); |
|
*/ |
|
/* global Mousetrap:true */ |
|
(function(Mousetrap) { |
|
var _globalCallbacks = {}; |
|
var _originalStopCallback = Mousetrap.prototype.stopCallback; |
|
|
|
Mousetrap.prototype.stopCallback = function(e, element, combo, sequence) { |
|
var self = this; |
|
|
|
if (self.paused) { |
|
return true; |
|
} |
|
|
|
if (_globalCallbacks[combo] || _globalCallbacks[sequence]) { |
|
return false; |
|
} |
|
|
|
return _originalStopCallback.call(self, e, element, combo); |
|
}; |
|
|
|
Mousetrap.prototype.bindGlobal = function(keys, callback, action) { |
|
var self = this; |
|
self.bind(keys, callback, action); |
|
|
|
if (keys instanceof Array) { |
|
for (var i = 0; i < keys.length; i++) { |
|
_globalCallbacks[keys[i]] = true; |
|
} |
|
return; |
|
} |
|
|
|
_globalCallbacks[keys] = true; |
|
}; |
|
|
|
Mousetrap.init(); |
|
}) (Mousetrap); |
|
|
|
|
|
/***/ }), |
|
/* 237 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
// eslint-disable-next-line import/no-unresolved |
|
__webpack_require__(238); |
|
|
|
|
|
/***/ }), |
|
/* 238 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var _registerCSSInterfaceWithDefaultTheme = __webpack_require__(239); |
|
|
|
var _registerCSSInterfaceWithDefaultTheme2 = _interopRequireDefault(_registerCSSInterfaceWithDefaultTheme); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
(0, _registerCSSInterfaceWithDefaultTheme2['default'])(); |
|
|
|
/***/ }), |
|
/* 239 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = registerCSSInterfaceWithDefaultTheme; |
|
|
|
var _reactWithStylesInterfaceCss = __webpack_require__(240); |
|
|
|
var _reactWithStylesInterfaceCss2 = _interopRequireDefault(_reactWithStylesInterfaceCss); |
|
|
|
var _registerInterfaceWithDefaultTheme = __webpack_require__(265); |
|
|
|
var _registerInterfaceWithDefaultTheme2 = _interopRequireDefault(_registerInterfaceWithDefaultTheme); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function registerCSSInterfaceWithDefaultTheme() { |
|
(0, _registerInterfaceWithDefaultTheme2['default'])(_reactWithStylesInterfaceCss2['default']); |
|
} |
|
|
|
/***/ }), |
|
/* 240 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
// eslint-disable-next-line import/no-unresolved |
|
module.exports = __webpack_require__(241).default; |
|
|
|
|
|
/***/ }), |
|
/* 241 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _arrayPrototype = __webpack_require__(242); |
|
|
|
var _arrayPrototype2 = _interopRequireDefault(_arrayPrototype); |
|
|
|
var _globalCache = __webpack_require__(261); |
|
|
|
var _globalCache2 = _interopRequireDefault(_globalCache); |
|
|
|
var _constants = __webpack_require__(262); |
|
|
|
var _getClassName = __webpack_require__(263); |
|
|
|
var _getClassName2 = _interopRequireDefault(_getClassName); |
|
|
|
var _separateStyles2 = __webpack_require__(264); |
|
|
|
var _separateStyles3 = _interopRequireDefault(_separateStyles2); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
/** |
|
* Function required as part of the react-with-styles interface. Parses the styles provided by |
|
* react-with-styles to produce class names based on the style name and optionally the namespace if |
|
* available. |
|
* |
|
* stylesObject {Object} The styles object passed to withStyles. |
|
* |
|
* Return an object mapping style names to class names. |
|
*/ |
|
function create(stylesObject) { |
|
var stylesToClasses = {}; |
|
var styleNames = Object.keys(stylesObject); |
|
var sharedState = _globalCache2['default'].get(_constants.GLOBAL_CACHE_KEY) || {}; |
|
var _sharedState$namespac = sharedState.namespace, |
|
namespace = _sharedState$namespac === undefined ? '' : _sharedState$namespac; |
|
|
|
styleNames.forEach(function (styleName) { |
|
var className = (0, _getClassName2['default'])(namespace, styleName); |
|
stylesToClasses[styleName] = className; |
|
}); |
|
return stylesToClasses; |
|
} |
|
|
|
/** |
|
* Process styles to be consumed by a component. |
|
* |
|
* stylesArray {Array} Array of the following: values returned by create, plain JavaScript objects |
|
* representing inline styles, or arrays thereof. |
|
* |
|
* Return an object with optional className and style properties to be spread on a component. |
|
*/ |
|
function resolve(stylesArray) { |
|
var flattenedStyles = (0, _arrayPrototype2['default'])(stylesArray, Infinity); |
|
|
|
var _separateStyles = (0, _separateStyles3['default'])(flattenedStyles), |
|
classNames = _separateStyles.classNames, |
|
hasInlineStyles = _separateStyles.hasInlineStyles, |
|
inlineStyles = _separateStyles.inlineStyles; |
|
|
|
var specificClassNames = classNames.map(function (name, index) { |
|
return String(name) + ' ' + String(name) + '_' + String(index + 1); |
|
}); |
|
var className = specificClassNames.join(' '); |
|
|
|
var result = { className: className }; |
|
if (hasInlineStyles) result.style = inlineStyles; |
|
return result; |
|
} |
|
|
|
exports['default'] = { create: create, resolve: resolve }; |
|
|
|
/***/ }), |
|
/* 242 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var define = __webpack_require__(55); |
|
var bind = __webpack_require__(59); |
|
|
|
var implementation = __webpack_require__(148); |
|
var getPolyfill = __webpack_require__(167); |
|
var polyfill = getPolyfill(); |
|
var shim = __webpack_require__(260); |
|
|
|
var boundFlat = bind.call(Function.call, polyfill); |
|
|
|
define(boundFlat, { |
|
getPolyfill: getPolyfill, |
|
implementation: implementation, |
|
shim: shim |
|
}); |
|
|
|
module.exports = boundFlat; |
|
|
|
|
|
/***/ }), |
|
/* 243 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var keysShim; |
|
if (!Object.keys) { |
|
// modified from https://github.com/es-shims/es5-shim |
|
var has = Object.prototype.hasOwnProperty; |
|
var toStr = Object.prototype.toString; |
|
var isArgs = __webpack_require__(147); // eslint-disable-line global-require |
|
var isEnumerable = Object.prototype.propertyIsEnumerable; |
|
var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString'); |
|
var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype'); |
|
var dontEnums = [ |
|
'toString', |
|
'toLocaleString', |
|
'valueOf', |
|
'hasOwnProperty', |
|
'isPrototypeOf', |
|
'propertyIsEnumerable', |
|
'constructor' |
|
]; |
|
var equalsConstructorPrototype = function (o) { |
|
var ctor = o.constructor; |
|
return ctor && ctor.prototype === o; |
|
}; |
|
var excludedKeys = { |
|
$applicationCache: true, |
|
$console: true, |
|
$external: true, |
|
$frame: true, |
|
$frameElement: true, |
|
$frames: true, |
|
$innerHeight: true, |
|
$innerWidth: true, |
|
$onmozfullscreenchange: true, |
|
$onmozfullscreenerror: true, |
|
$outerHeight: true, |
|
$outerWidth: true, |
|
$pageXOffset: true, |
|
$pageYOffset: true, |
|
$parent: true, |
|
$scrollLeft: true, |
|
$scrollTop: true, |
|
$scrollX: true, |
|
$scrollY: true, |
|
$self: true, |
|
$webkitIndexedDB: true, |
|
$webkitStorageInfo: true, |
|
$window: true |
|
}; |
|
var hasAutomationEqualityBug = (function () { |
|
/* global window */ |
|
if (typeof window === 'undefined') { return false; } |
|
for (var k in window) { |
|
try { |
|
if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') { |
|
try { |
|
equalsConstructorPrototype(window[k]); |
|
} catch (e) { |
|
return true; |
|
} |
|
} |
|
} catch (e) { |
|
return true; |
|
} |
|
} |
|
return false; |
|
}()); |
|
var equalsConstructorPrototypeIfNotBuggy = function (o) { |
|
/* global window */ |
|
if (typeof window === 'undefined' || !hasAutomationEqualityBug) { |
|
return equalsConstructorPrototype(o); |
|
} |
|
try { |
|
return equalsConstructorPrototype(o); |
|
} catch (e) { |
|
return false; |
|
} |
|
}; |
|
|
|
keysShim = function keys(object) { |
|
var isObject = object !== null && typeof object === 'object'; |
|
var isFunction = toStr.call(object) === '[object Function]'; |
|
var isArguments = isArgs(object); |
|
var isString = isObject && toStr.call(object) === '[object String]'; |
|
var theKeys = []; |
|
|
|
if (!isObject && !isFunction && !isArguments) { |
|
throw new TypeError('Object.keys called on a non-object'); |
|
} |
|
|
|
var skipProto = hasProtoEnumBug && isFunction; |
|
if (isString && object.length > 0 && !has.call(object, 0)) { |
|
for (var i = 0; i < object.length; ++i) { |
|
theKeys.push(String(i)); |
|
} |
|
} |
|
|
|
if (isArguments && object.length > 0) { |
|
for (var j = 0; j < object.length; ++j) { |
|
theKeys.push(String(j)); |
|
} |
|
} else { |
|
for (var name in object) { |
|
if (!(skipProto && name === 'prototype') && has.call(object, name)) { |
|
theKeys.push(String(name)); |
|
} |
|
} |
|
} |
|
|
|
if (hasDontEnumBug) { |
|
var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object); |
|
|
|
for (var k = 0; k < dontEnums.length; ++k) { |
|
if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) { |
|
theKeys.push(dontEnums[k]); |
|
} |
|
} |
|
} |
|
return theKeys; |
|
}; |
|
} |
|
module.exports = keysShim; |
|
|
|
|
|
/***/ }), |
|
/* 244 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
/* eslint no-invalid-this: 1 */ |
|
|
|
var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible '; |
|
var slice = Array.prototype.slice; |
|
var toStr = Object.prototype.toString; |
|
var funcType = '[object Function]'; |
|
|
|
module.exports = function bind(that) { |
|
var target = this; |
|
if (typeof target !== 'function' || toStr.call(target) !== funcType) { |
|
throw new TypeError(ERROR_MESSAGE + target); |
|
} |
|
var args = slice.call(arguments, 1); |
|
|
|
var bound; |
|
var binder = function () { |
|
if (this instanceof bound) { |
|
var result = target.apply( |
|
this, |
|
args.concat(slice.call(arguments)) |
|
); |
|
if (Object(result) === result) { |
|
return result; |
|
} |
|
return this; |
|
} else { |
|
return target.apply( |
|
that, |
|
args.concat(slice.call(arguments)) |
|
); |
|
} |
|
}; |
|
|
|
var boundLength = Math.max(0, target.length - args.length); |
|
var boundArgs = []; |
|
for (var i = 0; i < boundLength; i++) { |
|
boundArgs.push('$' + i); |
|
} |
|
|
|
bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder); |
|
|
|
if (target.prototype) { |
|
var Empty = function Empty() {}; |
|
Empty.prototype = target.prototype; |
|
bound.prototype = new Empty(); |
|
Empty.prototype = null; |
|
} |
|
|
|
return bound; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 245 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var trimStart = __webpack_require__(246); |
|
var trimEnd = __webpack_require__(248); |
|
var inspect = __webpack_require__(129); |
|
|
|
var ES2018 = __webpack_require__(251); |
|
var assign = __webpack_require__(91); |
|
var MAX_SAFE_INTEGER = __webpack_require__(159); |
|
|
|
var GetIntrinsic = __webpack_require__(60); |
|
|
|
var $TypeError = GetIntrinsic('%TypeError%'); |
|
|
|
var ES2019 = assign(assign({}, ES2018), { |
|
// https://tc39.es/ecma262/#sec-add-entries-from-iterable |
|
AddEntriesFromIterable: function AddEntriesFromIterable(target, iterable, adder) { |
|
if (!this.IsCallable(adder)) { |
|
throw new $TypeError('Assertion failed: `adder` is not callable'); |
|
} |
|
if (iterable == null) { |
|
throw new $TypeError('Assertion failed: `iterable` is present, and not nullish'); |
|
} |
|
var iteratorRecord = this.GetIterator(iterable); |
|
while (true) { // eslint-disable-line no-constant-condition |
|
var next = this.IteratorStep(iteratorRecord); |
|
if (!next) { |
|
return target; |
|
} |
|
var nextItem = this.IteratorValue(next); |
|
if (this.Type(nextItem) !== 'Object') { |
|
var error = new $TypeError('iterator next must return an Object, got ' + inspect(nextItem)); |
|
return this.IteratorClose( |
|
iteratorRecord, |
|
function () { throw error; } // eslint-disable-line no-loop-func |
|
); |
|
} |
|
try { |
|
var k = this.Get(nextItem, '0'); |
|
var v = this.Get(nextItem, '1'); |
|
this.Call(adder, target, [k, v]); |
|
} catch (e) { |
|
return this.IteratorClose( |
|
iteratorRecord, |
|
function () { throw e; } // eslint-disable-line no-loop-func |
|
); |
|
} |
|
} |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/10.0/#sec-flattenintoarray |
|
// eslint-disable-next-line max-params, max-statements |
|
FlattenIntoArray: function FlattenIntoArray(target, source, sourceLen, start, depth) { |
|
var mapperFunction; |
|
if (arguments.length > 5) { |
|
mapperFunction = arguments[5]; |
|
} |
|
|
|
var targetIndex = start; |
|
var sourceIndex = 0; |
|
while (sourceIndex < sourceLen) { |
|
var P = this.ToString(sourceIndex); |
|
var exists = this.HasProperty(source, P); |
|
if (exists === true) { |
|
var element = this.Get(source, P); |
|
if (typeof mapperFunction !== 'undefined') { |
|
if (arguments.length <= 6) { |
|
throw new $TypeError('Assertion failed: thisArg is required when mapperFunction is provided'); |
|
} |
|
element = this.Call(mapperFunction, arguments[6], [element, sourceIndex, source]); |
|
} |
|
var shouldFlatten = false; |
|
if (depth > 0) { |
|
shouldFlatten = this.IsArray(element); |
|
} |
|
if (shouldFlatten) { |
|
var elementLen = this.ToLength(this.Get(element, 'length')); |
|
targetIndex = this.FlattenIntoArray(target, element, elementLen, targetIndex, depth - 1); |
|
} else { |
|
if (targetIndex >= MAX_SAFE_INTEGER) { |
|
throw new $TypeError('index too large'); |
|
} |
|
this.CreateDataPropertyOrThrow(target, this.ToString(targetIndex), element); |
|
targetIndex += 1; |
|
} |
|
} |
|
sourceIndex += 1; |
|
} |
|
|
|
return targetIndex; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/10.0/#sec-trimstring |
|
TrimString: function TrimString(string, where) { |
|
var str = this.RequireObjectCoercible(string); |
|
var S = this.ToString(str); |
|
var T; |
|
if (where === 'start') { |
|
T = trimStart(S); |
|
} else if (where === 'end') { |
|
T = trimEnd(S); |
|
} else if (where === 'start+end') { |
|
T = trimStart(trimEnd(S)); |
|
} else { |
|
throw new $TypeError('Assertion failed: invalid `where` value; must be "start", "end", or "start+end"'); |
|
} |
|
return T; |
|
} |
|
}); |
|
|
|
module.exports = ES2019; |
|
|
|
|
|
/***/ }), |
|
/* 246 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var bind = __webpack_require__(59); |
|
var define = __webpack_require__(55); |
|
|
|
var implementation = __webpack_require__(149); |
|
var getPolyfill = __webpack_require__(150); |
|
var shim = __webpack_require__(247); |
|
|
|
var bound = bind.call(Function.call, getPolyfill()); |
|
|
|
define(bound, { |
|
getPolyfill: getPolyfill, |
|
implementation: implementation, |
|
shim: shim |
|
}); |
|
|
|
module.exports = bound; |
|
|
|
|
|
/***/ }), |
|
/* 247 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var define = __webpack_require__(55); |
|
var getPolyfill = __webpack_require__(150); |
|
|
|
module.exports = function shimTrimLeft() { |
|
var polyfill = getPolyfill(); |
|
define( |
|
String.prototype, |
|
{ trimLeft: polyfill }, |
|
{ trimLeft: function () { return String.prototype.trimLeft !== polyfill; } } |
|
); |
|
return polyfill; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 248 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var bind = __webpack_require__(59); |
|
var define = __webpack_require__(55); |
|
|
|
var implementation = __webpack_require__(151); |
|
var getPolyfill = __webpack_require__(152); |
|
var shim = __webpack_require__(249); |
|
|
|
var bound = bind.call(Function.call, getPolyfill()); |
|
|
|
define(bound, { |
|
getPolyfill: getPolyfill, |
|
implementation: implementation, |
|
shim: shim |
|
}); |
|
|
|
module.exports = bound; |
|
|
|
|
|
/***/ }), |
|
/* 249 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var define = __webpack_require__(55); |
|
var getPolyfill = __webpack_require__(152); |
|
|
|
module.exports = function shimTrimRight() { |
|
var polyfill = getPolyfill(); |
|
define( |
|
String.prototype, |
|
{ trimRight: polyfill }, |
|
{ trimRight: function () { return String.prototype.trimRight !== polyfill; } } |
|
); |
|
return polyfill; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 250 */ |
|
/***/ (function(module, exports) { |
|
|
|
/* (ignored) */ |
|
|
|
/***/ }), |
|
/* 251 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var GetIntrinsic = __webpack_require__(60); |
|
|
|
var keys = __webpack_require__(90); |
|
var inspect = __webpack_require__(129); |
|
|
|
var ES2017 = __webpack_require__(252); |
|
var assign = __webpack_require__(91); |
|
var forEach = __webpack_require__(131); |
|
var callBind = __webpack_require__(102); |
|
var every = __webpack_require__(132); |
|
var isPrefixOf = __webpack_require__(164); |
|
|
|
var $String = GetIntrinsic('%String%'); |
|
var $TypeError = GetIntrinsic('%TypeError%'); |
|
|
|
var callBound = __webpack_require__(75); |
|
var regexTester = __webpack_require__(163); |
|
var $isNaN = __webpack_require__(130); |
|
|
|
var $SymbolValueOf = callBound('Symbol.prototype.valueOf', true); |
|
// var $charAt = callBound('String.prototype.charAt'); |
|
var $strSlice = callBound('String.prototype.slice'); |
|
var $indexOf = callBound('String.prototype.indexOf'); |
|
var $parseInt = parseInt; |
|
|
|
var isDigit = regexTester(/^[0-9]$/); |
|
|
|
var $PromiseResolve = callBound('Promise.resolve', true); |
|
|
|
var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable'); |
|
var $pushApply = callBind.apply(GetIntrinsic('%Array.prototype.push%')); |
|
var $gOPS = $SymbolValueOf ? GetIntrinsic('%Object.getOwnPropertySymbols%') : null; |
|
|
|
var padTimeComponent = function padTimeComponent(c, count) { |
|
return $strSlice('00' + c, -(count || 2)); |
|
}; |
|
|
|
var weekdays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']; |
|
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']; |
|
|
|
var OwnPropertyKeys = function OwnPropertyKeys(ES, source) { |
|
var ownKeys = keys(source); |
|
if ($gOPS) { |
|
$pushApply(ownKeys, $gOPS(source)); |
|
} |
|
return ownKeys; |
|
}; |
|
|
|
var ES2018 = assign(assign({}, ES2017), { |
|
EnumerableOwnPropertyNames: ES2017.EnumerableOwnProperties, |
|
|
|
// https://ecma-international.org/ecma-262/9.0/#sec-thissymbolvalue |
|
thisSymbolValue: function thisSymbolValue(value) { |
|
if (!$SymbolValueOf) { |
|
throw new SyntaxError('Symbols are not supported; thisSymbolValue requires that `value` be a Symbol or a Symbol object'); |
|
} |
|
if (this.Type(value) === 'Symbol') { |
|
return value; |
|
} |
|
return $SymbolValueOf(value); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/9.0/#sec-isstringprefix |
|
IsStringPrefix: function IsStringPrefix(p, q) { |
|
if (this.Type(p) !== 'String') { |
|
throw new TypeError('Assertion failed: "p" must be a String'); |
|
} |
|
|
|
if (this.Type(q) !== 'String') { |
|
throw new TypeError('Assertion failed: "q" must be a String'); |
|
} |
|
|
|
return isPrefixOf(p, q); |
|
/* |
|
if (p === q || p === '') { |
|
return true; |
|
} |
|
|
|
var pLength = p.length; |
|
var qLength = q.length; |
|
if (pLength >= qLength) { |
|
return false; |
|
} |
|
|
|
// assert: pLength < qLength |
|
|
|
for (var i = 0; i < pLength; i += 1) { |
|
if ($charAt(p, i) !== $charAt(q, i)) { |
|
return false; |
|
} |
|
} |
|
return true; |
|
*/ |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/9.0/#sec-tostring-applied-to-the-number-type |
|
NumberToString: function NumberToString(m) { |
|
if (this.Type(m) !== 'Number') { |
|
throw new TypeError('Assertion failed: "m" must be a String'); |
|
} |
|
|
|
return $String(m); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/9.0/#sec-copydataproperties |
|
CopyDataProperties: function CopyDataProperties(target, source, excludedItems) { |
|
if (this.Type(target) !== 'Object') { |
|
throw new TypeError('Assertion failed: "target" must be an Object'); |
|
} |
|
|
|
if (!this.IsArray(excludedItems)) { |
|
throw new TypeError('Assertion failed: "excludedItems" must be a List of Property Keys'); |
|
} |
|
for (var i = 0; i < excludedItems.length; i += 1) { |
|
if (!this.IsPropertyKey(excludedItems[i])) { |
|
throw new TypeError('Assertion failed: "excludedItems" must be a List of Property Keys'); |
|
} |
|
} |
|
|
|
if (typeof source === 'undefined' || source === null) { |
|
return target; |
|
} |
|
|
|
var ES = this; |
|
|
|
var fromObj = ES.ToObject(source); |
|
|
|
var sourceKeys = OwnPropertyKeys(ES, fromObj); |
|
forEach(sourceKeys, function (nextKey) { |
|
var excluded = false; |
|
|
|
forEach(excludedItems, function (e) { |
|
if (ES.SameValue(e, nextKey) === true) { |
|
excluded = true; |
|
} |
|
}); |
|
|
|
var enumerable = $isEnumerable(fromObj, nextKey) || ( |
|
// this is to handle string keys being non-enumerable in older engines |
|
typeof source === 'string' |
|
&& nextKey >= 0 |
|
&& ES.IsInteger(ES.ToNumber(nextKey)) |
|
); |
|
if (excluded === false && enumerable) { |
|
var propValue = ES.Get(fromObj, nextKey); |
|
ES.CreateDataProperty(target, nextKey, propValue); |
|
} |
|
}); |
|
|
|
return target; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/9.0/#sec-promise-resolve |
|
PromiseResolve: function PromiseResolve(C, x) { |
|
if (!$PromiseResolve) { |
|
throw new SyntaxError('This environment does not support Promises.'); |
|
} |
|
return $PromiseResolve(C, x); |
|
}, |
|
|
|
// http://www.ecma-international.org/ecma-262/9.0/#sec-getsubstitution |
|
// eslint-disable-next-line max-statements, max-params, max-lines-per-function |
|
GetSubstitution: function GetSubstitution(matched, str, position, captures, namedCaptures, replacement) { |
|
if (this.Type(matched) !== 'String') { |
|
throw new $TypeError('Assertion failed: `matched` must be a String'); |
|
} |
|
var matchLength = matched.length; |
|
|
|
if (this.Type(str) !== 'String') { |
|
throw new $TypeError('Assertion failed: `str` must be a String'); |
|
} |
|
var stringLength = str.length; |
|
|
|
if (!this.IsInteger(position) || position < 0 || position > stringLength) { |
|
throw new $TypeError('Assertion failed: `position` must be a nonnegative integer, and less than or equal to the length of `string`, got ' + inspect(position)); |
|
} |
|
|
|
var ES = this; |
|
var isStringOrHole = function (capture, index, arr) { return ES.Type(capture) === 'String' || !(index in arr); }; |
|
if (!this.IsArray(captures) || !every(captures, isStringOrHole)) { |
|
throw new $TypeError('Assertion failed: `captures` must be a List of Strings, got ' + inspect(captures)); |
|
} |
|
|
|
if (this.Type(replacement) !== 'String') { |
|
throw new $TypeError('Assertion failed: `replacement` must be a String'); |
|
} |
|
|
|
var tailPos = position + matchLength; |
|
var m = captures.length; |
|
if (this.Type(namedCaptures) !== 'Undefined') { |
|
namedCaptures = this.ToObject(namedCaptures); // eslint-disable-line no-param-reassign |
|
} |
|
|
|
var result = ''; |
|
for (var i = 0; i < replacement.length; i += 1) { |
|
// if this is a $, and it's not the end of the replacement |
|
var current = replacement[i]; |
|
var isLast = (i + 1) >= replacement.length; |
|
var nextIsLast = (i + 2) >= replacement.length; |
|
if (current === '$' && !isLast) { |
|
var next = replacement[i + 1]; |
|
if (next === '$') { |
|
result += '$'; |
|
i += 1; |
|
} else if (next === '&') { |
|
result += matched; |
|
i += 1; |
|
} else if (next === '`') { |
|
result += position === 0 ? '' : $strSlice(str, 0, position - 1); |
|
i += 1; |
|
} else if (next === "'") { |
|
result += tailPos >= stringLength ? '' : $strSlice(str, tailPos); |
|
i += 1; |
|
} else { |
|
var nextNext = nextIsLast ? null : replacement[i + 2]; |
|
if (isDigit(next) && next !== '0' && (nextIsLast || !isDigit(nextNext))) { |
|
// $1 through $9, and not followed by a digit |
|
var n = $parseInt(next, 10); |
|
// if (n > m, impl-defined) |
|
result += (n <= m && this.Type(captures[n - 1]) === 'Undefined') ? '' : captures[n - 1]; |
|
i += 1; |
|
} else if (isDigit(next) && (nextIsLast || isDigit(nextNext))) { |
|
// $00 through $99 |
|
var nn = next + nextNext; |
|
var nnI = $parseInt(nn, 10) - 1; |
|
// if nn === '00' or nn > m, impl-defined |
|
result += (nn <= m && this.Type(captures[nnI]) === 'Undefined') ? '' : captures[nnI]; |
|
i += 2; |
|
} else if (next === '<') { |
|
// eslint-disable-next-line max-depth |
|
if (this.Type(namedCaptures) === 'Undefined') { |
|
result += '$<'; |
|
i += 2; |
|
} else { |
|
var endIndex = $indexOf(replacement, '>', i); |
|
// eslint-disable-next-line max-depth |
|
if (endIndex > -1) { |
|
var groupName = $strSlice(replacement, i, endIndex); |
|
var capture = this.Get(namedCaptures, groupName); |
|
// eslint-disable-next-line max-depth |
|
if (this.Type(capture) !== 'Undefined') { |
|
result += this.ToString(capture); |
|
} |
|
i += '$<' + groupName + '>'.length; |
|
} |
|
} |
|
} else { |
|
result += '$'; |
|
} |
|
} |
|
} else { |
|
// the final $, or else not a $ |
|
result += replacement[i]; |
|
} |
|
} |
|
return result; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/9.0/#sec-datestring |
|
DateString: function DateString(tv) { |
|
if (this.Type(tv) !== 'Number' || $isNaN(tv)) { |
|
throw new $TypeError('Assertion failed: `tv` must be a non-NaN Number'); |
|
} |
|
var weekday = weekdays[this.WeekDay(tv)]; |
|
var month = months[this.MonthFromTime(tv)]; |
|
var day = padTimeComponent(this.DateFromTime(tv)); |
|
var year = padTimeComponent(this.YearFromTime(tv), 4); |
|
return weekday + '\x20' + month + '\x20' + day + '\x20' + year; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/9.0/#sec-timestring |
|
TimeString: function TimeString(tv) { |
|
if (this.Type(tv) !== 'Number' || $isNaN(tv)) { |
|
throw new $TypeError('Assertion failed: `tv` must be a non-NaN Number'); |
|
} |
|
var hour = this.HourFromTime(tv); |
|
var minute = this.MinFromTime(tv); |
|
var second = this.SecFromTime(tv); |
|
return padTimeComponent(hour) + ':' + padTimeComponent(minute) + ':' + padTimeComponent(second) + '\x20GMT'; |
|
} |
|
}); |
|
|
|
delete ES2018.EnumerableOwnProperties; // replaced with EnumerableOwnPropertyNames |
|
|
|
delete ES2018.IsPropertyDescriptor; // not an actual abstract operation |
|
|
|
module.exports = ES2018; |
|
|
|
|
|
/***/ }), |
|
/* 252 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var GetIntrinsic = __webpack_require__(60); |
|
|
|
var ES2016 = __webpack_require__(253); |
|
var assign = __webpack_require__(91); |
|
var forEach = __webpack_require__(131); |
|
var callBind = __webpack_require__(102); |
|
|
|
var $TypeError = GetIntrinsic('%TypeError%'); |
|
var callBound = __webpack_require__(75); |
|
var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable'); |
|
var $pushApply = callBind.apply(GetIntrinsic('%Array.prototype.push%')); |
|
var $arrayPush = callBound('Array.prototype.push'); |
|
|
|
var ES2017 = assign(assign({}, ES2016), { |
|
ToIndex: function ToIndex(value) { |
|
if (typeof value === 'undefined') { |
|
return 0; |
|
} |
|
var integerIndex = this.ToInteger(value); |
|
if (integerIndex < 0) { |
|
throw new RangeError('index must be >= 0'); |
|
} |
|
var index = this.ToLength(integerIndex); |
|
if (!this.SameValueZero(integerIndex, index)) { |
|
throw new RangeError('index must be >= 0 and < 2 ** 53 - 1'); |
|
} |
|
return index; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/8.0/#sec-enumerableownproperties |
|
EnumerableOwnProperties: function EnumerableOwnProperties(O, kind) { |
|
var keys = ES2016.EnumerableOwnNames(O); |
|
if (kind === 'key') { |
|
return keys; |
|
} |
|
if (kind === 'value' || kind === 'key+value') { |
|
var results = []; |
|
forEach(keys, function (key) { |
|
if ($isEnumerable(O, key)) { |
|
$pushApply(results, [ |
|
kind === 'value' ? O[key] : [key, O[key]] |
|
]); |
|
} |
|
}); |
|
return results; |
|
} |
|
throw new $TypeError('Assertion failed: "kind" is not "key", "value", or "key+value": ' + kind); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/8.0/#sec-iterabletolist |
|
IterableToList: function IterableToList(items, method) { |
|
var iterator = this.GetIterator(items, method); |
|
var values = []; |
|
var next = true; |
|
while (next) { |
|
next = this.IteratorStep(iterator); |
|
if (next) { |
|
var nextValue = this.IteratorValue(next); |
|
$arrayPush(values, nextValue); |
|
} |
|
} |
|
return values; |
|
} |
|
}); |
|
|
|
delete ES2017.EnumerableOwnNames; // replaced with EnumerableOwnProperties |
|
delete ES2017.IterableToArrayLike; // replaced with IterableToList |
|
|
|
module.exports = ES2017; |
|
|
|
|
|
/***/ }), |
|
/* 253 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var hasSymbols = __webpack_require__(100)(); |
|
|
|
var ES2015 = __webpack_require__(254); |
|
var assign = __webpack_require__(91); |
|
|
|
var callBound = __webpack_require__(75); |
|
|
|
var $arrayPush = callBound('Array.prototype.push'); |
|
var $arraySlice = callBound('Array.prototype.slice'); |
|
var $arrayJoin = callBound('Array.prototype.join'); |
|
|
|
var ES2016 = assign(assign({}, ES2015), { |
|
// https://www.ecma-international.org/ecma-262/7.0/#sec-samevaluenonnumber |
|
SameValueNonNumber: function SameValueNonNumber(x, y) { |
|
if (typeof x === 'number' || typeof x !== typeof y) { |
|
throw new TypeError('SameValueNonNumber requires two non-number values of the same type.'); |
|
} |
|
return this.SameValue(x, y); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/7.0/#sec-iterabletoarraylike |
|
IterableToArrayLike: function IterableToArrayLike(items) { |
|
var usingIterator; |
|
if (hasSymbols) { |
|
usingIterator = this.GetMethod(items, Symbol.iterator); |
|
} else if (this.IsArray(items)) { |
|
usingIterator = function () { |
|
var i = -1; |
|
var arr = this; // eslint-disable-line no-invalid-this |
|
return { |
|
next: function () { |
|
i += 1; |
|
return { |
|
done: i >= arr.length, |
|
value: arr[i] |
|
}; |
|
} |
|
}; |
|
}; |
|
} else if (this.Type(items) === 'String') { |
|
var ES = this; |
|
usingIterator = function () { |
|
var i = 0; |
|
return { |
|
next: function () { |
|
var nextIndex = ES.AdvanceStringIndex(items, i, true); |
|
var value = $arrayJoin($arraySlice(items, i, nextIndex), ''); |
|
i = nextIndex; |
|
return { |
|
done: nextIndex > items.length, |
|
value: value |
|
}; |
|
} |
|
}; |
|
}; |
|
} |
|
if (typeof usingIterator !== 'undefined') { |
|
var iterator = this.GetIterator(items, usingIterator); |
|
var values = []; |
|
var next = true; |
|
while (next) { |
|
next = this.IteratorStep(iterator); |
|
if (next) { |
|
var nextValue = this.IteratorValue(next); |
|
$arrayPush(values, nextValue); |
|
} |
|
} |
|
return values; |
|
} |
|
|
|
return this.ToObject(items); |
|
} |
|
}); |
|
|
|
module.exports = ES2016; |
|
|
|
|
|
/***/ }), |
|
/* 254 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var has = __webpack_require__(63); |
|
var toPrimitive = __webpack_require__(154); |
|
var keys = __webpack_require__(90); |
|
var inspect = __webpack_require__(129); |
|
|
|
var GetIntrinsic = __webpack_require__(60); |
|
|
|
var $TypeError = GetIntrinsic('%TypeError%'); |
|
var $RangeError = GetIntrinsic('%RangeError%'); |
|
var $SyntaxError = GetIntrinsic('%SyntaxError%'); |
|
var $Array = GetIntrinsic('%Array%'); |
|
var $ArrayPrototype = $Array.prototype; |
|
var $String = GetIntrinsic('%String%'); |
|
var $Object = GetIntrinsic('%Object%'); |
|
var $Number = GetIntrinsic('%Number%'); |
|
var $Symbol = GetIntrinsic('%Symbol%', true); |
|
var $RegExp = GetIntrinsic('%RegExp%'); |
|
var $Date = GetIntrinsic('%Date%'); |
|
var $preventExtensions = $Object.preventExtensions; |
|
|
|
var hasSymbols = __webpack_require__(100)(); |
|
|
|
var assertRecord = __webpack_require__(157); |
|
var $isNaN = __webpack_require__(130); |
|
var $isFinite = __webpack_require__(158); |
|
var MAX_ARRAY_LENGTH = Math.pow(2, 32) - 1; |
|
var MAX_SAFE_INTEGER = __webpack_require__(159); |
|
|
|
var assign = __webpack_require__(91); |
|
var sign = __webpack_require__(160); |
|
var mod = __webpack_require__(161); |
|
var isPrimitive = __webpack_require__(257); |
|
var forEach = __webpack_require__(131); |
|
var every = __webpack_require__(132); |
|
var isSamePropertyDescriptor = __webpack_require__(258); |
|
var isPropertyDescriptor = __webpack_require__(162); |
|
var parseInteger = parseInt; |
|
var callBound = __webpack_require__(75); |
|
var regexTester = __webpack_require__(163); |
|
|
|
var $PromiseThen = callBound('Promise.prototype.then', true); |
|
var arraySlice = callBound('Array.prototype.slice'); |
|
var strSlice = callBound('String.prototype.slice'); |
|
|
|
var isBinary = regexTester(/^0b[01]+$/i); |
|
var isOctal = regexTester(/^0o[0-7]+$/i); |
|
var isDigit = regexTester(/^[0-9]$/); |
|
var regexExec = callBound('RegExp.prototype.exec'); |
|
var nonWS = ['\u0085', '\u200b', '\ufffe'].join(''); |
|
var nonWSregex = new $RegExp('[' + nonWS + ']', 'g'); |
|
var hasNonWS = regexTester(nonWSregex); |
|
var isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i); |
|
var $charCodeAt = callBound('String.prototype.charCodeAt'); |
|
var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable'); |
|
|
|
var toStr = callBound('Object.prototype.toString'); |
|
|
|
var $NumberValueOf = callBound('Number.prototype.valueOf'); |
|
var $BooleanValueOf = callBound('Boolean.prototype.valueOf'); |
|
var $StringValueOf = callBound('String.prototype.valueOf'); |
|
var $DateValueOf = callBound('Date.prototype.valueOf'); |
|
var $SymbolToString = callBound('Symbol.prototype.toString', true); |
|
|
|
var $floor = Math.floor; |
|
var $abs = Math.abs; |
|
|
|
var $ObjectCreate = $Object.create; |
|
var $gOPD = $Object.getOwnPropertyDescriptor; |
|
var $gOPN = $Object.getOwnPropertyNames; |
|
var $gOPS = $Object.getOwnPropertySymbols; |
|
var $isExtensible = $Object.isExtensible; |
|
var $defineProperty = $Object.defineProperty; |
|
var $setProto = Object.setPrototypeOf || ( |
|
// eslint-disable-next-line no-proto, no-negated-condition |
|
[].__proto__ !== Array.prototype |
|
? null |
|
: function (O, proto) { |
|
O.__proto__ = proto; // eslint-disable-line no-proto |
|
return O; |
|
} |
|
); |
|
|
|
var DefineOwnProperty = function DefineOwnProperty(ES, O, P, desc) { |
|
if (!$defineProperty) { |
|
if (!ES.IsDataDescriptor(desc)) { |
|
// ES3 does not support getters/setters |
|
return false; |
|
} |
|
if (!desc['[[Configurable]]'] || !desc['[[Writable]]']) { |
|
return false; |
|
} |
|
|
|
// fallback for ES3 |
|
if (P in O && $isEnumerable(O, P) !== !!desc['[[Enumerable]]']) { |
|
// a non-enumerable existing property |
|
return false; |
|
} |
|
|
|
// property does not exist at all, or exists but is enumerable |
|
var V = desc['[[Value]]']; |
|
O[P] = V; // will use [[Define]] |
|
return ES.SameValue(O[P], V); |
|
} |
|
$defineProperty(O, P, ES.FromPropertyDescriptor(desc)); |
|
return true; |
|
}; |
|
|
|
// whitespace from: https://es5.github.io/#x15.5.4.20 |
|
// implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324 |
|
var ws = [ |
|
'\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003', |
|
'\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028', |
|
'\u2029\uFEFF' |
|
].join(''); |
|
var trimRegex = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g'); |
|
var $replace = callBound('String.prototype.replace'); |
|
var trim = function (value) { |
|
return $replace(value, trimRegex, ''); |
|
}; |
|
|
|
var ES5 = __webpack_require__(259); |
|
|
|
var hasRegExpMatcher = __webpack_require__(166); |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-abstract-operations |
|
var ES6 = assign(assign({}, ES5), { |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-call-f-v-args |
|
Call: function Call(F, V) { |
|
var args = arguments.length > 2 ? arguments[2] : []; |
|
if (!this.IsCallable(F)) { |
|
throw new $TypeError(inspect(F) + ' is not a function'); |
|
} |
|
return F.apply(V, args); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toprimitive |
|
ToPrimitive: toPrimitive, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toboolean |
|
// ToBoolean: ES5.ToBoolean, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-tonumber |
|
ToNumber: function ToNumber(argument) { |
|
var value = isPrimitive(argument) ? argument : toPrimitive(argument, $Number); |
|
if (typeof value === 'symbol') { |
|
throw new $TypeError('Cannot convert a Symbol value to a number'); |
|
} |
|
if (typeof value === 'string') { |
|
if (isBinary(value)) { |
|
return this.ToNumber(parseInteger(strSlice(value, 2), 2)); |
|
} else if (isOctal(value)) { |
|
return this.ToNumber(parseInteger(strSlice(value, 2), 8)); |
|
} else if (hasNonWS(value) || isInvalidHexLiteral(value)) { |
|
return NaN; |
|
} else { |
|
var trimmed = trim(value); |
|
if (trimmed !== value) { |
|
return this.ToNumber(trimmed); |
|
} |
|
} |
|
} |
|
return $Number(value); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tointeger |
|
// ToInteger: ES5.ToNumber, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toint32 |
|
// ToInt32: ES5.ToInt32, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint32 |
|
// ToUint32: ES5.ToUint32, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toint16 |
|
ToInt16: function ToInt16(argument) { |
|
var int16bit = this.ToUint16(argument); |
|
return int16bit >= 0x8000 ? int16bit - 0x10000 : int16bit; |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint16 |
|
// ToUint16: ES5.ToUint16, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toint8 |
|
ToInt8: function ToInt8(argument) { |
|
var int8bit = this.ToUint8(argument); |
|
return int8bit >= 0x80 ? int8bit - 0x100 : int8bit; |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint8 |
|
ToUint8: function ToUint8(argument) { |
|
var number = this.ToNumber(argument); |
|
if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; } |
|
var posInt = sign(number) * $floor($abs(number)); |
|
return mod(posInt, 0x100); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint8clamp |
|
ToUint8Clamp: function ToUint8Clamp(argument) { |
|
var number = this.ToNumber(argument); |
|
if ($isNaN(number) || number <= 0) { return 0; } |
|
if (number >= 0xFF) { return 0xFF; } |
|
var f = $floor(argument); |
|
if (f + 0.5 < number) { return f + 1; } |
|
if (number < f + 0.5) { return f; } |
|
if (f % 2 !== 0) { return f + 1; } |
|
return f; |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tostring |
|
ToString: function ToString(argument) { |
|
if (typeof argument === 'symbol') { |
|
throw new $TypeError('Cannot convert a Symbol value to a string'); |
|
} |
|
return $String(argument); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toobject |
|
ToObject: function ToObject(value) { |
|
this.RequireObjectCoercible(value); |
|
return $Object(value); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-topropertykey |
|
ToPropertyKey: function ToPropertyKey(argument) { |
|
var key = this.ToPrimitive(argument, $String); |
|
return typeof key === 'symbol' ? key : this.ToString(key); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength |
|
ToLength: function ToLength(argument) { |
|
var len = this.ToInteger(argument); |
|
if (len <= 0) { return 0; } // includes converting -0 to +0 |
|
if (len > MAX_SAFE_INTEGER) { return MAX_SAFE_INTEGER; } |
|
return len; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-canonicalnumericindexstring |
|
CanonicalNumericIndexString: function CanonicalNumericIndexString(argument) { |
|
if (toStr(argument) !== '[object String]') { |
|
throw new $TypeError('must be a string'); |
|
} |
|
if (argument === '-0') { return -0; } |
|
var n = this.ToNumber(argument); |
|
if (this.SameValue(this.ToString(n), argument)) { return n; } |
|
return void 0; |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-requireobjectcoercible |
|
RequireObjectCoercible: ES5.CheckObjectCoercible, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isarray |
|
IsArray: $Array.isArray || function IsArray(argument) { |
|
return toStr(argument) === '[object Array]'; |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-iscallable |
|
// IsCallable: ES5.IsCallable, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isconstructor |
|
IsConstructor: function IsConstructor(argument) { |
|
return typeof argument === 'function' && !!argument.prototype; // unfortunately there's no way to truly check this without try/catch `new argument` |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isextensible-o |
|
IsExtensible: $preventExtensions |
|
? function IsExtensible(obj) { |
|
if (isPrimitive(obj)) { |
|
return false; |
|
} |
|
return $isExtensible(obj); |
|
} |
|
: function isExtensible(obj) { return true; }, // eslint-disable-line no-unused-vars |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isinteger |
|
IsInteger: function IsInteger(argument) { |
|
if (typeof argument !== 'number' || $isNaN(argument) || !$isFinite(argument)) { |
|
return false; |
|
} |
|
var abs = $abs(argument); |
|
return $floor(abs) === abs; |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ispropertykey |
|
IsPropertyKey: function IsPropertyKey(argument) { |
|
return typeof argument === 'string' || typeof argument === 'symbol'; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-isregexp |
|
IsRegExp: function IsRegExp(argument) { |
|
if (!argument || typeof argument !== 'object') { |
|
return false; |
|
} |
|
if (hasSymbols) { |
|
var isRegExp = argument[$Symbol.match]; |
|
if (typeof isRegExp !== 'undefined') { |
|
return ES5.ToBoolean(isRegExp); |
|
} |
|
} |
|
return hasRegExpMatcher(argument); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevalue |
|
// SameValue: ES5.SameValue, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero |
|
SameValueZero: function SameValueZero(x, y) { |
|
return (x === y) || ($isNaN(x) && $isNaN(y)); |
|
}, |
|
|
|
/** |
|
* 7.3.2 GetV (V, P) |
|
* 1. Assert: IsPropertyKey(P) is true. |
|
* 2. Let O be ToObject(V). |
|
* 3. ReturnIfAbrupt(O). |
|
* 4. Return O.[[Get]](P, V). |
|
*/ |
|
GetV: function GetV(V, P) { |
|
// 7.3.2.1 |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
|
|
// 7.3.2.2-3 |
|
var O = this.ToObject(V); |
|
|
|
// 7.3.2.4 |
|
return O[P]; |
|
}, |
|
|
|
/** |
|
* 7.3.9 - https://ecma-international.org/ecma-262/6.0/#sec-getmethod |
|
* 1. Assert: IsPropertyKey(P) is true. |
|
* 2. Let func be GetV(O, P). |
|
* 3. ReturnIfAbrupt(func). |
|
* 4. If func is either undefined or null, return undefined. |
|
* 5. If IsCallable(func) is false, throw a TypeError exception. |
|
* 6. Return func. |
|
*/ |
|
GetMethod: function GetMethod(O, P) { |
|
// 7.3.9.1 |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
|
|
// 7.3.9.2 |
|
var func = this.GetV(O, P); |
|
|
|
// 7.3.9.4 |
|
if (func == null) { |
|
return void 0; |
|
} |
|
|
|
// 7.3.9.5 |
|
if (!this.IsCallable(func)) { |
|
throw new $TypeError(P + 'is not a function'); |
|
} |
|
|
|
// 7.3.9.6 |
|
return func; |
|
}, |
|
|
|
/** |
|
* 7.3.1 Get (O, P) - https://ecma-international.org/ecma-262/6.0/#sec-get-o-p |
|
* 1. Assert: Type(O) is Object. |
|
* 2. Assert: IsPropertyKey(P) is true. |
|
* 3. Return O.[[Get]](P, O). |
|
*/ |
|
Get: function Get(O, P) { |
|
// 7.3.1.1 |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
// 7.3.1.2 |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true, got ' + inspect(P)); |
|
} |
|
// 7.3.1.3 |
|
return O[P]; |
|
}, |
|
|
|
Type: function Type(x) { |
|
if (typeof x === 'symbol') { |
|
return 'Symbol'; |
|
} |
|
return ES5.Type(x); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-speciesconstructor |
|
SpeciesConstructor: function SpeciesConstructor(O, defaultConstructor) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
var C = O.constructor; |
|
if (typeof C === 'undefined') { |
|
return defaultConstructor; |
|
} |
|
if (this.Type(C) !== 'Object') { |
|
throw new $TypeError('O.constructor is not an Object'); |
|
} |
|
var S = hasSymbols && $Symbol.species ? C[$Symbol.species] : void 0; |
|
if (S == null) { |
|
return defaultConstructor; |
|
} |
|
if (this.IsConstructor(S)) { |
|
return S; |
|
} |
|
throw new $TypeError('no constructor found'); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-frompropertydescriptor |
|
FromPropertyDescriptor: function FromPropertyDescriptor(Desc) { |
|
if (typeof Desc === 'undefined') { |
|
return Desc; |
|
} |
|
|
|
assertRecord(this, 'Property Descriptor', 'Desc', Desc); |
|
|
|
var obj = {}; |
|
if ('[[Value]]' in Desc) { |
|
obj.value = Desc['[[Value]]']; |
|
} |
|
if ('[[Writable]]' in Desc) { |
|
obj.writable = Desc['[[Writable]]']; |
|
} |
|
if ('[[Get]]' in Desc) { |
|
obj.get = Desc['[[Get]]']; |
|
} |
|
if ('[[Set]]' in Desc) { |
|
obj.set = Desc['[[Set]]']; |
|
} |
|
if ('[[Enumerable]]' in Desc) { |
|
obj.enumerable = Desc['[[Enumerable]]']; |
|
} |
|
if ('[[Configurable]]' in Desc) { |
|
obj.configurable = Desc['[[Configurable]]']; |
|
} |
|
return obj; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-completepropertydescriptor |
|
CompletePropertyDescriptor: function CompletePropertyDescriptor(Desc) { |
|
assertRecord(this, 'Property Descriptor', 'Desc', Desc); |
|
|
|
if (this.IsGenericDescriptor(Desc) || this.IsDataDescriptor(Desc)) { |
|
if (!has(Desc, '[[Value]]')) { |
|
Desc['[[Value]]'] = void 0; |
|
} |
|
if (!has(Desc, '[[Writable]]')) { |
|
Desc['[[Writable]]'] = false; |
|
} |
|
} else { |
|
if (!has(Desc, '[[Get]]')) { |
|
Desc['[[Get]]'] = void 0; |
|
} |
|
if (!has(Desc, '[[Set]]')) { |
|
Desc['[[Set]]'] = void 0; |
|
} |
|
} |
|
if (!has(Desc, '[[Enumerable]]')) { |
|
Desc['[[Enumerable]]'] = false; |
|
} |
|
if (!has(Desc, '[[Configurable]]')) { |
|
Desc['[[Configurable]]'] = false; |
|
} |
|
return Desc; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-set-o-p-v-throw |
|
Set: function Set(O, P, V, Throw) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('O must be an Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('P must be a Property Key'); |
|
} |
|
if (this.Type(Throw) !== 'Boolean') { |
|
throw new $TypeError('Throw must be a Boolean'); |
|
} |
|
if (Throw) { |
|
O[P] = V; |
|
return true; |
|
} else { |
|
try { |
|
O[P] = V; |
|
} catch (e) { |
|
return false; |
|
} |
|
} |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-hasownproperty |
|
HasOwnProperty: function HasOwnProperty(O, P) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('O must be an Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('P must be a Property Key'); |
|
} |
|
return has(O, P); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-hasproperty |
|
HasProperty: function HasProperty(O, P) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('O must be an Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('P must be a Property Key'); |
|
} |
|
return P in O; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-isconcatspreadable |
|
IsConcatSpreadable: function IsConcatSpreadable(O) { |
|
if (this.Type(O) !== 'Object') { |
|
return false; |
|
} |
|
if (hasSymbols && typeof $Symbol.isConcatSpreadable === 'symbol') { |
|
var spreadable = this.Get(O, Symbol.isConcatSpreadable); |
|
if (typeof spreadable !== 'undefined') { |
|
return this.ToBoolean(spreadable); |
|
} |
|
} |
|
return this.IsArray(O); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-invoke |
|
Invoke: function Invoke(O, P) { |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('P must be a Property Key'); |
|
} |
|
var argumentsList = arraySlice(arguments, 2); |
|
var func = this.GetV(O, P); |
|
return this.Call(func, O, argumentsList); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-getiterator |
|
GetIterator: function GetIterator(obj, method) { |
|
var actualMethod = method; |
|
if (arguments.length < 2) { |
|
if (!hasSymbols) { |
|
throw new SyntaxError('GetIterator depends on native Symbol support when `method` is not passed'); |
|
} |
|
actualMethod = this.GetMethod(obj, $Symbol.iterator); |
|
} |
|
var iterator = this.Call(actualMethod, obj); |
|
if (this.Type(iterator) !== 'Object') { |
|
throw new $TypeError('iterator must return an object'); |
|
} |
|
|
|
return iterator; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-iteratornext |
|
IteratorNext: function IteratorNext(iterator, value) { |
|
var result = this.Invoke(iterator, 'next', arguments.length < 2 ? [] : [value]); |
|
if (this.Type(result) !== 'Object') { |
|
throw new $TypeError('iterator next must return an object'); |
|
} |
|
return result; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-iteratorcomplete |
|
IteratorComplete: function IteratorComplete(iterResult) { |
|
if (this.Type(iterResult) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(iterResult) is not Object'); |
|
} |
|
return this.ToBoolean(this.Get(iterResult, 'done')); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-iteratorvalue |
|
IteratorValue: function IteratorValue(iterResult) { |
|
if (this.Type(iterResult) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(iterResult) is not Object'); |
|
} |
|
return this.Get(iterResult, 'value'); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-iteratorstep |
|
IteratorStep: function IteratorStep(iterator) { |
|
var result = this.IteratorNext(iterator); |
|
var done = this.IteratorComplete(result); |
|
return done === true ? false : result; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-iteratorclose |
|
IteratorClose: function IteratorClose(iterator, completion) { |
|
if (this.Type(iterator) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(iterator) is not Object'); |
|
} |
|
if (!this.IsCallable(completion)) { |
|
throw new $TypeError('Assertion failed: completion is not a thunk for a Completion Record'); |
|
} |
|
var completionThunk = completion; |
|
|
|
var iteratorReturn = this.GetMethod(iterator, 'return'); |
|
|
|
if (typeof iteratorReturn === 'undefined') { |
|
return completionThunk(); |
|
} |
|
|
|
var completionRecord; |
|
try { |
|
var innerResult = this.Call(iteratorReturn, iterator, []); |
|
} catch (e) { |
|
// if we hit here, then "e" is the innerResult completion that needs re-throwing |
|
|
|
// if the completion is of type "throw", this will throw. |
|
completionRecord = completionThunk(); |
|
completionThunk = null; // ensure it's not called twice. |
|
|
|
// if not, then return the innerResult completion |
|
throw e; |
|
} |
|
completionRecord = completionThunk(); // if innerResult worked, then throw if the completion does |
|
completionThunk = null; // ensure it's not called twice. |
|
|
|
if (this.Type(innerResult) !== 'Object') { |
|
throw new $TypeError('iterator .return must return an object'); |
|
} |
|
|
|
return completionRecord; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-createiterresultobject |
|
CreateIterResultObject: function CreateIterResultObject(value, done) { |
|
if (this.Type(done) !== 'Boolean') { |
|
throw new $TypeError('Assertion failed: Type(done) is not Boolean'); |
|
} |
|
return { |
|
value: value, |
|
done: done |
|
}; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-regexpexec |
|
RegExpExec: function RegExpExec(R, S) { |
|
if (this.Type(R) !== 'Object') { |
|
throw new $TypeError('R must be an Object'); |
|
} |
|
if (this.Type(S) !== 'String') { |
|
throw new $TypeError('S must be a String'); |
|
} |
|
var exec = this.Get(R, 'exec'); |
|
if (this.IsCallable(exec)) { |
|
var result = this.Call(exec, R, [S]); |
|
if (result === null || this.Type(result) === 'Object') { |
|
return result; |
|
} |
|
throw new $TypeError('"exec" method must return `null` or an Object'); |
|
} |
|
return regexExec(R, S); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-arrayspeciescreate |
|
ArraySpeciesCreate: function ArraySpeciesCreate(originalArray, length) { |
|
if (!this.IsInteger(length) || length < 0) { |
|
throw new $TypeError('Assertion failed: length must be an integer >= 0'); |
|
} |
|
var len = length === 0 ? 0 : length; |
|
var C; |
|
var isArray = this.IsArray(originalArray); |
|
if (isArray) { |
|
C = this.Get(originalArray, 'constructor'); |
|
// TODO: figure out how to make a cross-realm normal Array, a same-realm Array |
|
// if (this.IsConstructor(C)) { |
|
// if C is another realm's Array, C = undefined |
|
// Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(Array))) === null ? |
|
// } |
|
if (this.Type(C) === 'Object' && hasSymbols && $Symbol.species) { |
|
C = this.Get(C, $Symbol.species); |
|
if (C === null) { |
|
C = void 0; |
|
} |
|
} |
|
} |
|
if (typeof C === 'undefined') { |
|
return $Array(len); |
|
} |
|
if (!this.IsConstructor(C)) { |
|
throw new $TypeError('C must be a constructor'); |
|
} |
|
return new C(len); // this.Construct(C, len); |
|
}, |
|
|
|
CreateDataProperty: function CreateDataProperty(O, P, V) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
var oldDesc = $gOPD(O, P); |
|
var extensible = oldDesc || this.IsExtensible(O); |
|
var immutable = oldDesc && (!oldDesc.writable || !oldDesc.configurable); |
|
if (immutable || !extensible) { |
|
return false; |
|
} |
|
return DefineOwnProperty(this, O, P, { |
|
'[[Configurable]]': true, |
|
'[[Enumerable]]': true, |
|
'[[Value]]': V, |
|
'[[Writable]]': true |
|
}); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-createdatapropertyorthrow |
|
CreateDataPropertyOrThrow: function CreateDataPropertyOrThrow(O, P, V) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
var success = this.CreateDataProperty(O, P, V); |
|
if (!success) { |
|
throw new $TypeError('unable to create data property'); |
|
} |
|
return success; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-objectcreate |
|
ObjectCreate: function ObjectCreate(proto, internalSlotsList) { |
|
if (proto !== null && this.Type(proto) !== 'Object') { |
|
throw new $TypeError('Assertion failed: proto must be null or an object'); |
|
} |
|
var slots = arguments.length < 2 ? [] : internalSlotsList; |
|
if (slots.length > 0) { |
|
throw new $SyntaxError('es-abstract does not yet support internal slots'); |
|
} |
|
|
|
if (proto === null && !$ObjectCreate) { |
|
throw new $SyntaxError('native Object.create support is required to create null objects'); |
|
} |
|
|
|
return $ObjectCreate(proto); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-advancestringindex |
|
AdvanceStringIndex: function AdvanceStringIndex(S, index, unicode) { |
|
if (this.Type(S) !== 'String') { |
|
throw new $TypeError('S must be a String'); |
|
} |
|
if (!this.IsInteger(index) || index < 0 || index > MAX_SAFE_INTEGER) { |
|
throw new $TypeError('Assertion failed: length must be an integer >= 0 and <= 2**53'); |
|
} |
|
if (this.Type(unicode) !== 'Boolean') { |
|
throw new $TypeError('Assertion failed: unicode must be a Boolean'); |
|
} |
|
if (!unicode) { |
|
return index + 1; |
|
} |
|
var length = S.length; |
|
if ((index + 1) >= length) { |
|
return index + 1; |
|
} |
|
|
|
var first = $charCodeAt(S, index); |
|
if (first < 0xD800 || first > 0xDBFF) { |
|
return index + 1; |
|
} |
|
|
|
var second = $charCodeAt(S, index + 1); |
|
if (second < 0xDC00 || second > 0xDFFF) { |
|
return index + 1; |
|
} |
|
|
|
return index + 2; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-createmethodproperty |
|
CreateMethodProperty: function CreateMethodProperty(O, P, V) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
|
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
|
|
var newDesc = { |
|
'[[Configurable]]': true, |
|
'[[Enumerable]]': false, |
|
'[[Value]]': V, |
|
'[[Writable]]': true |
|
}; |
|
return DefineOwnProperty(this, O, P, newDesc); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-definepropertyorthrow |
|
DefinePropertyOrThrow: function DefinePropertyOrThrow(O, P, desc) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
|
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
|
|
var Desc = isPropertyDescriptor(this, desc) ? desc : this.ToPropertyDescriptor(desc); |
|
if (!isPropertyDescriptor(this, Desc)) { |
|
throw new $TypeError('Assertion failed: Desc is not a valid Property Descriptor'); |
|
} |
|
|
|
return DefineOwnProperty(this, O, P, Desc); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-deletepropertyorthrow |
|
DeletePropertyOrThrow: function DeletePropertyOrThrow(O, P) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
|
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
|
|
var success = delete O[P]; |
|
if (!success) { |
|
throw new TypeError('Attempt to delete property failed.'); |
|
} |
|
return success; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-enumerableownnames |
|
EnumerableOwnNames: function EnumerableOwnNames(O) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
|
|
return keys(O); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-number-prototype-object |
|
thisNumberValue: function thisNumberValue(value) { |
|
if (this.Type(value) === 'Number') { |
|
return value; |
|
} |
|
|
|
return $NumberValueOf(value); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-boolean-prototype-object |
|
thisBooleanValue: function thisBooleanValue(value) { |
|
if (this.Type(value) === 'Boolean') { |
|
return value; |
|
} |
|
|
|
return $BooleanValueOf(value); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-string-prototype-object |
|
thisStringValue: function thisStringValue(value) { |
|
if (this.Type(value) === 'String') { |
|
return value; |
|
} |
|
|
|
return $StringValueOf(value); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-date-prototype-object |
|
thisTimeValue: function thisTimeValue(value) { |
|
return $DateValueOf(value); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-setintegritylevel |
|
SetIntegrityLevel: function SetIntegrityLevel(O, level) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
if (level !== 'sealed' && level !== 'frozen') { |
|
throw new $TypeError('Assertion failed: `level` must be `"sealed"` or `"frozen"`'); |
|
} |
|
if (!$preventExtensions) { |
|
throw new $SyntaxError('SetIntegrityLevel requires native `Object.preventExtensions` support'); |
|
} |
|
var status = $preventExtensions(O); |
|
if (!status) { |
|
return false; |
|
} |
|
if (!$gOPN) { |
|
throw new $SyntaxError('SetIntegrityLevel requires native `Object.getOwnPropertyNames` support'); |
|
} |
|
var theKeys = $gOPN(O); |
|
var ES = this; |
|
if (level === 'sealed') { |
|
forEach(theKeys, function (k) { |
|
ES.DefinePropertyOrThrow(O, k, { configurable: false }); |
|
}); |
|
} else if (level === 'frozen') { |
|
forEach(theKeys, function (k) { |
|
var currentDesc = $gOPD(O, k); |
|
if (typeof currentDesc !== 'undefined') { |
|
var desc; |
|
if (ES.IsAccessorDescriptor(ES.ToPropertyDescriptor(currentDesc))) { |
|
desc = { configurable: false }; |
|
} else { |
|
desc = { configurable: false, writable: false }; |
|
} |
|
ES.DefinePropertyOrThrow(O, k, desc); |
|
} |
|
}); |
|
} |
|
return true; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-testintegritylevel |
|
TestIntegrityLevel: function TestIntegrityLevel(O, level) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
if (level !== 'sealed' && level !== 'frozen') { |
|
throw new $TypeError('Assertion failed: `level` must be `"sealed"` or `"frozen"`'); |
|
} |
|
var status = this.IsExtensible(O); |
|
if (status) { |
|
return false; |
|
} |
|
var theKeys = $gOPN(O); |
|
var ES = this; |
|
return theKeys.length === 0 || every(theKeys, function (k) { |
|
var currentDesc = $gOPD(O, k); |
|
if (typeof currentDesc !== 'undefined') { |
|
if (currentDesc.configurable) { |
|
return false; |
|
} |
|
if (level === 'frozen' && ES.IsDataDescriptor(ES.ToPropertyDescriptor(currentDesc)) && currentDesc.writable) { |
|
return false; |
|
} |
|
} |
|
return true; |
|
}); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-ordinaryhasinstance |
|
OrdinaryHasInstance: function OrdinaryHasInstance(C, O) { |
|
if (this.IsCallable(C) === false) { |
|
return false; |
|
} |
|
if (this.Type(O) !== 'Object') { |
|
return false; |
|
} |
|
var P = this.Get(C, 'prototype'); |
|
if (this.Type(P) !== 'Object') { |
|
throw new $TypeError('OrdinaryHasInstance called on an object with an invalid prototype property.'); |
|
} |
|
return O instanceof C; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-ordinaryhasproperty |
|
OrdinaryHasProperty: function OrdinaryHasProperty(O, P) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: P must be a Property Key'); |
|
} |
|
return P in O; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-instanceofoperator |
|
InstanceofOperator: function InstanceofOperator(O, C) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
var instOfHandler = hasSymbols && $Symbol.hasInstance ? this.GetMethod(C, $Symbol.hasInstance) : void 0; |
|
if (typeof instOfHandler !== 'undefined') { |
|
return this.ToBoolean(this.Call(instOfHandler, C, [O])); |
|
} |
|
if (!this.IsCallable(C)) { |
|
throw new $TypeError('`C` is not Callable'); |
|
} |
|
return this.OrdinaryHasInstance(C, O); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-ispromise |
|
IsPromise: function IsPromise(x) { |
|
if (this.Type(x) !== 'Object') { |
|
return false; |
|
} |
|
if (!$PromiseThen) { // Promises are not supported |
|
return false; |
|
} |
|
try { |
|
$PromiseThen(x); // throws if not a promise |
|
} catch (e) { |
|
return false; |
|
} |
|
return true; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-abstract-equality-comparison |
|
'Abstract Equality Comparison': function AbstractEqualityComparison(x, y) { |
|
var xType = this.Type(x); |
|
var yType = this.Type(y); |
|
if (xType === yType) { |
|
return x === y; // ES6+ specified this shortcut anyways. |
|
} |
|
if (x == null && y == null) { |
|
return true; |
|
} |
|
if (xType === 'Number' && yType === 'String') { |
|
return this['Abstract Equality Comparison'](x, this.ToNumber(y)); |
|
} |
|
if (xType === 'String' && yType === 'Number') { |
|
return this['Abstract Equality Comparison'](this.ToNumber(x), y); |
|
} |
|
if (xType === 'Boolean') { |
|
return this['Abstract Equality Comparison'](this.ToNumber(x), y); |
|
} |
|
if (yType === 'Boolean') { |
|
return this['Abstract Equality Comparison'](x, this.ToNumber(y)); |
|
} |
|
if ((xType === 'String' || xType === 'Number' || xType === 'Symbol') && yType === 'Object') { |
|
return this['Abstract Equality Comparison'](x, this.ToPrimitive(y)); |
|
} |
|
if (xType === 'Object' && (yType === 'String' || yType === 'Number' || yType === 'Symbol')) { |
|
return this['Abstract Equality Comparison'](this.ToPrimitive(x), y); |
|
} |
|
return false; |
|
}, |
|
|
|
// eslint-disable-next-line max-lines-per-function, max-statements, id-length, max-params |
|
ValidateAndApplyPropertyDescriptor: function ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current) { |
|
// this uses the ES2017+ logic, since it fixes a number of bugs in the ES2015 logic. |
|
var oType = this.Type(O); |
|
if (oType !== 'Undefined' && oType !== 'Object') { |
|
throw new $TypeError('Assertion failed: O must be undefined or an Object'); |
|
} |
|
if (this.Type(extensible) !== 'Boolean') { |
|
throw new $TypeError('Assertion failed: extensible must be a Boolean'); |
|
} |
|
if (!isPropertyDescriptor(this, Desc)) { |
|
throw new $TypeError('Assertion failed: Desc must be a Property Descriptor'); |
|
} |
|
if (this.Type(current) !== 'Undefined' && !isPropertyDescriptor(this, current)) { |
|
throw new $TypeError('Assertion failed: current must be a Property Descriptor, or undefined'); |
|
} |
|
if (oType !== 'Undefined' && !this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: if O is not undefined, P must be a Property Key'); |
|
} |
|
if (this.Type(current) === 'Undefined') { |
|
if (!extensible) { |
|
return false; |
|
} |
|
if (this.IsGenericDescriptor(Desc) || this.IsDataDescriptor(Desc)) { |
|
if (oType !== 'Undefined') { |
|
DefineOwnProperty(this, O, P, { |
|
'[[Configurable]]': Desc['[[Configurable]]'], |
|
'[[Enumerable]]': Desc['[[Enumerable]]'], |
|
'[[Value]]': Desc['[[Value]]'], |
|
'[[Writable]]': Desc['[[Writable]]'] |
|
}); |
|
} |
|
} else { |
|
if (!this.IsAccessorDescriptor(Desc)) { |
|
throw new $TypeError('Assertion failed: Desc is not an accessor descriptor'); |
|
} |
|
if (oType !== 'Undefined') { |
|
return DefineOwnProperty(this, O, P, Desc); |
|
} |
|
} |
|
return true; |
|
} |
|
if (this.IsGenericDescriptor(Desc) && !('[[Configurable]]' in Desc) && !('[[Enumerable]]' in Desc)) { |
|
return true; |
|
} |
|
if (isSamePropertyDescriptor(this, Desc, current)) { |
|
return true; // removed by ES2017, but should still be correct |
|
} |
|
// "if every field in Desc is absent, return true" can't really match the assertion that it's a Property Descriptor |
|
if (!current['[[Configurable]]']) { |
|
if (Desc['[[Configurable]]']) { |
|
return false; |
|
} |
|
if ('[[Enumerable]]' in Desc && !Desc['[[Enumerable]]'] === !!current['[[Enumerable]]']) { |
|
return false; |
|
} |
|
} |
|
if (this.IsGenericDescriptor(Desc)) { |
|
// no further validation is required. |
|
} else if (this.IsDataDescriptor(current) !== this.IsDataDescriptor(Desc)) { |
|
if (!current['[[Configurable]]']) { |
|
return false; |
|
} |
|
if (this.IsDataDescriptor(current)) { |
|
if (oType !== 'Undefined') { |
|
DefineOwnProperty(this, O, P, { |
|
'[[Configurable]]': current['[[Configurable]]'], |
|
'[[Enumerable]]': current['[[Enumerable]]'], |
|
'[[Get]]': undefined |
|
}); |
|
} |
|
} else if (oType !== 'Undefined') { |
|
DefineOwnProperty(this, O, P, { |
|
'[[Configurable]]': current['[[Configurable]]'], |
|
'[[Enumerable]]': current['[[Enumerable]]'], |
|
'[[Value]]': undefined |
|
}); |
|
} |
|
} else if (this.IsDataDescriptor(current) && this.IsDataDescriptor(Desc)) { |
|
if (!current['[[Configurable]]'] && !current['[[Writable]]']) { |
|
if ('[[Writable]]' in Desc && Desc['[[Writable]]']) { |
|
return false; |
|
} |
|
if ('[[Value]]' in Desc && !this.SameValue(Desc['[[Value]]'], current['[[Value]]'])) { |
|
return false; |
|
} |
|
return true; |
|
} |
|
} else if (this.IsAccessorDescriptor(current) && this.IsAccessorDescriptor(Desc)) { |
|
if (!current['[[Configurable]]']) { |
|
if ('[[Set]]' in Desc && !this.SameValue(Desc['[[Set]]'], current['[[Set]]'])) { |
|
return false; |
|
} |
|
if ('[[Get]]' in Desc && !this.SameValue(Desc['[[Get]]'], current['[[Get]]'])) { |
|
return false; |
|
} |
|
return true; |
|
} |
|
} else { |
|
throw new $TypeError('Assertion failed: current and Desc are not both data, both accessors, or one accessor and one data.'); |
|
} |
|
if (oType !== 'Undefined') { |
|
return DefineOwnProperty(this, O, P, Desc); |
|
} |
|
return true; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-ordinarydefineownproperty |
|
OrdinaryDefineOwnProperty: function OrdinaryDefineOwnProperty(O, P, Desc) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: O must be an Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: P must be a Property Key'); |
|
} |
|
if (!isPropertyDescriptor(this, Desc)) { |
|
throw new $TypeError('Assertion failed: Desc must be a Property Descriptor'); |
|
} |
|
var desc = $gOPD(O, P); |
|
var current = desc && this.ToPropertyDescriptor(desc); |
|
var extensible = this.IsExtensible(O); |
|
return this.ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-ordinarygetownproperty |
|
OrdinaryGetOwnProperty: function OrdinaryGetOwnProperty(O, P) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: O must be an Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: P must be a Property Key'); |
|
} |
|
if (!has(O, P)) { |
|
return void 0; |
|
} |
|
if (!$gOPD) { |
|
// ES3 fallback |
|
var arrayLength = this.IsArray(O) && P === 'length'; |
|
var regexLastIndex = this.IsRegExp(O) && P === 'lastIndex'; |
|
return { |
|
'[[Configurable]]': !(arrayLength || regexLastIndex), |
|
'[[Enumerable]]': $isEnumerable(O, P), |
|
'[[Value]]': O[P], |
|
'[[Writable]]': true |
|
}; |
|
} |
|
return this.ToPropertyDescriptor($gOPD(O, P)); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-arraycreate |
|
ArrayCreate: function ArrayCreate(length) { |
|
if (!this.IsInteger(length) || length < 0) { |
|
throw new $TypeError('Assertion failed: `length` must be an integer Number >= 0'); |
|
} |
|
if (length > MAX_ARRAY_LENGTH) { |
|
throw new $RangeError('length is greater than (2**32 - 1)'); |
|
} |
|
var proto = arguments.length > 1 ? arguments[1] : $ArrayPrototype; |
|
var A = []; // steps 5 - 7, and 9 |
|
if (proto !== $ArrayPrototype) { // step 8 |
|
if (!$setProto) { |
|
throw new $SyntaxError('ArrayCreate: a `proto` argument that is not `Array.prototype` is not supported in an environment that does not support setting the [[Prototype]]'); |
|
} |
|
$setProto(A, proto); |
|
} |
|
if (length !== 0) { // bypasses the need for step 2 |
|
A.length = length; |
|
} |
|
/* step 10, the above as a shortcut for the below |
|
this.OrdinaryDefineOwnProperty(A, 'length', { |
|
'[[Configurable]]': false, |
|
'[[Enumerable]]': false, |
|
'[[Value]]': length, |
|
'[[Writable]]': true |
|
}); |
|
*/ |
|
return A; |
|
}, |
|
|
|
// eslint-disable-next-line max-statements, max-lines-per-function |
|
ArraySetLength: function ArraySetLength(A, Desc) { |
|
if (!this.IsArray(A)) { |
|
throw new $TypeError('Assertion failed: A must be an Array'); |
|
} |
|
if (!isPropertyDescriptor(this, Desc)) { |
|
throw new $TypeError('Assertion failed: Desc must be a Property Descriptor'); |
|
} |
|
if (!('[[Value]]' in Desc)) { |
|
return this.OrdinaryDefineOwnProperty(A, 'length', Desc); |
|
} |
|
var newLenDesc = assign({}, Desc); |
|
var newLen = this.ToUint32(Desc['[[Value]]']); |
|
var numberLen = this.ToNumber(Desc['[[Value]]']); |
|
if (newLen !== numberLen) { |
|
throw new $RangeError('Invalid array length'); |
|
} |
|
newLenDesc['[[Value]]'] = newLen; |
|
var oldLenDesc = this.OrdinaryGetOwnProperty(A, 'length'); |
|
if (!this.IsDataDescriptor(oldLenDesc)) { |
|
throw new $TypeError('Assertion failed: an array had a non-data descriptor on `length`'); |
|
} |
|
var oldLen = oldLenDesc['[[Value]]']; |
|
if (newLen >= oldLen) { |
|
return this.OrdinaryDefineOwnProperty(A, 'length', newLenDesc); |
|
} |
|
if (!oldLenDesc['[[Writable]]']) { |
|
return false; |
|
} |
|
var newWritable; |
|
if (!('[[Writable]]' in newLenDesc) || newLenDesc['[[Writable]]']) { |
|
newWritable = true; |
|
} else { |
|
newWritable = false; |
|
newLenDesc['[[Writable]]'] = true; |
|
} |
|
var succeeded = this.OrdinaryDefineOwnProperty(A, 'length', newLenDesc); |
|
if (!succeeded) { |
|
return false; |
|
} |
|
while (newLen < oldLen) { |
|
oldLen -= 1; |
|
var deleteSucceeded = delete A[this.ToString(oldLen)]; |
|
if (!deleteSucceeded) { |
|
newLenDesc['[[Value]]'] = oldLen + 1; |
|
if (!newWritable) { |
|
newLenDesc['[[Writable]]'] = false; |
|
this.OrdinaryDefineOwnProperty(A, 'length', newLenDesc); |
|
return false; |
|
} |
|
} |
|
} |
|
if (!newWritable) { |
|
return this.OrdinaryDefineOwnProperty(A, 'length', { '[[Writable]]': false }); |
|
} |
|
return true; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-createhtml |
|
CreateHTML: function CreateHTML(string, tag, attribute, value) { |
|
if (this.Type(tag) !== 'String' || this.Type(attribute) !== 'String') { |
|
throw new $TypeError('Assertion failed: `tag` and `attribute` must be strings'); |
|
} |
|
var str = this.RequireObjectCoercible(string); |
|
var S = this.ToString(str); |
|
var p1 = '<' + tag; |
|
if (attribute !== '') { |
|
var V = this.ToString(value); |
|
var escapedV = $replace(V, /\x22/g, '"'); |
|
p1 += '\x20' + attribute + '\x3D\x22' + escapedV + '\x22'; |
|
} |
|
return p1 + '>' + S + '</' + tag + '>'; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-getownpropertykeys |
|
GetOwnPropertyKeys: function GetOwnPropertyKeys(O, Type) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
if (Type === 'Symbol') { |
|
return hasSymbols && $gOPS ? $gOPS(O) : []; |
|
} |
|
if (Type === 'String') { |
|
if (!$gOPN) { |
|
return keys(O); |
|
} |
|
return $gOPN(O); |
|
} |
|
throw new $TypeError('Assertion failed: `Type` must be `"String"` or `"Symbol"`'); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-symboldescriptivestring |
|
SymbolDescriptiveString: function SymbolDescriptiveString(sym) { |
|
if (this.Type(sym) !== 'Symbol') { |
|
throw new $TypeError('Assertion failed: `sym` must be a Symbol'); |
|
} |
|
return $SymbolToString(sym); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-getsubstitution |
|
// eslint-disable-next-line max-statements, max-params, max-lines-per-function |
|
GetSubstitution: function GetSubstitution(matched, str, position, captures, replacement) { |
|
if (this.Type(matched) !== 'String') { |
|
throw new $TypeError('Assertion failed: `matched` must be a String'); |
|
} |
|
var matchLength = matched.length; |
|
|
|
if (this.Type(str) !== 'String') { |
|
throw new $TypeError('Assertion failed: `str` must be a String'); |
|
} |
|
var stringLength = str.length; |
|
|
|
if (!this.IsInteger(position) || position < 0 || position > stringLength) { |
|
throw new $TypeError('Assertion failed: `position` must be a nonnegative integer, and less than or equal to the length of `string`, got ' + inspect(position)); |
|
} |
|
|
|
var ES = this; |
|
var isStringOrHole = function (capture, index, arr) { return ES.Type(capture) === 'String' || !(index in arr); }; |
|
if (!this.IsArray(captures) || !every(captures, isStringOrHole)) { |
|
throw new $TypeError('Assertion failed: `captures` must be a List of Strings, got ' + inspect(captures)); |
|
} |
|
|
|
if (this.Type(replacement) !== 'String') { |
|
throw new $TypeError('Assertion failed: `replacement` must be a String'); |
|
} |
|
|
|
var tailPos = position + matchLength; |
|
var m = captures.length; |
|
|
|
var result = ''; |
|
for (var i = 0; i < replacement.length; i += 1) { |
|
// if this is a $, and it's not the end of the replacement |
|
var current = replacement[i]; |
|
var isLast = (i + 1) >= replacement.length; |
|
var nextIsLast = (i + 2) >= replacement.length; |
|
if (current === '$' && !isLast) { |
|
var next = replacement[i + 1]; |
|
if (next === '$') { |
|
result += '$'; |
|
i += 1; |
|
} else if (next === '&') { |
|
result += matched; |
|
i += 1; |
|
} else if (next === '`') { |
|
result += position === 0 ? '' : strSlice(str, 0, position - 1); |
|
i += 1; |
|
} else if (next === "'") { |
|
result += tailPos >= stringLength ? '' : strSlice(str, tailPos); |
|
i += 1; |
|
} else { |
|
var nextNext = nextIsLast ? null : replacement[i + 2]; |
|
if (isDigit(next) && next !== '0' && (nextIsLast || !isDigit(nextNext))) { |
|
// $1 through $9, and not followed by a digit |
|
var n = parseInteger(next, 10); |
|
// if (n > m, impl-defined) |
|
result += (n <= m && this.Type(captures[n - 1]) === 'Undefined') ? '' : captures[n - 1]; |
|
i += 1; |
|
} else if (isDigit(next) && (nextIsLast || isDigit(nextNext))) { |
|
// $00 through $99 |
|
var nn = next + nextNext; |
|
var nnI = parseInteger(nn, 10) - 1; |
|
// if nn === '00' or nn > m, impl-defined |
|
result += (nn <= m && this.Type(captures[nnI]) === 'Undefined') ? '' : captures[nnI]; |
|
i += 2; |
|
} else { |
|
result += '$'; |
|
} |
|
} |
|
} else { |
|
// the final $, or else not a $ |
|
result += replacement[i]; |
|
} |
|
} |
|
return result; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-todatestring |
|
ToDateString: function ToDateString(tv) { |
|
if (this.Type(tv) !== 'Number') { |
|
throw new $TypeError('Assertion failed: `tv` must be a Number'); |
|
} |
|
if ($isNaN(tv)) { |
|
return 'Invalid Date'; |
|
} |
|
return $Date(tv); |
|
} |
|
}); |
|
|
|
delete ES6.CheckObjectCoercible; // renamed in ES6 to RequireObjectCoercible |
|
|
|
module.exports = ES6; |
|
|
|
|
|
/***/ }), |
|
/* 255 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var hasSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol'; |
|
|
|
var isPrimitive = __webpack_require__(155); |
|
var isCallable = __webpack_require__(101); |
|
var isDate = __webpack_require__(256); |
|
var isSymbol = __webpack_require__(156); |
|
|
|
var ordinaryToPrimitive = function OrdinaryToPrimitive(O, hint) { |
|
if (typeof O === 'undefined' || O === null) { |
|
throw new TypeError('Cannot call method on ' + O); |
|
} |
|
if (typeof hint !== 'string' || (hint !== 'number' && hint !== 'string')) { |
|
throw new TypeError('hint must be "string" or "number"'); |
|
} |
|
var methodNames = hint === 'string' ? ['toString', 'valueOf'] : ['valueOf', 'toString']; |
|
var method, result, i; |
|
for (i = 0; i < methodNames.length; ++i) { |
|
method = O[methodNames[i]]; |
|
if (isCallable(method)) { |
|
result = method.call(O); |
|
if (isPrimitive(result)) { |
|
return result; |
|
} |
|
} |
|
} |
|
throw new TypeError('No default value'); |
|
}; |
|
|
|
var GetMethod = function GetMethod(O, P) { |
|
var func = O[P]; |
|
if (func !== null && typeof func !== 'undefined') { |
|
if (!isCallable(func)) { |
|
throw new TypeError(func + ' returned for property ' + P + ' of object ' + O + ' is not a function'); |
|
} |
|
return func; |
|
} |
|
return void 0; |
|
}; |
|
|
|
// http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive |
|
module.exports = function ToPrimitive(input) { |
|
if (isPrimitive(input)) { |
|
return input; |
|
} |
|
var hint = 'default'; |
|
if (arguments.length > 1) { |
|
if (arguments[1] === String) { |
|
hint = 'string'; |
|
} else if (arguments[1] === Number) { |
|
hint = 'number'; |
|
} |
|
} |
|
|
|
var exoticToPrim; |
|
if (hasSymbols) { |
|
if (Symbol.toPrimitive) { |
|
exoticToPrim = GetMethod(input, Symbol.toPrimitive); |
|
} else if (isSymbol(input)) { |
|
exoticToPrim = Symbol.prototype.valueOf; |
|
} |
|
} |
|
if (typeof exoticToPrim !== 'undefined') { |
|
var result = exoticToPrim.call(input, hint); |
|
if (isPrimitive(result)) { |
|
return result; |
|
} |
|
throw new TypeError('unable to convert exotic object to primitive'); |
|
} |
|
if (hint === 'default' && (isDate(input) || isSymbol(input))) { |
|
hint = 'string'; |
|
} |
|
return ordinaryToPrimitive(input, hint === 'default' ? 'number' : hint); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 256 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var getDay = Date.prototype.getDay; |
|
var tryDateObject = function tryDateObject(value) { |
|
try { |
|
getDay.call(value); |
|
return true; |
|
} catch (e) { |
|
return false; |
|
} |
|
}; |
|
|
|
var toStr = Object.prototype.toString; |
|
var dateClass = '[object Date]'; |
|
var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol'; |
|
|
|
module.exports = function isDateObject(value) { |
|
if (typeof value !== 'object' || value === null) { return false; } |
|
return hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 257 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
module.exports = function isPrimitive(value) { |
|
return value === null || (typeof value !== 'function' && typeof value !== 'object'); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 258 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var every = __webpack_require__(132); |
|
|
|
module.exports = function isSamePropertyDescriptor(ES, D1, D2) { |
|
var fields = [ |
|
'[[Configurable]]', |
|
'[[Enumerable]]', |
|
'[[Get]]', |
|
'[[Set]]', |
|
'[[Value]]', |
|
'[[Writable]]' |
|
]; |
|
return every(fields, function (field) { |
|
if ((field in D1) !== (field in D2)) { |
|
return false; |
|
} |
|
return ES.SameValue(D1[field], D2[field]); |
|
}); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 259 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var GetIntrinsic = __webpack_require__(60); |
|
|
|
var $Object = GetIntrinsic('%Object%'); |
|
var $EvalError = GetIntrinsic('%EvalError%'); |
|
var $TypeError = GetIntrinsic('%TypeError%'); |
|
var $String = GetIntrinsic('%String%'); |
|
var $Date = GetIntrinsic('%Date%'); |
|
var $Number = GetIntrinsic('%Number%'); |
|
var $floor = GetIntrinsic('%Math.floor%'); |
|
var $DateUTC = GetIntrinsic('%Date.UTC%'); |
|
var $abs = GetIntrinsic('%Math.abs%'); |
|
|
|
var assertRecord = __webpack_require__(157); |
|
var isPropertyDescriptor = __webpack_require__(162); |
|
var $isNaN = __webpack_require__(130); |
|
var $isFinite = __webpack_require__(158); |
|
var sign = __webpack_require__(160); |
|
var mod = __webpack_require__(161); |
|
var isPrefixOf = __webpack_require__(164); |
|
var callBound = __webpack_require__(75); |
|
|
|
var IsCallable = __webpack_require__(101); |
|
var toPrimitive = __webpack_require__(165); |
|
|
|
var has = __webpack_require__(63); |
|
|
|
var $getUTCFullYear = callBound('Date.prototype.getUTCFullYear'); |
|
|
|
var HoursPerDay = 24; |
|
var MinutesPerHour = 60; |
|
var SecondsPerMinute = 60; |
|
var msPerSecond = 1e3; |
|
var msPerMinute = msPerSecond * SecondsPerMinute; |
|
var msPerHour = msPerMinute * MinutesPerHour; |
|
var msPerDay = 86400000; |
|
|
|
// https://es5.github.io/#x9 |
|
var ES5 = { |
|
ToPrimitive: toPrimitive, |
|
|
|
ToBoolean: function ToBoolean(value) { |
|
return !!value; |
|
}, |
|
ToNumber: function ToNumber(value) { |
|
return +value; // eslint-disable-line no-implicit-coercion |
|
}, |
|
ToInteger: function ToInteger(value) { |
|
var number = this.ToNumber(value); |
|
if ($isNaN(number)) { return 0; } |
|
if (number === 0 || !$isFinite(number)) { return number; } |
|
return sign(number) * Math.floor(Math.abs(number)); |
|
}, |
|
ToInt32: function ToInt32(x) { |
|
return this.ToNumber(x) >> 0; |
|
}, |
|
ToUint32: function ToUint32(x) { |
|
return this.ToNumber(x) >>> 0; |
|
}, |
|
ToUint16: function ToUint16(value) { |
|
var number = this.ToNumber(value); |
|
if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; } |
|
var posInt = sign(number) * Math.floor(Math.abs(number)); |
|
return mod(posInt, 0x10000); |
|
}, |
|
ToString: function ToString(value) { |
|
return $String(value); |
|
}, |
|
ToObject: function ToObject(value) { |
|
this.CheckObjectCoercible(value); |
|
return $Object(value); |
|
}, |
|
CheckObjectCoercible: function CheckObjectCoercible(value, optMessage) { |
|
/* jshint eqnull:true */ |
|
if (value == null) { |
|
throw new $TypeError(optMessage || 'Cannot call method on ' + value); |
|
} |
|
return value; |
|
}, |
|
IsCallable: IsCallable, |
|
SameValue: function SameValue(x, y) { |
|
if (x === y) { // 0 === -0, but they are not identical. |
|
if (x === 0) { return 1 / x === 1 / y; } |
|
return true; |
|
} |
|
return $isNaN(x) && $isNaN(y); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-8 |
|
Type: function Type(x) { |
|
if (x === null) { |
|
return 'Null'; |
|
} |
|
if (typeof x === 'undefined') { |
|
return 'Undefined'; |
|
} |
|
if (typeof x === 'function' || typeof x === 'object') { |
|
return 'Object'; |
|
} |
|
if (typeof x === 'number') { |
|
return 'Number'; |
|
} |
|
if (typeof x === 'boolean') { |
|
return 'Boolean'; |
|
} |
|
if (typeof x === 'string') { |
|
return 'String'; |
|
} |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-property-descriptor-specification-type |
|
IsPropertyDescriptor: function IsPropertyDescriptor(Desc) { |
|
return isPropertyDescriptor(this, Desc); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-8.10.1 |
|
IsAccessorDescriptor: function IsAccessorDescriptor(Desc) { |
|
if (typeof Desc === 'undefined') { |
|
return false; |
|
} |
|
|
|
assertRecord(this, 'Property Descriptor', 'Desc', Desc); |
|
|
|
if (!has(Desc, '[[Get]]') && !has(Desc, '[[Set]]')) { |
|
return false; |
|
} |
|
|
|
return true; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-8.10.2 |
|
IsDataDescriptor: function IsDataDescriptor(Desc) { |
|
if (typeof Desc === 'undefined') { |
|
return false; |
|
} |
|
|
|
assertRecord(this, 'Property Descriptor', 'Desc', Desc); |
|
|
|
if (!has(Desc, '[[Value]]') && !has(Desc, '[[Writable]]')) { |
|
return false; |
|
} |
|
|
|
return true; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-8.10.3 |
|
IsGenericDescriptor: function IsGenericDescriptor(Desc) { |
|
if (typeof Desc === 'undefined') { |
|
return false; |
|
} |
|
|
|
assertRecord(this, 'Property Descriptor', 'Desc', Desc); |
|
|
|
if (!this.IsAccessorDescriptor(Desc) && !this.IsDataDescriptor(Desc)) { |
|
return true; |
|
} |
|
|
|
return false; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-8.10.4 |
|
FromPropertyDescriptor: function FromPropertyDescriptor(Desc) { |
|
if (typeof Desc === 'undefined') { |
|
return Desc; |
|
} |
|
|
|
assertRecord(this, 'Property Descriptor', 'Desc', Desc); |
|
|
|
if (this.IsDataDescriptor(Desc)) { |
|
return { |
|
value: Desc['[[Value]]'], |
|
writable: !!Desc['[[Writable]]'], |
|
enumerable: !!Desc['[[Enumerable]]'], |
|
configurable: !!Desc['[[Configurable]]'] |
|
}; |
|
} else if (this.IsAccessorDescriptor(Desc)) { |
|
return { |
|
get: Desc['[[Get]]'], |
|
set: Desc['[[Set]]'], |
|
enumerable: !!Desc['[[Enumerable]]'], |
|
configurable: !!Desc['[[Configurable]]'] |
|
}; |
|
} else { |
|
throw new $TypeError('FromPropertyDescriptor must be called with a fully populated Property Descriptor'); |
|
} |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-8.10.5 |
|
ToPropertyDescriptor: function ToPropertyDescriptor(Obj) { |
|
if (this.Type(Obj) !== 'Object') { |
|
throw new $TypeError('ToPropertyDescriptor requires an object'); |
|
} |
|
|
|
var desc = {}; |
|
if (has(Obj, 'enumerable')) { |
|
desc['[[Enumerable]]'] = this.ToBoolean(Obj.enumerable); |
|
} |
|
if (has(Obj, 'configurable')) { |
|
desc['[[Configurable]]'] = this.ToBoolean(Obj.configurable); |
|
} |
|
if (has(Obj, 'value')) { |
|
desc['[[Value]]'] = Obj.value; |
|
} |
|
if (has(Obj, 'writable')) { |
|
desc['[[Writable]]'] = this.ToBoolean(Obj.writable); |
|
} |
|
if (has(Obj, 'get')) { |
|
var getter = Obj.get; |
|
if (typeof getter !== 'undefined' && !this.IsCallable(getter)) { |
|
throw new TypeError('getter must be a function'); |
|
} |
|
desc['[[Get]]'] = getter; |
|
} |
|
if (has(Obj, 'set')) { |
|
var setter = Obj.set; |
|
if (typeof setter !== 'undefined' && !this.IsCallable(setter)) { |
|
throw new $TypeError('setter must be a function'); |
|
} |
|
desc['[[Set]]'] = setter; |
|
} |
|
|
|
if ((has(desc, '[[Get]]') || has(desc, '[[Set]]')) && (has(desc, '[[Value]]') || has(desc, '[[Writable]]'))) { |
|
throw new $TypeError('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute'); |
|
} |
|
return desc; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-11.9.3 |
|
'Abstract Equality Comparison': function AbstractEqualityComparison(x, y) { |
|
var xType = this.Type(x); |
|
var yType = this.Type(y); |
|
if (xType === yType) { |
|
return x === y; // ES6+ specified this shortcut anyways. |
|
} |
|
if (x == null && y == null) { |
|
return true; |
|
} |
|
if (xType === 'Number' && yType === 'String') { |
|
return this['Abstract Equality Comparison'](x, this.ToNumber(y)); |
|
} |
|
if (xType === 'String' && yType === 'Number') { |
|
return this['Abstract Equality Comparison'](this.ToNumber(x), y); |
|
} |
|
if (xType === 'Boolean') { |
|
return this['Abstract Equality Comparison'](this.ToNumber(x), y); |
|
} |
|
if (yType === 'Boolean') { |
|
return this['Abstract Equality Comparison'](x, this.ToNumber(y)); |
|
} |
|
if ((xType === 'String' || xType === 'Number') && yType === 'Object') { |
|
return this['Abstract Equality Comparison'](x, this.ToPrimitive(y)); |
|
} |
|
if (xType === 'Object' && (yType === 'String' || yType === 'Number')) { |
|
return this['Abstract Equality Comparison'](this.ToPrimitive(x), y); |
|
} |
|
return false; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-11.9.6 |
|
'Strict Equality Comparison': function StrictEqualityComparison(x, y) { |
|
var xType = this.Type(x); |
|
var yType = this.Type(y); |
|
if (xType !== yType) { |
|
return false; |
|
} |
|
if (xType === 'Undefined' || xType === 'Null') { |
|
return true; |
|
} |
|
return x === y; // shortcut for steps 4-7 |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-11.8.5 |
|
// eslint-disable-next-line max-statements |
|
'Abstract Relational Comparison': function AbstractRelationalComparison(x, y, LeftFirst) { |
|
if (this.Type(LeftFirst) !== 'Boolean') { |
|
throw new $TypeError('Assertion failed: LeftFirst argument must be a Boolean'); |
|
} |
|
var px; |
|
var py; |
|
if (LeftFirst) { |
|
px = this.ToPrimitive(x, $Number); |
|
py = this.ToPrimitive(y, $Number); |
|
} else { |
|
py = this.ToPrimitive(y, $Number); |
|
px = this.ToPrimitive(x, $Number); |
|
} |
|
var bothStrings = this.Type(px) === 'String' && this.Type(py) === 'String'; |
|
if (!bothStrings) { |
|
var nx = this.ToNumber(px); |
|
var ny = this.ToNumber(py); |
|
if ($isNaN(nx) || $isNaN(ny)) { |
|
return undefined; |
|
} |
|
if ($isFinite(nx) && $isFinite(ny) && nx === ny) { |
|
return false; |
|
} |
|
if (nx === 0 && ny === 0) { |
|
return false; |
|
} |
|
if (nx === Infinity) { |
|
return false; |
|
} |
|
if (ny === Infinity) { |
|
return true; |
|
} |
|
if (ny === -Infinity) { |
|
return false; |
|
} |
|
if (nx === -Infinity) { |
|
return true; |
|
} |
|
return nx < ny; // by now, these are both nonzero, finite, and not equal |
|
} |
|
if (isPrefixOf(py, px)) { |
|
return false; |
|
} |
|
if (isPrefixOf(px, py)) { |
|
return true; |
|
} |
|
return px < py; // both strings, neither a prefix of the other. shortcut for steps c-f |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10 |
|
msFromTime: function msFromTime(t) { |
|
return mod(t, msPerSecond); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10 |
|
SecFromTime: function SecFromTime(t) { |
|
return mod($floor(t / msPerSecond), SecondsPerMinute); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10 |
|
MinFromTime: function MinFromTime(t) { |
|
return mod($floor(t / msPerMinute), MinutesPerHour); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10 |
|
HourFromTime: function HourFromTime(t) { |
|
return mod($floor(t / msPerHour), HoursPerDay); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.2 |
|
Day: function Day(t) { |
|
return $floor(t / msPerDay); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.2 |
|
TimeWithinDay: function TimeWithinDay(t) { |
|
return mod(t, msPerDay); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3 |
|
DayFromYear: function DayFromYear(y) { |
|
return (365 * (y - 1970)) + $floor((y - 1969) / 4) - $floor((y - 1901) / 100) + $floor((y - 1601) / 400); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3 |
|
TimeFromYear: function TimeFromYear(y) { |
|
return msPerDay * this.DayFromYear(y); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3 |
|
YearFromTime: function YearFromTime(t) { |
|
// largest y such that this.TimeFromYear(y) <= t |
|
return $getUTCFullYear(new $Date(t)); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.6 |
|
WeekDay: function WeekDay(t) { |
|
return mod(this.Day(t) + 4, 7); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3 |
|
DaysInYear: function DaysInYear(y) { |
|
if (mod(y, 4) !== 0) { |
|
return 365; |
|
} |
|
if (mod(y, 100) !== 0) { |
|
return 366; |
|
} |
|
if (mod(y, 400) !== 0) { |
|
return 365; |
|
} |
|
return 366; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3 |
|
InLeapYear: function InLeapYear(t) { |
|
var days = this.DaysInYear(this.YearFromTime(t)); |
|
if (days === 365) { |
|
return 0; |
|
} |
|
if (days === 366) { |
|
return 1; |
|
} |
|
throw new $EvalError('Assertion failed: there are not 365 or 366 days in a year, got: ' + days); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.4 |
|
DayWithinYear: function DayWithinYear(t) { |
|
return this.Day(t) - this.DayFromYear(this.YearFromTime(t)); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.4 |
|
MonthFromTime: function MonthFromTime(t) { |
|
var day = this.DayWithinYear(t); |
|
if (0 <= day && day < 31) { |
|
return 0; |
|
} |
|
var leap = this.InLeapYear(t); |
|
if (31 <= day && day < (59 + leap)) { |
|
return 1; |
|
} |
|
if ((59 + leap) <= day && day < (90 + leap)) { |
|
return 2; |
|
} |
|
if ((90 + leap) <= day && day < (120 + leap)) { |
|
return 3; |
|
} |
|
if ((120 + leap) <= day && day < (151 + leap)) { |
|
return 4; |
|
} |
|
if ((151 + leap) <= day && day < (181 + leap)) { |
|
return 5; |
|
} |
|
if ((181 + leap) <= day && day < (212 + leap)) { |
|
return 6; |
|
} |
|
if ((212 + leap) <= day && day < (243 + leap)) { |
|
return 7; |
|
} |
|
if ((243 + leap) <= day && day < (273 + leap)) { |
|
return 8; |
|
} |
|
if ((273 + leap) <= day && day < (304 + leap)) { |
|
return 9; |
|
} |
|
if ((304 + leap) <= day && day < (334 + leap)) { |
|
return 10; |
|
} |
|
if ((334 + leap) <= day && day < (365 + leap)) { |
|
return 11; |
|
} |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.5 |
|
DateFromTime: function DateFromTime(t) { |
|
var m = this.MonthFromTime(t); |
|
var d = this.DayWithinYear(t); |
|
if (m === 0) { |
|
return d + 1; |
|
} |
|
if (m === 1) { |
|
return d - 30; |
|
} |
|
var leap = this.InLeapYear(t); |
|
if (m === 2) { |
|
return d - 58 - leap; |
|
} |
|
if (m === 3) { |
|
return d - 89 - leap; |
|
} |
|
if (m === 4) { |
|
return d - 119 - leap; |
|
} |
|
if (m === 5) { |
|
return d - 150 - leap; |
|
} |
|
if (m === 6) { |
|
return d - 180 - leap; |
|
} |
|
if (m === 7) { |
|
return d - 211 - leap; |
|
} |
|
if (m === 8) { |
|
return d - 242 - leap; |
|
} |
|
if (m === 9) { |
|
return d - 272 - leap; |
|
} |
|
if (m === 10) { |
|
return d - 303 - leap; |
|
} |
|
if (m === 11) { |
|
return d - 333 - leap; |
|
} |
|
throw new $EvalError('Assertion failed: MonthFromTime returned an impossible value: ' + m); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.12 |
|
MakeDay: function MakeDay(year, month, date) { |
|
if (!$isFinite(year) || !$isFinite(month) || !$isFinite(date)) { |
|
return NaN; |
|
} |
|
var y = this.ToInteger(year); |
|
var m = this.ToInteger(month); |
|
var dt = this.ToInteger(date); |
|
var ym = y + $floor(m / 12); |
|
var mn = mod(m, 12); |
|
var t = $DateUTC(ym, mn, 1); |
|
if (this.YearFromTime(t) !== ym || this.MonthFromTime(t) !== mn || this.DateFromTime(t) !== 1) { |
|
return NaN; |
|
} |
|
return this.Day(t) + dt - 1; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.13 |
|
MakeDate: function MakeDate(day, time) { |
|
if (!$isFinite(day) || !$isFinite(time)) { |
|
return NaN; |
|
} |
|
return (day * msPerDay) + time; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.11 |
|
MakeTime: function MakeTime(hour, min, sec, ms) { |
|
if (!$isFinite(hour) || !$isFinite(min) || !$isFinite(sec) || !$isFinite(ms)) { |
|
return NaN; |
|
} |
|
var h = this.ToInteger(hour); |
|
var m = this.ToInteger(min); |
|
var s = this.ToInteger(sec); |
|
var milli = this.ToInteger(ms); |
|
var t = (h * msPerHour) + (m * msPerMinute) + (s * msPerSecond) + milli; |
|
return t; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.14 |
|
TimeClip: function TimeClip(time) { |
|
if (!$isFinite(time) || $abs(time) > 8.64e15) { |
|
return NaN; |
|
} |
|
return $Number(new $Date(this.ToNumber(time))); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-5.2 |
|
modulo: function modulo(x, y) { |
|
return mod(x, y); |
|
} |
|
}; |
|
|
|
module.exports = ES5; |
|
|
|
|
|
/***/ }), |
|
/* 260 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var define = __webpack_require__(55); |
|
var getPolyfill = __webpack_require__(167); |
|
|
|
module.exports = function shimFlat() { |
|
var polyfill = getPolyfill(); |
|
define( |
|
Array.prototype, |
|
{ flat: polyfill }, |
|
{ flat: function () { return Array.prototype.flat !== polyfill; } } |
|
); |
|
return polyfill; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 261 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* WEBPACK VAR INJECTION */(function(global) { |
|
|
|
var define = __webpack_require__(55); |
|
var isSymbol = __webpack_require__(156); |
|
|
|
var globalKey = '__ global cache key __'; |
|
/* istanbul ignore else */ |
|
// eslint-disable-next-line no-restricted-properties |
|
if (typeof Symbol === 'function' && isSymbol(Symbol('foo')) && typeof Symbol['for'] === 'function') { |
|
// eslint-disable-next-line no-restricted-properties |
|
globalKey = Symbol['for'](globalKey); |
|
} |
|
|
|
var trueThunk = function () { |
|
return true; |
|
}; |
|
|
|
var ensureCache = function ensureCache() { |
|
if (!global[globalKey]) { |
|
var properties = {}; |
|
properties[globalKey] = {}; |
|
var predicates = {}; |
|
predicates[globalKey] = trueThunk; |
|
define(global, properties, predicates); |
|
} |
|
return global[globalKey]; |
|
}; |
|
|
|
var cache = ensureCache(); |
|
|
|
var isPrimitive = function isPrimitive(val) { |
|
return val === null || (typeof val !== 'object' && typeof val !== 'function'); |
|
}; |
|
|
|
var getPrimitiveKey = function getPrimitiveKey(val) { |
|
if (isSymbol(val)) { |
|
return Symbol.prototype.valueOf.call(val); |
|
} |
|
return typeof val + ' | ' + String(val); |
|
}; |
|
|
|
var requirePrimitiveKey = function requirePrimitiveKey(val) { |
|
if (!isPrimitive(val)) { |
|
throw new TypeError('key must not be an object'); |
|
} |
|
}; |
|
|
|
var globalCache = { |
|
clear: function clear() { |
|
delete global[globalKey]; |
|
cache = ensureCache(); |
|
}, |
|
|
|
'delete': function deleteKey(key) { |
|
requirePrimitiveKey(key); |
|
delete cache[getPrimitiveKey(key)]; |
|
return !globalCache.has(key); |
|
}, |
|
|
|
get: function get(key) { |
|
requirePrimitiveKey(key); |
|
return cache[getPrimitiveKey(key)]; |
|
}, |
|
|
|
has: function has(key) { |
|
requirePrimitiveKey(key); |
|
return getPrimitiveKey(key) in cache; |
|
}, |
|
|
|
set: function set(key, value) { |
|
requirePrimitiveKey(key); |
|
var primitiveKey = getPrimitiveKey(key); |
|
var props = {}; |
|
props[primitiveKey] = value; |
|
var predicates = {}; |
|
predicates[primitiveKey] = trueThunk; |
|
define(cache, props, predicates); |
|
return globalCache.has(key); |
|
}, |
|
|
|
setIfMissingThenGet: function setIfMissingThenGet(key, valueThunk) { |
|
if (globalCache.has(key)) { |
|
return globalCache.get(key); |
|
} |
|
var item = valueThunk(); |
|
globalCache.set(key, item); |
|
return item; |
|
} |
|
}; |
|
|
|
module.exports = globalCache; |
|
|
|
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(65))) |
|
|
|
/***/ }), |
|
/* 262 */ |
|
/***/ (function(module, exports) { |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
var GLOBAL_CACHE_KEY = 'reactWithStylesInterfaceCSS'; |
|
var MAX_SPECIFICITY = 20; |
|
|
|
exports.GLOBAL_CACHE_KEY = GLOBAL_CACHE_KEY; |
|
exports.MAX_SPECIFICITY = MAX_SPECIFICITY; |
|
|
|
/***/ }), |
|
/* 263 */ |
|
/***/ (function(module, exports) { |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = getClassName; |
|
/** |
|
* Construct a class name. |
|
* |
|
* namespace {String} Used to construct unique class names. |
|
* styleName {String} Name identifying the specific style. |
|
* |
|
* Return the class name. |
|
*/ |
|
function getClassName(namespace, styleName) { |
|
var namespaceSegment = namespace.length > 0 ? String(namespace) + '__' : ''; |
|
return '' + namespaceSegment + String(styleName); |
|
} |
|
|
|
/***/ }), |
|
/* 264 */ |
|
/***/ (function(module, exports) { |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
// This function takes an array of styles and separates them into styles that |
|
// are handled by Aphrodite and inline styles. |
|
function separateStyles(stylesArray) { |
|
var classNames = []; |
|
|
|
// Since determining if an Object is empty requires collecting all of its |
|
// keys, and we want the best performance in this code because we are in the |
|
// render path, we are going to do a little bookkeeping ourselves. |
|
var hasInlineStyles = false; |
|
var inlineStyles = {}; |
|
|
|
// This is run on potentially every node in the tree when rendering, where |
|
// performance is critical. Normally we would prefer using `forEach`, but |
|
// old-fashioned for loops are faster so that's what we have chosen here. |
|
for (var i = 0; i < stylesArray.length; i++) { |
|
// eslint-disable-line no-plusplus |
|
var style = stylesArray[i]; |
|
|
|
// If this style is falsy, we just want to disregard it. This allows for |
|
// syntax like: |
|
// |
|
// css(isFoo && styles.foo) |
|
if (style) { |
|
if (typeof style === 'string') { |
|
classNames.push(style); |
|
} else { |
|
Object.assign(inlineStyles, style); |
|
hasInlineStyles = true; |
|
} |
|
} |
|
} |
|
|
|
return { |
|
classNames: classNames, |
|
hasInlineStyles: hasInlineStyles, |
|
inlineStyles: inlineStyles |
|
}; |
|
} |
|
|
|
exports['default'] = separateStyles; |
|
|
|
/***/ }), |
|
/* 265 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = registerInterfaceWithDefaultTheme; |
|
|
|
var _ThemedStyleSheet = __webpack_require__(168); |
|
|
|
var _ThemedStyleSheet2 = _interopRequireDefault(_ThemedStyleSheet); |
|
|
|
var _DefaultTheme = __webpack_require__(169); |
|
|
|
var _DefaultTheme2 = _interopRequireDefault(_DefaultTheme); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function registerInterfaceWithDefaultTheme(reactWithStylesInterface) { |
|
_ThemedStyleSheet2['default'].registerInterface(reactWithStylesInterface); |
|
_ThemedStyleSheet2['default'].registerTheme(_DefaultTheme2['default']); |
|
} |
|
|
|
/***/ }), |
|
/* 266 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _CalendarDay = __webpack_require__(133); |
|
|
|
Object.defineProperty(exports, 'CalendarDay', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_CalendarDay)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _CalendarMonth = __webpack_require__(173); |
|
|
|
Object.defineProperty(exports, 'CalendarMonth', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_CalendarMonth)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _CalendarMonthGrid = __webpack_require__(175); |
|
|
|
Object.defineProperty(exports, 'CalendarMonthGrid', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_CalendarMonthGrid)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _DateRangePicker = __webpack_require__(285); |
|
|
|
Object.defineProperty(exports, 'DateRangePicker', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_DateRangePicker)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _DateRangePickerInput = __webpack_require__(196); |
|
|
|
Object.defineProperty(exports, 'DateRangePickerInput', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_DateRangePickerInput)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _DateRangePickerInputController = __webpack_require__(195); |
|
|
|
Object.defineProperty(exports, 'DateRangePickerInputController', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_DateRangePickerInputController)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _DateRangePickerShape = __webpack_require__(188); |
|
|
|
Object.defineProperty(exports, 'DateRangePickerShape', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_DateRangePickerShape)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _DayPicker = __webpack_require__(141); |
|
|
|
Object.defineProperty(exports, 'DayPicker', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_DayPicker)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _DayPickerRangeController = __webpack_require__(204); |
|
|
|
Object.defineProperty(exports, 'DayPickerRangeController', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_DayPickerRangeController)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _DayPickerSingleDateController = __webpack_require__(207); |
|
|
|
Object.defineProperty(exports, 'DayPickerSingleDateController', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_DayPickerSingleDateController)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _SingleDatePicker = __webpack_require__(312); |
|
|
|
Object.defineProperty(exports, 'SingleDatePicker', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_SingleDatePicker)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _SingleDatePickerInput = __webpack_require__(209); |
|
|
|
Object.defineProperty(exports, 'SingleDatePickerInput', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_SingleDatePickerInput)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _SingleDatePickerShape = __webpack_require__(208); |
|
|
|
Object.defineProperty(exports, 'SingleDatePickerShape', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_SingleDatePickerShape)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _isInclusivelyAfterDay = __webpack_require__(94); |
|
|
|
Object.defineProperty(exports, 'isInclusivelyAfterDay', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_isInclusivelyAfterDay)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _isInclusivelyBeforeDay = __webpack_require__(313); |
|
|
|
Object.defineProperty(exports, 'isInclusivelyBeforeDay', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_isInclusivelyBeforeDay)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _isNextDay = __webpack_require__(205); |
|
|
|
Object.defineProperty(exports, 'isNextDay', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_isNextDay)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _isSameDay = __webpack_require__(77); |
|
|
|
Object.defineProperty(exports, 'isSameDay', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_isSameDay)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _toISODateString = __webpack_require__(104); |
|
|
|
Object.defineProperty(exports, 'toISODateString', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_toISODateString)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _toLocalizedDateString = __webpack_require__(139); |
|
|
|
Object.defineProperty(exports, 'toLocalizedDateString', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_toLocalizedDateString)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
var _toMomentObject = __webpack_require__(78); |
|
|
|
Object.defineProperty(exports, 'toMomentObject', { |
|
enumerable: true, |
|
get: function () { |
|
function get() { |
|
return _interopRequireDefault(_toMomentObject)['default']; |
|
} |
|
|
|
return get; |
|
}() |
|
}); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
/***/ }), |
|
/* 267 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var define = __webpack_require__(55); |
|
var getPolyfill = __webpack_require__(171); |
|
|
|
module.exports = function shimAssign() { |
|
var polyfill = getPolyfill(); |
|
define( |
|
Object, |
|
{ assign: polyfill }, |
|
{ assign: function () { return Object.assign !== polyfill; } } |
|
); |
|
return polyfill; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 268 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
/** |
|
* Copyright (c) 2013-present, Facebook, Inc. |
|
* |
|
* This source code is licensed under the MIT license found in the |
|
* LICENSE file in the root directory of this source tree. |
|
* |
|
* @typechecks |
|
* |
|
*/ |
|
|
|
/*eslint-disable no-self-compare */ |
|
|
|
|
|
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty; |
|
|
|
/** |
|
* inlined Object.is polyfill to avoid requiring consumers ship their own |
|
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is |
|
*/ |
|
function is(x, y) { |
|
// SameValue algorithm |
|
if (x === y) { |
|
// Steps 1-5, 7-10 |
|
// Steps 6.b-6.e: +0 != -0 |
|
// Added the nonzero y check to make Flow happy, but it is redundant |
|
return x !== 0 || y !== 0 || 1 / x === 1 / y; |
|
} else { |
|
// Step 6.a: NaN == NaN |
|
return x !== x && y !== y; |
|
} |
|
} |
|
|
|
/** |
|
* Performs equality by iterating through keys on an object and returning false |
|
* when any key has values which are not strictly equal between the arguments. |
|
* Returns true when the values of all keys are strictly equal. |
|
*/ |
|
function shallowEqual(objA, objB) { |
|
if (is(objA, objB)) { |
|
return true; |
|
} |
|
|
|
if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) { |
|
return false; |
|
} |
|
|
|
var keysA = Object.keys(objA); |
|
var keysB = Object.keys(objB); |
|
|
|
if (keysA.length !== keysB.length) { |
|
return false; |
|
} |
|
|
|
// Test for A's keys different from B. |
|
for (var i = 0; i < keysA.length; i++) { |
|
if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) { |
|
return false; |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
module.exports = shallowEqual; |
|
|
|
/***/ }), |
|
/* 269 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var moment = __webpack_require__(29); |
|
|
|
function isValidMoment(testMoment) { |
|
if (typeof moment.isMoment === 'function' && !moment.isMoment(testMoment)) { |
|
return false; |
|
} |
|
|
|
/* istanbul ignore else */ |
|
if (typeof testMoment.isValid === 'function') { |
|
// moment 1.7.0+ |
|
return testMoment.isValid(); |
|
} |
|
|
|
/* istanbul ignore next */ |
|
return !isNaN(testMoment); |
|
} |
|
|
|
module.exports = { |
|
isValidMoment : isValidMoment, |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 270 */ |
|
/***/ (function(module, exports) { |
|
|
|
var messages = { |
|
invalidPredicate: '`predicate` must be a function', |
|
invalidPropValidator: '`propValidator` must be a function', |
|
requiredCore: 'is marked as required', |
|
invalidTypeCore: 'Invalid input type', |
|
predicateFailureCore: 'Failed to succeed with predicate', |
|
anonymousMessage: '<<anonymous>>', |
|
baseInvalidMessage: 'Invalid ', |
|
}; |
|
|
|
function constructPropValidatorVariations(propValidator) { |
|
if (typeof propValidator !== 'function') { |
|
throw new Error(messages.invalidPropValidator); |
|
} |
|
|
|
var requiredPropValidator = propValidator.bind(null, false, null); |
|
requiredPropValidator.isRequired = propValidator.bind(null, true, null); |
|
|
|
requiredPropValidator.withPredicate = function predicateApplication(predicate) { |
|
if (typeof predicate !== 'function') { |
|
throw new Error(messages.invalidPredicate); |
|
} |
|
var basePropValidator = propValidator.bind(null, false, predicate); |
|
basePropValidator.isRequired = propValidator.bind(null, true, predicate); |
|
return basePropValidator; |
|
}; |
|
|
|
return requiredPropValidator; |
|
} |
|
|
|
function createInvalidRequiredErrorMessage(propName, componentName, value) { |
|
return new Error( |
|
'The prop `' + propName + '` ' + messages.requiredCore + |
|
' in `' + componentName + '`, but its value is `' + value + '`.' |
|
); |
|
} |
|
|
|
var independentGuardianValue = -1; |
|
|
|
function preValidationRequireCheck(isRequired, componentName, propFullName, propValue) { |
|
var isPropValueUndefined = typeof propValue === 'undefined'; |
|
var isPropValueNull = propValue === null; |
|
|
|
if (isRequired) { |
|
if (isPropValueUndefined) { |
|
return createInvalidRequiredErrorMessage(propFullName, componentName, 'undefined'); |
|
} else if (isPropValueNull) { |
|
return createInvalidRequiredErrorMessage(propFullName, componentName, 'null'); |
|
} |
|
} |
|
|
|
if (isPropValueUndefined || isPropValueNull) { |
|
return null; |
|
} |
|
|
|
return independentGuardianValue; |
|
} |
|
|
|
function createMomentChecker(type, typeValidator, validator, momentType) { |
|
|
|
function propValidator( |
|
isRequired, // Bound parameter to indicate with the propType is required |
|
predicate, // Bound parameter to allow user to add dynamic validation |
|
props, |
|
propName, |
|
componentName, |
|
location, |
|
propFullName |
|
) { |
|
var propValue = props[ propName ]; |
|
var propType = typeof propValue; |
|
|
|
componentName = componentName || messages.anonymousMessage; |
|
propFullName = propFullName || propName; |
|
|
|
var preValidationRequireCheckValue = preValidationRequireCheck( |
|
isRequired, componentName, propFullName, propValue |
|
); |
|
|
|
if (preValidationRequireCheckValue !== independentGuardianValue) { |
|
return preValidationRequireCheckValue; |
|
} |
|
|
|
if (typeValidator && !typeValidator(propValue)) { |
|
return new Error( |
|
messages.invalidTypeCore + ': `' + propName + '` of type `' + propType + '` ' + |
|
'supplied to `' + componentName + '`, expected `' + type + '`.' |
|
); |
|
} |
|
|
|
if (!validator(propValue)) { |
|
return new Error( |
|
messages.baseInvalidMessage + location + ' `' + propName + '` of type `' + propType + '` ' + |
|
'supplied to `' + componentName + '`, expected `' + momentType + '`.' |
|
); |
|
} |
|
|
|
if (predicate && !predicate(propValue)) { |
|
var predicateName = predicate.name || messages.anonymousMessage; |
|
return new Error( |
|
messages.baseInvalidMessage + location + ' `' + propName + '` of type `' + propType + '` ' + |
|
'supplied to `' + componentName + '`. ' + messages.predicateFailureCore + ' `' + |
|
predicateName + '`.' |
|
); |
|
} |
|
|
|
return null; |
|
|
|
} |
|
|
|
return constructPropValidatorVariations(propValidator); |
|
|
|
} |
|
|
|
module.exports = { |
|
constructPropValidatorVariations: constructPropValidatorVariations, |
|
createMomentChecker: createMomentChecker, |
|
messages: messages, |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 271 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
function noop() { |
|
return null; |
|
} |
|
|
|
noop.isRequired = noop; |
|
|
|
function noopThunk() { |
|
return noop; |
|
} |
|
|
|
module.exports = { |
|
and: noopThunk, |
|
between: noopThunk, |
|
booleanSome: noopThunk, |
|
childrenHavePropXorChildren: noopThunk, |
|
childrenOf: noopThunk, |
|
childrenOfType: noopThunk, |
|
childrenSequenceOf: noopThunk, |
|
componentWithName: noopThunk, |
|
disallowedIf: noopThunk, |
|
elementType: noopThunk, |
|
empty: noopThunk, |
|
explicitNull: noopThunk, |
|
forbidExtraProps: Object, |
|
integer: noopThunk, |
|
keysOf: noopThunk, |
|
mutuallyExclusiveProps: noopThunk, |
|
mutuallyExclusiveTrueProps: noopThunk, |
|
nChildren: noopThunk, |
|
nonNegativeInteger: noop, |
|
nonNegativeNumber: noopThunk, |
|
numericString: noopThunk, |
|
object: noopThunk, |
|
or: noopThunk, |
|
range: noopThunk, |
|
ref: noopThunk, |
|
requiredBy: noopThunk, |
|
restrictedProp: noopThunk, |
|
sequenceOf: noopThunk, |
|
shape: noopThunk, |
|
stringEndsWith: noopThunk, |
|
stringStartsWith: noopThunk, |
|
uniqueArray: noopThunk, |
|
uniqueArrayOf: noopThunk, |
|
valuesOf: noopThunk, |
|
withShape: noopThunk |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 272 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
/** |
|
* Copyright 2015, Yahoo! Inc. |
|
* Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms. |
|
*/ |
|
var ReactIs = __webpack_require__(273); |
|
var REACT_STATICS = { |
|
childContextTypes: true, |
|
contextType: true, |
|
contextTypes: true, |
|
defaultProps: true, |
|
displayName: true, |
|
getDefaultProps: true, |
|
getDerivedStateFromError: true, |
|
getDerivedStateFromProps: true, |
|
mixins: true, |
|
propTypes: true, |
|
type: true |
|
}; |
|
|
|
var KNOWN_STATICS = { |
|
name: true, |
|
length: true, |
|
prototype: true, |
|
caller: true, |
|
callee: true, |
|
arguments: true, |
|
arity: true |
|
}; |
|
|
|
var FORWARD_REF_STATICS = { |
|
'$$typeof': true, |
|
render: true, |
|
defaultProps: true, |
|
displayName: true, |
|
propTypes: true |
|
}; |
|
|
|
var MEMO_STATICS = { |
|
'$$typeof': true, |
|
compare: true, |
|
defaultProps: true, |
|
displayName: true, |
|
propTypes: true, |
|
type: true |
|
}; |
|
|
|
var TYPE_STATICS = {}; |
|
TYPE_STATICS[ReactIs.ForwardRef] = FORWARD_REF_STATICS; |
|
|
|
function getStatics(component) { |
|
if (ReactIs.isMemo(component)) { |
|
return MEMO_STATICS; |
|
} |
|
return TYPE_STATICS[component['$$typeof']] || REACT_STATICS; |
|
} |
|
|
|
var defineProperty = Object.defineProperty; |
|
var getOwnPropertyNames = Object.getOwnPropertyNames; |
|
var getOwnPropertySymbols = Object.getOwnPropertySymbols; |
|
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; |
|
var getPrototypeOf = Object.getPrototypeOf; |
|
var objectPrototype = Object.prototype; |
|
|
|
function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) { |
|
if (typeof sourceComponent !== 'string') { |
|
// don't hoist over string (html) components |
|
|
|
if (objectPrototype) { |
|
var inheritedComponent = getPrototypeOf(sourceComponent); |
|
if (inheritedComponent && inheritedComponent !== objectPrototype) { |
|
hoistNonReactStatics(targetComponent, inheritedComponent, blacklist); |
|
} |
|
} |
|
|
|
var keys = getOwnPropertyNames(sourceComponent); |
|
|
|
if (getOwnPropertySymbols) { |
|
keys = keys.concat(getOwnPropertySymbols(sourceComponent)); |
|
} |
|
|
|
var targetStatics = getStatics(targetComponent); |
|
var sourceStatics = getStatics(sourceComponent); |
|
|
|
for (var i = 0; i < keys.length; ++i) { |
|
var key = keys[i]; |
|
if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) { |
|
var descriptor = getOwnPropertyDescriptor(sourceComponent, key); |
|
try { |
|
// Avoid failures from read-only properties |
|
defineProperty(targetComponent, key, descriptor); |
|
} catch (e) {} |
|
} |
|
} |
|
|
|
return targetComponent; |
|
} |
|
|
|
return targetComponent; |
|
} |
|
|
|
module.exports = hoistNonReactStatics; |
|
|
|
|
|
/***/ }), |
|
/* 273 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
if (true) { |
|
module.exports = __webpack_require__(274); |
|
} else {} |
|
|
|
|
|
/***/ }), |
|
/* 274 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
/** @license React v16.8.6 |
|
* react-is.production.min.js |
|
* |
|
* Copyright (c) Facebook, Inc. and its affiliates. |
|
* |
|
* This source code is licensed under the MIT license found in the |
|
* LICENSE file in the root directory of this source tree. |
|
*/ |
|
|
|
Object.defineProperty(exports,"__esModule",{value:!0}); |
|
var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?Symbol.for("react.memo"): |
|
60115,r=b?Symbol.for("react.lazy"):60116;function t(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case h:return a;default:return u}}case r:case q:case d:return u}}}function v(a){return t(a)===m}exports.typeOf=t;exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n; |
|
exports.Fragment=e;exports.Lazy=r;exports.Memo=q;exports.Portal=d;exports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isValidElementType=function(a){return"string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||"object"===typeof a&&null!==a&&(a.$$typeof===r||a.$$typeof===q||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n)};exports.isAsyncMode=function(a){return v(a)||t(a)===l};exports.isConcurrentMode=v;exports.isContextConsumer=function(a){return t(a)===k}; |
|
exports.isContextProvider=function(a){return t(a)===h};exports.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return t(a)===n};exports.isFragment=function(a){return t(a)===e};exports.isLazy=function(a){return t(a)===r};exports.isMemo=function(a){return t(a)===q};exports.isPortal=function(a){return t(a)===d};exports.isProfiler=function(a){return t(a)===g};exports.isStrictMode=function(a){return t(a)===f}; |
|
exports.isSuspense=function(a){return t(a)===p}; |
|
|
|
|
|
/***/ }), |
|
/* 275 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
var CHANNEL = exports.CHANNEL = '__direction__'; |
|
|
|
var DIRECTIONS = exports.DIRECTIONS = { |
|
LTR: 'ltr', |
|
RTL: 'rtl' |
|
}; |
|
|
|
/***/ }), |
|
/* 276 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
exports['default'] = _propTypes2['default'].shape({ |
|
getState: _propTypes2['default'].func, |
|
setState: _propTypes2['default'].func, |
|
subscribe: _propTypes2['default'].func |
|
}); |
|
|
|
/***/ }), |
|
/* 277 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = getPhrase; |
|
function getPhrase(phrase, args) { |
|
if (typeof phrase === 'string') return phrase; |
|
|
|
if (typeof phrase === 'function') { |
|
return phrase(args); |
|
} |
|
|
|
return ''; |
|
} |
|
|
|
/***/ }), |
|
/* 278 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = CalendarWeek; |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _CalendarDay = __webpack_require__(133); |
|
|
|
var _CalendarDay2 = _interopRequireDefault(_CalendarDay); |
|
|
|
var _CustomizableCalendarDay = __webpack_require__(279); |
|
|
|
var _CustomizableCalendarDay2 = _interopRequireDefault(_CustomizableCalendarDay); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)({ |
|
children: (0, _airbnbPropTypes.or)([(0, _airbnbPropTypes.childrenOfType)(_CalendarDay2['default']), (0, _airbnbPropTypes.childrenOfType)(_CustomizableCalendarDay2['default'])]).isRequired |
|
}); |
|
|
|
function CalendarWeek(_ref) { |
|
var children = _ref.children; |
|
|
|
return _react2['default'].createElement( |
|
'tr', |
|
null, |
|
children |
|
); |
|
} |
|
|
|
CalendarWeek.propTypes = propTypes; |
|
|
|
/***/ }), |
|
/* 279 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.PureCustomizableCalendarDay = exports.selectedStyles = exports.lastInRangeStyles = exports.selectedSpanStyles = exports.hoveredSpanStyles = exports.blockedOutOfRangeStyles = exports.blockedCalendarStyles = exports.blockedMinNightsStyles = exports.highlightedCalendarStyles = exports.outsideStyles = exports.defaultStyles = undefined; |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _reactAddonsShallowCompare = __webpack_require__(76); |
|
|
|
var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); |
|
|
|
var _reactMomentProptypes = __webpack_require__(66); |
|
|
|
var _reactMomentProptypes2 = _interopRequireDefault(_reactMomentProptypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _getCalendarDaySettings = __webpack_require__(172); |
|
|
|
var _getCalendarDaySettings2 = _interopRequireDefault(_getCalendarDaySettings); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
var _DefaultTheme = __webpack_require__(169); |
|
|
|
var _DefaultTheme2 = _interopRequireDefault(_DefaultTheme); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
var color = _DefaultTheme2['default'].reactDates.color; |
|
|
|
|
|
function getStyles(stylesObj, isHovered) { |
|
if (!stylesObj) return null; |
|
|
|
var hover = stylesObj.hover; |
|
|
|
if (isHovered && hover) { |
|
return hover; |
|
} |
|
|
|
return stylesObj; |
|
} |
|
|
|
var DayStyleShape = _propTypes2['default'].shape({ |
|
background: _propTypes2['default'].string, |
|
border: (0, _airbnbPropTypes.or)([_propTypes2['default'].string, _propTypes2['default'].number]), |
|
color: _propTypes2['default'].string, |
|
|
|
hover: _propTypes2['default'].shape({ |
|
background: _propTypes2['default'].string, |
|
border: (0, _airbnbPropTypes.or)([_propTypes2['default'].string, _propTypes2['default'].number]), |
|
color: _propTypes2['default'].string |
|
}) |
|
}); |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, { |
|
day: _reactMomentProptypes2['default'].momentObj, |
|
daySize: _airbnbPropTypes.nonNegativeInteger, |
|
isOutsideDay: _propTypes2['default'].bool, |
|
modifiers: _propTypes2['default'].instanceOf(Set), |
|
isFocused: _propTypes2['default'].bool, |
|
tabIndex: _propTypes2['default'].oneOf([0, -1]), |
|
onDayClick: _propTypes2['default'].func, |
|
onDayMouseEnter: _propTypes2['default'].func, |
|
onDayMouseLeave: _propTypes2['default'].func, |
|
renderDayContents: _propTypes2['default'].func, |
|
ariaLabelFormat: _propTypes2['default'].string, |
|
|
|
// style overrides |
|
defaultStyles: DayStyleShape, |
|
outsideStyles: DayStyleShape, |
|
todayStyles: DayStyleShape, |
|
firstDayOfWeekStyles: DayStyleShape, |
|
lastDayOfWeekStyles: DayStyleShape, |
|
highlightedCalendarStyles: DayStyleShape, |
|
blockedMinNightsStyles: DayStyleShape, |
|
blockedCalendarStyles: DayStyleShape, |
|
blockedOutOfRangeStyles: DayStyleShape, |
|
hoveredSpanStyles: DayStyleShape, |
|
selectedSpanStyles: DayStyleShape, |
|
lastInRangeStyles: DayStyleShape, |
|
selectedStyles: DayStyleShape, |
|
selectedStartStyles: DayStyleShape, |
|
selectedEndStyles: DayStyleShape, |
|
afterHoveredStartStyles: DayStyleShape, |
|
|
|
// internationalization |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.CalendarDayPhrases)) |
|
})); |
|
|
|
var defaultStyles = exports.defaultStyles = { |
|
border: '1px solid ' + String(color.core.borderLight), |
|
color: color.text, |
|
background: color.background, |
|
|
|
hover: { |
|
background: color.core.borderLight, |
|
border: '1px double ' + String(color.core.borderLight), |
|
color: 'inherit' |
|
} |
|
}; |
|
|
|
var outsideStyles = exports.outsideStyles = { |
|
background: color.outside.backgroundColor, |
|
border: 0, |
|
color: color.outside.color |
|
}; |
|
|
|
var highlightedCalendarStyles = exports.highlightedCalendarStyles = { |
|
background: color.highlighted.backgroundColor, |
|
color: color.highlighted.color, |
|
|
|
hover: { |
|
background: color.highlighted.backgroundColor_hover, |
|
color: color.highlighted.color_active |
|
} |
|
}; |
|
|
|
var blockedMinNightsStyles = exports.blockedMinNightsStyles = { |
|
background: color.minimumNights.backgroundColor, |
|
border: '1px solid ' + String(color.minimumNights.borderColor), |
|
color: color.minimumNights.color, |
|
|
|
hover: { |
|
background: color.minimumNights.backgroundColor_hover, |
|
color: color.minimumNights.color_active |
|
} |
|
}; |
|
|
|
var blockedCalendarStyles = exports.blockedCalendarStyles = { |
|
background: color.blocked_calendar.backgroundColor, |
|
border: '1px solid ' + String(color.blocked_calendar.borderColor), |
|
color: color.blocked_calendar.color, |
|
|
|
hover: { |
|
background: color.blocked_calendar.backgroundColor_hover, |
|
border: '1px solid ' + String(color.blocked_calendar.borderColor), |
|
color: color.blocked_calendar.color_active |
|
} |
|
}; |
|
|
|
var blockedOutOfRangeStyles = exports.blockedOutOfRangeStyles = { |
|
background: color.blocked_out_of_range.backgroundColor, |
|
border: '1px solid ' + String(color.blocked_out_of_range.borderColor), |
|
color: color.blocked_out_of_range.color, |
|
|
|
hover: { |
|
background: color.blocked_out_of_range.backgroundColor_hover, |
|
border: '1px solid ' + String(color.blocked_out_of_range.borderColor), |
|
color: color.blocked_out_of_range.color_active |
|
} |
|
}; |
|
|
|
var hoveredSpanStyles = exports.hoveredSpanStyles = { |
|
background: color.hoveredSpan.backgroundColor, |
|
border: '1px solid ' + String(color.hoveredSpan.borderColor), |
|
color: color.hoveredSpan.color, |
|
|
|
hover: { |
|
background: color.hoveredSpan.backgroundColor_hover, |
|
border: '1px solid ' + String(color.hoveredSpan.borderColor), |
|
color: color.hoveredSpan.color_active |
|
} |
|
}; |
|
|
|
var selectedSpanStyles = exports.selectedSpanStyles = { |
|
background: color.selectedSpan.backgroundColor, |
|
border: '1px solid ' + String(color.selectedSpan.borderColor), |
|
color: color.selectedSpan.color, |
|
|
|
hover: { |
|
background: color.selectedSpan.backgroundColor_hover, |
|
border: '1px solid ' + String(color.selectedSpan.borderColor), |
|
color: color.selectedSpan.color_active |
|
} |
|
}; |
|
|
|
var lastInRangeStyles = exports.lastInRangeStyles = { |
|
borderRight: color.core.primary |
|
}; |
|
|
|
var selectedStyles = exports.selectedStyles = { |
|
background: color.selected.backgroundColor, |
|
border: '1px solid ' + String(color.selected.borderColor), |
|
color: color.selected.color, |
|
|
|
hover: { |
|
background: color.selected.backgroundColor_hover, |
|
border: '1px solid ' + String(color.selected.borderColor), |
|
color: color.selected.color_active |
|
} |
|
}; |
|
|
|
var defaultProps = { |
|
day: (0, _moment2['default'])(), |
|
daySize: _constants.DAY_SIZE, |
|
isOutsideDay: false, |
|
modifiers: new Set(), |
|
isFocused: false, |
|
tabIndex: -1, |
|
onDayClick: function () { |
|
function onDayClick() {} |
|
|
|
return onDayClick; |
|
}(), |
|
onDayMouseEnter: function () { |
|
function onDayMouseEnter() {} |
|
|
|
return onDayMouseEnter; |
|
}(), |
|
onDayMouseLeave: function () { |
|
function onDayMouseLeave() {} |
|
|
|
return onDayMouseLeave; |
|
}(), |
|
|
|
renderDayContents: null, |
|
ariaLabelFormat: 'dddd, LL', |
|
|
|
// style defaults |
|
defaultStyles: defaultStyles, |
|
outsideStyles: outsideStyles, |
|
todayStyles: {}, |
|
highlightedCalendarStyles: highlightedCalendarStyles, |
|
blockedMinNightsStyles: blockedMinNightsStyles, |
|
blockedCalendarStyles: blockedCalendarStyles, |
|
blockedOutOfRangeStyles: blockedOutOfRangeStyles, |
|
hoveredSpanStyles: hoveredSpanStyles, |
|
selectedSpanStyles: selectedSpanStyles, |
|
lastInRangeStyles: lastInRangeStyles, |
|
selectedStyles: selectedStyles, |
|
selectedStartStyles: {}, |
|
selectedEndStyles: {}, |
|
afterHoveredStartStyles: {}, |
|
firstDayOfWeekStyles: {}, |
|
lastDayOfWeekStyles: {}, |
|
|
|
// internationalization |
|
phrases: _defaultPhrases.CalendarDayPhrases |
|
}; |
|
|
|
var CustomizableCalendarDay = function (_React$Component) { |
|
_inherits(CustomizableCalendarDay, _React$Component); |
|
|
|
function CustomizableCalendarDay() { |
|
var _ref; |
|
|
|
_classCallCheck(this, CustomizableCalendarDay); |
|
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { |
|
args[_key] = arguments[_key]; |
|
} |
|
|
|
var _this = _possibleConstructorReturn(this, (_ref = CustomizableCalendarDay.__proto__ || Object.getPrototypeOf(CustomizableCalendarDay)).call.apply(_ref, [this].concat(args))); |
|
|
|
_this.state = { |
|
isHovered: false |
|
}; |
|
|
|
_this.setButtonRef = _this.setButtonRef.bind(_this); |
|
return _this; |
|
} |
|
|
|
_createClass(CustomizableCalendarDay, [{ |
|
key: 'shouldComponentUpdate', |
|
value: function () { |
|
function shouldComponentUpdate(nextProps, nextState) { |
|
return (0, _reactAddonsShallowCompare2['default'])(this, nextProps, nextState); |
|
} |
|
|
|
return shouldComponentUpdate; |
|
}() |
|
}, { |
|
key: 'componentDidUpdate', |
|
value: function () { |
|
function componentDidUpdate(prevProps) { |
|
var _props = this.props, |
|
isFocused = _props.isFocused, |
|
tabIndex = _props.tabIndex; |
|
|
|
if (tabIndex === 0) { |
|
if (isFocused || tabIndex !== prevProps.tabIndex) { |
|
this.buttonRef.focus(); |
|
} |
|
} |
|
} |
|
|
|
return componentDidUpdate; |
|
}() |
|
}, { |
|
key: 'onDayClick', |
|
value: function () { |
|
function onDayClick(day, e) { |
|
var onDayClick = this.props.onDayClick; |
|
|
|
onDayClick(day, e); |
|
} |
|
|
|
return onDayClick; |
|
}() |
|
}, { |
|
key: 'onDayMouseEnter', |
|
value: function () { |
|
function onDayMouseEnter(day, e) { |
|
var onDayMouseEnter = this.props.onDayMouseEnter; |
|
|
|
this.setState({ isHovered: true }); |
|
onDayMouseEnter(day, e); |
|
} |
|
|
|
return onDayMouseEnter; |
|
}() |
|
}, { |
|
key: 'onDayMouseLeave', |
|
value: function () { |
|
function onDayMouseLeave(day, e) { |
|
var onDayMouseLeave = this.props.onDayMouseLeave; |
|
|
|
this.setState({ isHovered: false }); |
|
onDayMouseLeave(day, e); |
|
} |
|
|
|
return onDayMouseLeave; |
|
}() |
|
}, { |
|
key: 'onKeyDown', |
|
value: function () { |
|
function onKeyDown(day, e) { |
|
var onDayClick = this.props.onDayClick; |
|
var key = e.key; |
|
|
|
if (key === 'Enter' || key === ' ') { |
|
onDayClick(day, e); |
|
} |
|
} |
|
|
|
return onKeyDown; |
|
}() |
|
}, { |
|
key: 'setButtonRef', |
|
value: function () { |
|
function setButtonRef(ref) { |
|
this.buttonRef = ref; |
|
} |
|
|
|
return setButtonRef; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _this2 = this; |
|
|
|
var _props2 = this.props, |
|
day = _props2.day, |
|
ariaLabelFormat = _props2.ariaLabelFormat, |
|
daySize = _props2.daySize, |
|
isOutsideDay = _props2.isOutsideDay, |
|
modifiers = _props2.modifiers, |
|
tabIndex = _props2.tabIndex, |
|
renderDayContents = _props2.renderDayContents, |
|
styles = _props2.styles, |
|
phrases = _props2.phrases, |
|
defaultStylesWithHover = _props2.defaultStyles, |
|
outsideStylesWithHover = _props2.outsideStyles, |
|
todayStylesWithHover = _props2.todayStyles, |
|
firstDayOfWeekStylesWithHover = _props2.firstDayOfWeekStyles, |
|
lastDayOfWeekStylesWithHover = _props2.lastDayOfWeekStyles, |
|
highlightedCalendarStylesWithHover = _props2.highlightedCalendarStyles, |
|
blockedMinNightsStylesWithHover = _props2.blockedMinNightsStyles, |
|
blockedCalendarStylesWithHover = _props2.blockedCalendarStyles, |
|
blockedOutOfRangeStylesWithHover = _props2.blockedOutOfRangeStyles, |
|
hoveredSpanStylesWithHover = _props2.hoveredSpanStyles, |
|
selectedSpanStylesWithHover = _props2.selectedSpanStyles, |
|
lastInRangeStylesWithHover = _props2.lastInRangeStyles, |
|
selectedStylesWithHover = _props2.selectedStyles, |
|
selectedStartStylesWithHover = _props2.selectedStartStyles, |
|
selectedEndStylesWithHover = _props2.selectedEndStyles, |
|
afterHoveredStartStylesWithHover = _props2.afterHoveredStartStyles; |
|
var isHovered = this.state.isHovered; |
|
|
|
|
|
if (!day) return _react2['default'].createElement('td', null); |
|
|
|
var _getCalendarDaySettin = (0, _getCalendarDaySettings2['default'])(day, ariaLabelFormat, daySize, modifiers, phrases), |
|
daySizeStyles = _getCalendarDaySettin.daySizeStyles, |
|
useDefaultCursor = _getCalendarDaySettin.useDefaultCursor, |
|
selected = _getCalendarDaySettin.selected, |
|
hoveredSpan = _getCalendarDaySettin.hoveredSpan, |
|
isOutsideRange = _getCalendarDaySettin.isOutsideRange, |
|
ariaLabel = _getCalendarDaySettin.ariaLabel; |
|
|
|
return _react2['default'].createElement( |
|
'td', |
|
_extends({}, (0, _reactWithStyles.css)(styles.CalendarDay, useDefaultCursor && styles.CalendarDay__defaultCursor, daySizeStyles, getStyles(defaultStylesWithHover, isHovered), isOutsideDay && getStyles(outsideStylesWithHover, isHovered), modifiers.has('today') && getStyles(todayStylesWithHover, isHovered), modifiers.has('first-day-of-week') && getStyles(firstDayOfWeekStylesWithHover, isHovered), modifiers.has('last-day-of-week') && getStyles(lastDayOfWeekStylesWithHover, isHovered), modifiers.has('highlighted-calendar') && getStyles(highlightedCalendarStylesWithHover, isHovered), modifiers.has('blocked-minimum-nights') && getStyles(blockedMinNightsStylesWithHover, isHovered), modifiers.has('blocked-calendar') && getStyles(blockedCalendarStylesWithHover, isHovered), hoveredSpan && getStyles(hoveredSpanStylesWithHover, isHovered), modifiers.has('after-hovered-start') && getStyles(afterHoveredStartStylesWithHover, isHovered), modifiers.has('selected-span') && getStyles(selectedSpanStylesWithHover, isHovered), modifiers.has('last-in-range') && getStyles(lastInRangeStylesWithHover, isHovered), selected && getStyles(selectedStylesWithHover, isHovered), modifiers.has('selected-start') && getStyles(selectedStartStylesWithHover, isHovered), modifiers.has('selected-end') && getStyles(selectedEndStylesWithHover, isHovered), isOutsideRange && getStyles(blockedOutOfRangeStylesWithHover, isHovered)), { |
|
role: 'button' // eslint-disable-line jsx-a11y/no-noninteractive-element-to-interactive-role |
|
, ref: this.setButtonRef, |
|
'aria-label': ariaLabel, |
|
onMouseEnter: function () { |
|
function onMouseEnter(e) { |
|
_this2.onDayMouseEnter(day, e); |
|
} |
|
|
|
return onMouseEnter; |
|
}(), |
|
onMouseLeave: function () { |
|
function onMouseLeave(e) { |
|
_this2.onDayMouseLeave(day, e); |
|
} |
|
|
|
return onMouseLeave; |
|
}(), |
|
onMouseUp: function () { |
|
function onMouseUp(e) { |
|
e.currentTarget.blur(); |
|
} |
|
|
|
return onMouseUp; |
|
}(), |
|
onClick: function () { |
|
function onClick(e) { |
|
_this2.onDayClick(day, e); |
|
} |
|
|
|
return onClick; |
|
}(), |
|
onKeyDown: function () { |
|
function onKeyDown(e) { |
|
_this2.onKeyDown(day, e); |
|
} |
|
|
|
return onKeyDown; |
|
}(), |
|
tabIndex: tabIndex |
|
}), |
|
renderDayContents ? renderDayContents(day, modifiers) : day.format('D') |
|
); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return CustomizableCalendarDay; |
|
}(_react2['default'].Component); |
|
|
|
CustomizableCalendarDay.propTypes = propTypes; |
|
CustomizableCalendarDay.defaultProps = defaultProps; |
|
|
|
exports.PureCustomizableCalendarDay = CustomizableCalendarDay; |
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref2) { |
|
var font = _ref2.reactDates.font; |
|
return { |
|
CalendarDay: { |
|
boxSizing: 'border-box', |
|
cursor: 'pointer', |
|
fontSize: font.size, |
|
textAlign: 'center', |
|
|
|
':active': { |
|
outline: 0 |
|
} |
|
}, |
|
|
|
CalendarDay__defaultCursor: { |
|
cursor: 'default' |
|
} |
|
}; |
|
})(CustomizableCalendarDay); |
|
|
|
/***/ }), |
|
/* 280 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = getCalendarMonthWeeks; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function getCalendarMonthWeeks(month, enableOutsideDays) { |
|
var firstDayOfWeek = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _moment2['default'].localeData().firstDayOfWeek(); |
|
|
|
if (!_moment2['default'].isMoment(month) || !month.isValid()) { |
|
throw new TypeError('`month` must be a valid moment object'); |
|
} |
|
if (_constants.WEEKDAYS.indexOf(firstDayOfWeek) === -1) { |
|
throw new TypeError('`firstDayOfWeek` must be an integer between 0 and 6'); |
|
} |
|
|
|
// set utc offset to get correct dates in future (when timezone changes) |
|
var firstOfMonth = month.clone().startOf('month').hour(12); |
|
var lastOfMonth = month.clone().endOf('month').hour(12); |
|
|
|
// calculate the exact first and last days to fill the entire matrix |
|
// (considering days outside month) |
|
var prevDays = (firstOfMonth.day() + 7 - firstDayOfWeek) % 7; |
|
var nextDays = (firstDayOfWeek + 6 - lastOfMonth.day()) % 7; |
|
var firstDay = firstOfMonth.clone().subtract(prevDays, 'day'); |
|
var lastDay = lastOfMonth.clone().add(nextDays, 'day'); |
|
|
|
var totalDays = lastDay.diff(firstDay, 'days') + 1; |
|
|
|
var currentDay = firstDay.clone(); |
|
var weeksInMonth = []; |
|
|
|
for (var i = 0; i < totalDays; i += 1) { |
|
if (i % 7 === 0) { |
|
weeksInMonth.push([]); |
|
} |
|
|
|
var day = null; |
|
if (i >= prevDays && i < totalDays - nextDays || enableOutsideDays) { |
|
day = currentDay.clone(); |
|
} |
|
|
|
weeksInMonth[weeksInMonth.length - 1].push(day); |
|
|
|
currentDay.add(1, 'day'); |
|
} |
|
|
|
return weeksInMonth; |
|
} |
|
|
|
/***/ }), |
|
/* 281 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = isTransitionEndSupported; |
|
function isTransitionEndSupported() { |
|
return !!(typeof window !== 'undefined' && 'TransitionEvent' in window); |
|
} |
|
|
|
/***/ }), |
|
/* 282 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports["default"] = getTransformStyles; |
|
function getTransformStyles(transformValue) { |
|
return { |
|
transform: transformValue, |
|
msTransform: transformValue, |
|
MozTransform: transformValue, |
|
WebkitTransform: transformValue |
|
}; |
|
} |
|
|
|
/***/ }), |
|
/* 283 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = isPrevMonth; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _isSameMonth = __webpack_require__(177); |
|
|
|
var _isSameMonth2 = _interopRequireDefault(_isSameMonth); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function isPrevMonth(a, b) { |
|
if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false; |
|
return (0, _isSameMonth2['default'])(a.clone().subtract(1, 'month'), b); |
|
} |
|
|
|
/***/ }), |
|
/* 284 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = isNextMonth; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _isSameMonth = __webpack_require__(177); |
|
|
|
var _isSameMonth2 = _interopRequireDefault(_isSameMonth); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function isNextMonth(a, b) { |
|
if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false; |
|
return (0, _isSameMonth2['default'])(a.clone().add(1, 'month'), b); |
|
} |
|
|
|
/***/ }), |
|
/* 285 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.PureDateRangePicker = undefined; |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _reactAddonsShallowCompare = __webpack_require__(76); |
|
|
|
var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
var _reactPortal = __webpack_require__(216); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _consolidatedEvents = __webpack_require__(105); |
|
|
|
var _isTouchDevice = __webpack_require__(80); |
|
|
|
var _isTouchDevice2 = _interopRequireDefault(_isTouchDevice); |
|
|
|
var _reactOutsideClickHandler = __webpack_require__(134); |
|
|
|
var _reactOutsideClickHandler2 = _interopRequireDefault(_reactOutsideClickHandler); |
|
|
|
var _DateRangePickerShape = __webpack_require__(188); |
|
|
|
var _DateRangePickerShape2 = _interopRequireDefault(_DateRangePickerShape); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getResponsiveContainerStyles = __webpack_require__(192); |
|
|
|
var _getResponsiveContainerStyles2 = _interopRequireDefault(_getResponsiveContainerStyles); |
|
|
|
var _getDetachedContainerStyles = __webpack_require__(193); |
|
|
|
var _getDetachedContainerStyles2 = _interopRequireDefault(_getDetachedContainerStyles); |
|
|
|
var _getInputHeight = __webpack_require__(137); |
|
|
|
var _getInputHeight2 = _interopRequireDefault(_getInputHeight); |
|
|
|
var _isInclusivelyAfterDay = __webpack_require__(94); |
|
|
|
var _isInclusivelyAfterDay2 = _interopRequireDefault(_isInclusivelyAfterDay); |
|
|
|
var _disableScroll2 = __webpack_require__(194); |
|
|
|
var _disableScroll3 = _interopRequireDefault(_disableScroll2); |
|
|
|
var _DateRangePickerInputController = __webpack_require__(195); |
|
|
|
var _DateRangePickerInputController2 = _interopRequireDefault(_DateRangePickerInputController); |
|
|
|
var _DayPickerRangeController = __webpack_require__(204); |
|
|
|
var _DayPickerRangeController2 = _interopRequireDefault(_DayPickerRangeController); |
|
|
|
var _CloseButton = __webpack_require__(96); |
|
|
|
var _CloseButton2 = _interopRequireDefault(_CloseButton); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, _DateRangePickerShape2['default'])); |
|
|
|
var defaultProps = { |
|
// required props for a functional interactive DateRangePicker |
|
startDate: null, |
|
endDate: null, |
|
focusedInput: null, |
|
|
|
// input related props |
|
startDatePlaceholderText: 'Start Date', |
|
endDatePlaceholderText: 'End Date', |
|
disabled: false, |
|
required: false, |
|
readOnly: false, |
|
screenReaderInputMessage: '', |
|
showClearDates: false, |
|
showDefaultInputIcon: false, |
|
inputIconPosition: _constants.ICON_BEFORE_POSITION, |
|
customInputIcon: null, |
|
customArrowIcon: null, |
|
customCloseIcon: null, |
|
noBorder: false, |
|
block: false, |
|
small: false, |
|
regular: false, |
|
keepFocusOnInput: false, |
|
|
|
// calendar presentation and interaction related props |
|
renderMonthText: null, |
|
orientation: _constants.HORIZONTAL_ORIENTATION, |
|
anchorDirection: _constants.ANCHOR_LEFT, |
|
openDirection: _constants.OPEN_DOWN, |
|
horizontalMargin: 0, |
|
withPortal: false, |
|
withFullScreenPortal: false, |
|
appendToBody: false, |
|
disableScroll: false, |
|
initialVisibleMonth: null, |
|
numberOfMonths: 2, |
|
keepOpenOnDateSelect: false, |
|
reopenPickerOnClearDates: false, |
|
renderCalendarInfo: null, |
|
calendarInfoPosition: _constants.INFO_POSITION_BOTTOM, |
|
hideKeyboardShortcutsPanel: false, |
|
daySize: _constants.DAY_SIZE, |
|
isRTL: false, |
|
firstDayOfWeek: null, |
|
verticalHeight: null, |
|
transitionDuration: undefined, |
|
verticalSpacing: _constants.DEFAULT_VERTICAL_SPACING, |
|
|
|
// navigation related props |
|
navPrev: null, |
|
navNext: null, |
|
|
|
onPrevMonthClick: function () { |
|
function onPrevMonthClick() {} |
|
|
|
return onPrevMonthClick; |
|
}(), |
|
onNextMonthClick: function () { |
|
function onNextMonthClick() {} |
|
|
|
return onNextMonthClick; |
|
}(), |
|
onClose: function () { |
|
function onClose() {} |
|
|
|
return onClose; |
|
}(), |
|
|
|
|
|
// day presentation and interaction related props |
|
renderCalendarDay: undefined, |
|
renderDayContents: null, |
|
renderMonthElement: null, |
|
minimumNights: 1, |
|
enableOutsideDays: false, |
|
isDayBlocked: function () { |
|
function isDayBlocked() { |
|
return false; |
|
} |
|
|
|
return isDayBlocked; |
|
}(), |
|
isOutsideRange: function () { |
|
function isOutsideRange(day) { |
|
return !(0, _isInclusivelyAfterDay2['default'])(day, (0, _moment2['default'])()); |
|
} |
|
|
|
return isOutsideRange; |
|
}(), |
|
isDayHighlighted: function () { |
|
function isDayHighlighted() { |
|
return false; |
|
} |
|
|
|
return isDayHighlighted; |
|
}(), |
|
|
|
// internationalization |
|
displayFormat: function () { |
|
function displayFormat() { |
|
return _moment2['default'].localeData().longDateFormat('L'); |
|
} |
|
|
|
return displayFormat; |
|
}(), |
|
monthFormat: 'MMMM YYYY', |
|
weekDayFormat: 'dd', |
|
phrases: _defaultPhrases.DateRangePickerPhrases, |
|
dayAriaLabelFormat: undefined |
|
}; |
|
|
|
var DateRangePicker = function (_React$Component) { |
|
_inherits(DateRangePicker, _React$Component); |
|
|
|
function DateRangePicker(props) { |
|
_classCallCheck(this, DateRangePicker); |
|
|
|
var _this = _possibleConstructorReturn(this, (DateRangePicker.__proto__ || Object.getPrototypeOf(DateRangePicker)).call(this, props)); |
|
|
|
_this.state = { |
|
dayPickerContainerStyles: {}, |
|
isDateRangePickerInputFocused: false, |
|
isDayPickerFocused: false, |
|
showKeyboardShortcuts: false |
|
}; |
|
|
|
_this.isTouchDevice = false; |
|
|
|
_this.onOutsideClick = _this.onOutsideClick.bind(_this); |
|
_this.onDateRangePickerInputFocus = _this.onDateRangePickerInputFocus.bind(_this); |
|
_this.onDayPickerFocus = _this.onDayPickerFocus.bind(_this); |
|
_this.onDayPickerBlur = _this.onDayPickerBlur.bind(_this); |
|
_this.showKeyboardShortcutsPanel = _this.showKeyboardShortcutsPanel.bind(_this); |
|
|
|
_this.responsivizePickerPosition = _this.responsivizePickerPosition.bind(_this); |
|
_this.disableScroll = _this.disableScroll.bind(_this); |
|
|
|
_this.setDayPickerContainerRef = _this.setDayPickerContainerRef.bind(_this); |
|
_this.setContainerRef = _this.setContainerRef.bind(_this); |
|
return _this; |
|
} |
|
|
|
_createClass(DateRangePicker, [{ |
|
key: 'componentDidMount', |
|
value: function () { |
|
function componentDidMount() { |
|
this.removeEventListener = (0, _consolidatedEvents.addEventListener)(window, 'resize', this.responsivizePickerPosition, { passive: true }); |
|
this.responsivizePickerPosition(); |
|
this.disableScroll(); |
|
|
|
var focusedInput = this.props.focusedInput; |
|
|
|
if (focusedInput) { |
|
this.setState({ |
|
isDateRangePickerInputFocused: true |
|
}); |
|
} |
|
|
|
this.isTouchDevice = (0, _isTouchDevice2['default'])(); |
|
} |
|
|
|
return componentDidMount; |
|
}() |
|
}, { |
|
key: 'shouldComponentUpdate', |
|
value: function () { |
|
function shouldComponentUpdate(nextProps, nextState) { |
|
return (0, _reactAddonsShallowCompare2['default'])(this, nextProps, nextState); |
|
} |
|
|
|
return shouldComponentUpdate; |
|
}() |
|
}, { |
|
key: 'componentDidUpdate', |
|
value: function () { |
|
function componentDidUpdate(prevProps) { |
|
var focusedInput = this.props.focusedInput; |
|
|
|
if (!prevProps.focusedInput && focusedInput && this.isOpened()) { |
|
// The date picker just changed from being closed to being open. |
|
this.responsivizePickerPosition(); |
|
this.disableScroll(); |
|
} else if (prevProps.focusedInput && !focusedInput && !this.isOpened()) { |
|
// The date picker just changed from being open to being closed. |
|
if (this.enableScroll) this.enableScroll(); |
|
} |
|
} |
|
|
|
return componentDidUpdate; |
|
}() |
|
}, { |
|
key: 'componentWillUnmount', |
|
value: function () { |
|
function componentWillUnmount() { |
|
if (this.removeEventListener) this.removeEventListener(); |
|
if (this.enableScroll) this.enableScroll(); |
|
} |
|
|
|
return componentWillUnmount; |
|
}() |
|
}, { |
|
key: 'onOutsideClick', |
|
value: function () { |
|
function onOutsideClick(event) { |
|
var _props = this.props, |
|
onFocusChange = _props.onFocusChange, |
|
onClose = _props.onClose, |
|
startDate = _props.startDate, |
|
endDate = _props.endDate, |
|
appendToBody = _props.appendToBody; |
|
|
|
if (!this.isOpened()) return; |
|
if (appendToBody && this.dayPickerContainer.contains(event.target)) return; |
|
|
|
this.setState({ |
|
isDateRangePickerInputFocused: false, |
|
isDayPickerFocused: false, |
|
showKeyboardShortcuts: false |
|
}); |
|
|
|
onFocusChange(null); |
|
onClose({ startDate: startDate, endDate: endDate }); |
|
} |
|
|
|
return onOutsideClick; |
|
}() |
|
}, { |
|
key: 'onDateRangePickerInputFocus', |
|
value: function () { |
|
function onDateRangePickerInputFocus(focusedInput) { |
|
var _props2 = this.props, |
|
onFocusChange = _props2.onFocusChange, |
|
readOnly = _props2.readOnly, |
|
withPortal = _props2.withPortal, |
|
withFullScreenPortal = _props2.withFullScreenPortal, |
|
keepFocusOnInput = _props2.keepFocusOnInput; |
|
|
|
|
|
if (focusedInput) { |
|
var withAnyPortal = withPortal || withFullScreenPortal; |
|
var moveFocusToDayPicker = withAnyPortal || readOnly && !keepFocusOnInput || this.isTouchDevice && !keepFocusOnInput; |
|
|
|
if (moveFocusToDayPicker) { |
|
this.onDayPickerFocus(); |
|
} else { |
|
this.onDayPickerBlur(); |
|
} |
|
} |
|
|
|
onFocusChange(focusedInput); |
|
} |
|
|
|
return onDateRangePickerInputFocus; |
|
}() |
|
}, { |
|
key: 'onDayPickerFocus', |
|
value: function () { |
|
function onDayPickerFocus() { |
|
var _props3 = this.props, |
|
focusedInput = _props3.focusedInput, |
|
onFocusChange = _props3.onFocusChange; |
|
|
|
if (!focusedInput) onFocusChange(_constants.START_DATE); |
|
|
|
this.setState({ |
|
isDateRangePickerInputFocused: false, |
|
isDayPickerFocused: true, |
|
showKeyboardShortcuts: false |
|
}); |
|
} |
|
|
|
return onDayPickerFocus; |
|
}() |
|
}, { |
|
key: 'onDayPickerBlur', |
|
value: function () { |
|
function onDayPickerBlur() { |
|
this.setState({ |
|
isDateRangePickerInputFocused: true, |
|
isDayPickerFocused: false, |
|
showKeyboardShortcuts: false |
|
}); |
|
} |
|
|
|
return onDayPickerBlur; |
|
}() |
|
}, { |
|
key: 'setDayPickerContainerRef', |
|
value: function () { |
|
function setDayPickerContainerRef(ref) { |
|
this.dayPickerContainer = ref; |
|
} |
|
|
|
return setDayPickerContainerRef; |
|
}() |
|
}, { |
|
key: 'setContainerRef', |
|
value: function () { |
|
function setContainerRef(ref) { |
|
this.container = ref; |
|
} |
|
|
|
return setContainerRef; |
|
}() |
|
}, { |
|
key: 'isOpened', |
|
value: function () { |
|
function isOpened() { |
|
var focusedInput = this.props.focusedInput; |
|
|
|
return focusedInput === _constants.START_DATE || focusedInput === _constants.END_DATE; |
|
} |
|
|
|
return isOpened; |
|
}() |
|
}, { |
|
key: 'disableScroll', |
|
value: function () { |
|
function disableScroll() { |
|
var _props4 = this.props, |
|
appendToBody = _props4.appendToBody, |
|
propDisableScroll = _props4.disableScroll; |
|
|
|
if (!appendToBody && !propDisableScroll) return; |
|
if (!this.isOpened()) return; |
|
|
|
// Disable scroll for every ancestor of this DateRangePicker up to the |
|
// document level. This ensures the input and the picker never move. Other |
|
// sibling elements or the picker itself can scroll. |
|
this.enableScroll = (0, _disableScroll3['default'])(this.container); |
|
} |
|
|
|
return disableScroll; |
|
}() |
|
}, { |
|
key: 'responsivizePickerPosition', |
|
value: function () { |
|
function responsivizePickerPosition() { |
|
// It's possible the portal props have been changed in response to window resizes |
|
// So let's ensure we reset this back to the base state each time |
|
this.setState({ dayPickerContainerStyles: {} }); |
|
|
|
if (!this.isOpened()) { |
|
return; |
|
} |
|
|
|
var _props5 = this.props, |
|
openDirection = _props5.openDirection, |
|
anchorDirection = _props5.anchorDirection, |
|
horizontalMargin = _props5.horizontalMargin, |
|
withPortal = _props5.withPortal, |
|
withFullScreenPortal = _props5.withFullScreenPortal, |
|
appendToBody = _props5.appendToBody; |
|
var dayPickerContainerStyles = this.state.dayPickerContainerStyles; |
|
|
|
|
|
var isAnchoredLeft = anchorDirection === _constants.ANCHOR_LEFT; |
|
if (!withPortal && !withFullScreenPortal) { |
|
var containerRect = this.dayPickerContainer.getBoundingClientRect(); |
|
var currentOffset = dayPickerContainerStyles[anchorDirection] || 0; |
|
var containerEdge = isAnchoredLeft ? containerRect[_constants.ANCHOR_RIGHT] : containerRect[_constants.ANCHOR_LEFT]; |
|
|
|
this.setState({ |
|
dayPickerContainerStyles: (0, _object2['default'])({}, (0, _getResponsiveContainerStyles2['default'])(anchorDirection, currentOffset, containerEdge, horizontalMargin), appendToBody && (0, _getDetachedContainerStyles2['default'])(openDirection, anchorDirection, this.container)) |
|
}); |
|
} |
|
} |
|
|
|
return responsivizePickerPosition; |
|
}() |
|
}, { |
|
key: 'showKeyboardShortcutsPanel', |
|
value: function () { |
|
function showKeyboardShortcutsPanel() { |
|
this.setState({ |
|
isDateRangePickerInputFocused: false, |
|
isDayPickerFocused: true, |
|
showKeyboardShortcuts: true |
|
}); |
|
} |
|
|
|
return showKeyboardShortcutsPanel; |
|
}() |
|
}, { |
|
key: 'maybeRenderDayPickerWithPortal', |
|
value: function () { |
|
function maybeRenderDayPickerWithPortal() { |
|
var _props6 = this.props, |
|
withPortal = _props6.withPortal, |
|
withFullScreenPortal = _props6.withFullScreenPortal, |
|
appendToBody = _props6.appendToBody; |
|
|
|
|
|
if (!this.isOpened()) { |
|
return null; |
|
} |
|
|
|
if (withPortal || withFullScreenPortal || appendToBody) { |
|
return _react2['default'].createElement( |
|
_reactPortal.Portal, |
|
null, |
|
this.renderDayPicker() |
|
); |
|
} |
|
|
|
return this.renderDayPicker(); |
|
} |
|
|
|
return maybeRenderDayPickerWithPortal; |
|
}() |
|
}, { |
|
key: 'renderDayPicker', |
|
value: function () { |
|
function renderDayPicker() { |
|
var _props7 = this.props, |
|
anchorDirection = _props7.anchorDirection, |
|
openDirection = _props7.openDirection, |
|
isDayBlocked = _props7.isDayBlocked, |
|
isDayHighlighted = _props7.isDayHighlighted, |
|
isOutsideRange = _props7.isOutsideRange, |
|
numberOfMonths = _props7.numberOfMonths, |
|
orientation = _props7.orientation, |
|
monthFormat = _props7.monthFormat, |
|
renderMonthText = _props7.renderMonthText, |
|
navPrev = _props7.navPrev, |
|
navNext = _props7.navNext, |
|
onPrevMonthClick = _props7.onPrevMonthClick, |
|
onNextMonthClick = _props7.onNextMonthClick, |
|
onDatesChange = _props7.onDatesChange, |
|
onFocusChange = _props7.onFocusChange, |
|
withPortal = _props7.withPortal, |
|
withFullScreenPortal = _props7.withFullScreenPortal, |
|
daySize = _props7.daySize, |
|
enableOutsideDays = _props7.enableOutsideDays, |
|
focusedInput = _props7.focusedInput, |
|
startDate = _props7.startDate, |
|
endDate = _props7.endDate, |
|
minimumNights = _props7.minimumNights, |
|
keepOpenOnDateSelect = _props7.keepOpenOnDateSelect, |
|
renderCalendarDay = _props7.renderCalendarDay, |
|
renderDayContents = _props7.renderDayContents, |
|
renderCalendarInfo = _props7.renderCalendarInfo, |
|
renderMonthElement = _props7.renderMonthElement, |
|
calendarInfoPosition = _props7.calendarInfoPosition, |
|
firstDayOfWeek = _props7.firstDayOfWeek, |
|
initialVisibleMonth = _props7.initialVisibleMonth, |
|
hideKeyboardShortcutsPanel = _props7.hideKeyboardShortcutsPanel, |
|
customCloseIcon = _props7.customCloseIcon, |
|
onClose = _props7.onClose, |
|
phrases = _props7.phrases, |
|
dayAriaLabelFormat = _props7.dayAriaLabelFormat, |
|
isRTL = _props7.isRTL, |
|
weekDayFormat = _props7.weekDayFormat, |
|
styles = _props7.styles, |
|
verticalHeight = _props7.verticalHeight, |
|
transitionDuration = _props7.transitionDuration, |
|
verticalSpacing = _props7.verticalSpacing, |
|
small = _props7.small, |
|
disabled = _props7.disabled, |
|
reactDates = _props7.theme.reactDates; |
|
var _state = this.state, |
|
dayPickerContainerStyles = _state.dayPickerContainerStyles, |
|
isDayPickerFocused = _state.isDayPickerFocused, |
|
showKeyboardShortcuts = _state.showKeyboardShortcuts; |
|
|
|
|
|
var onOutsideClick = !withFullScreenPortal && withPortal ? this.onOutsideClick : undefined; |
|
var initialVisibleMonthThunk = initialVisibleMonth || function () { |
|
return startDate || endDate || (0, _moment2['default'])(); |
|
}; |
|
|
|
var closeIcon = customCloseIcon || _react2['default'].createElement(_CloseButton2['default'], (0, _reactWithStyles.css)(styles.DateRangePicker_closeButton_svg)); |
|
|
|
var inputHeight = (0, _getInputHeight2['default'])(reactDates, small); |
|
|
|
var withAnyPortal = withPortal || withFullScreenPortal; |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
_extends({ // eslint-disable-line jsx-a11y/no-static-element-interactions |
|
ref: this.setDayPickerContainerRef |
|
}, (0, _reactWithStyles.css)(styles.DateRangePicker_picker, anchorDirection === _constants.ANCHOR_LEFT && styles.DateRangePicker_picker__directionLeft, anchorDirection === _constants.ANCHOR_RIGHT && styles.DateRangePicker_picker__directionRight, orientation === _constants.HORIZONTAL_ORIENTATION && styles.DateRangePicker_picker__horizontal, orientation === _constants.VERTICAL_ORIENTATION && styles.DateRangePicker_picker__vertical, !withAnyPortal && openDirection === _constants.OPEN_DOWN && { |
|
top: inputHeight + verticalSpacing |
|
}, !withAnyPortal && openDirection === _constants.OPEN_UP && { |
|
bottom: inputHeight + verticalSpacing |
|
}, withAnyPortal && styles.DateRangePicker_picker__portal, withFullScreenPortal && styles.DateRangePicker_picker__fullScreenPortal, isRTL && styles.DateRangePicker_picker__rtl, dayPickerContainerStyles), { |
|
onClick: onOutsideClick |
|
}), |
|
_react2['default'].createElement(_DayPickerRangeController2['default'], { |
|
orientation: orientation, |
|
enableOutsideDays: enableOutsideDays, |
|
numberOfMonths: numberOfMonths, |
|
onPrevMonthClick: onPrevMonthClick, |
|
onNextMonthClick: onNextMonthClick, |
|
onDatesChange: onDatesChange, |
|
onFocusChange: onFocusChange, |
|
onClose: onClose, |
|
focusedInput: focusedInput, |
|
startDate: startDate, |
|
endDate: endDate, |
|
monthFormat: monthFormat, |
|
renderMonthText: renderMonthText, |
|
withPortal: withAnyPortal, |
|
daySize: daySize, |
|
initialVisibleMonth: initialVisibleMonthThunk, |
|
hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel, |
|
navPrev: navPrev, |
|
navNext: navNext, |
|
minimumNights: minimumNights, |
|
isOutsideRange: isOutsideRange, |
|
isDayHighlighted: isDayHighlighted, |
|
isDayBlocked: isDayBlocked, |
|
keepOpenOnDateSelect: keepOpenOnDateSelect, |
|
renderCalendarDay: renderCalendarDay, |
|
renderDayContents: renderDayContents, |
|
renderCalendarInfo: renderCalendarInfo, |
|
renderMonthElement: renderMonthElement, |
|
calendarInfoPosition: calendarInfoPosition, |
|
isFocused: isDayPickerFocused, |
|
showKeyboardShortcuts: showKeyboardShortcuts, |
|
onBlur: this.onDayPickerBlur, |
|
phrases: phrases, |
|
dayAriaLabelFormat: dayAriaLabelFormat, |
|
isRTL: isRTL, |
|
firstDayOfWeek: firstDayOfWeek, |
|
weekDayFormat: weekDayFormat, |
|
verticalHeight: verticalHeight, |
|
transitionDuration: transitionDuration, |
|
disabled: disabled |
|
}), |
|
withFullScreenPortal && _react2['default'].createElement( |
|
'button', |
|
_extends({}, (0, _reactWithStyles.css)(styles.DateRangePicker_closeButton), { |
|
type: 'button', |
|
onClick: this.onOutsideClick, |
|
'aria-label': phrases.closeDatePicker |
|
}), |
|
closeIcon |
|
) |
|
); |
|
} |
|
|
|
return renderDayPicker; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _props8 = this.props, |
|
startDate = _props8.startDate, |
|
startDateId = _props8.startDateId, |
|
startDatePlaceholderText = _props8.startDatePlaceholderText, |
|
endDate = _props8.endDate, |
|
endDateId = _props8.endDateId, |
|
endDatePlaceholderText = _props8.endDatePlaceholderText, |
|
focusedInput = _props8.focusedInput, |
|
screenReaderInputMessage = _props8.screenReaderInputMessage, |
|
showClearDates = _props8.showClearDates, |
|
showDefaultInputIcon = _props8.showDefaultInputIcon, |
|
inputIconPosition = _props8.inputIconPosition, |
|
customInputIcon = _props8.customInputIcon, |
|
customArrowIcon = _props8.customArrowIcon, |
|
customCloseIcon = _props8.customCloseIcon, |
|
disabled = _props8.disabled, |
|
required = _props8.required, |
|
readOnly = _props8.readOnly, |
|
openDirection = _props8.openDirection, |
|
phrases = _props8.phrases, |
|
isOutsideRange = _props8.isOutsideRange, |
|
minimumNights = _props8.minimumNights, |
|
withPortal = _props8.withPortal, |
|
withFullScreenPortal = _props8.withFullScreenPortal, |
|
displayFormat = _props8.displayFormat, |
|
reopenPickerOnClearDates = _props8.reopenPickerOnClearDates, |
|
keepOpenOnDateSelect = _props8.keepOpenOnDateSelect, |
|
onDatesChange = _props8.onDatesChange, |
|
onClose = _props8.onClose, |
|
isRTL = _props8.isRTL, |
|
noBorder = _props8.noBorder, |
|
block = _props8.block, |
|
verticalSpacing = _props8.verticalSpacing, |
|
small = _props8.small, |
|
regular = _props8.regular, |
|
styles = _props8.styles; |
|
var isDateRangePickerInputFocused = this.state.isDateRangePickerInputFocused; |
|
|
|
|
|
var enableOutsideClick = !withPortal && !withFullScreenPortal; |
|
|
|
var hideFang = verticalSpacing < _constants.FANG_HEIGHT_PX; |
|
|
|
var input = _react2['default'].createElement(_DateRangePickerInputController2['default'], { |
|
startDate: startDate, |
|
startDateId: startDateId, |
|
startDatePlaceholderText: startDatePlaceholderText, |
|
isStartDateFocused: focusedInput === _constants.START_DATE, |
|
endDate: endDate, |
|
endDateId: endDateId, |
|
endDatePlaceholderText: endDatePlaceholderText, |
|
isEndDateFocused: focusedInput === _constants.END_DATE, |
|
displayFormat: displayFormat, |
|
showClearDates: showClearDates, |
|
showCaret: !withPortal && !withFullScreenPortal && !hideFang, |
|
showDefaultInputIcon: showDefaultInputIcon, |
|
inputIconPosition: inputIconPosition, |
|
customInputIcon: customInputIcon, |
|
customArrowIcon: customArrowIcon, |
|
customCloseIcon: customCloseIcon, |
|
disabled: disabled, |
|
required: required, |
|
readOnly: readOnly, |
|
openDirection: openDirection, |
|
reopenPickerOnClearDates: reopenPickerOnClearDates, |
|
keepOpenOnDateSelect: keepOpenOnDateSelect, |
|
isOutsideRange: isOutsideRange, |
|
minimumNights: minimumNights, |
|
withFullScreenPortal: withFullScreenPortal, |
|
onDatesChange: onDatesChange, |
|
onFocusChange: this.onDateRangePickerInputFocus, |
|
onKeyDownArrowDown: this.onDayPickerFocus, |
|
onKeyDownQuestionMark: this.showKeyboardShortcutsPanel, |
|
onClose: onClose, |
|
phrases: phrases, |
|
screenReaderMessage: screenReaderInputMessage, |
|
isFocused: isDateRangePickerInputFocused, |
|
isRTL: isRTL, |
|
noBorder: noBorder, |
|
block: block, |
|
small: small, |
|
regular: regular, |
|
verticalSpacing: verticalSpacing |
|
}); |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
_extends({ |
|
ref: this.setContainerRef |
|
}, (0, _reactWithStyles.css)(styles.DateRangePicker, block && styles.DateRangePicker__block)), |
|
enableOutsideClick && _react2['default'].createElement( |
|
_reactOutsideClickHandler2['default'], |
|
{ onOutsideClick: this.onOutsideClick }, |
|
input, |
|
this.maybeRenderDayPickerWithPortal() |
|
), |
|
!enableOutsideClick && input, |
|
!enableOutsideClick && this.maybeRenderDayPickerWithPortal() |
|
); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return DateRangePicker; |
|
}(_react2['default'].Component); |
|
|
|
DateRangePicker.propTypes = propTypes; |
|
DateRangePicker.defaultProps = defaultProps; |
|
|
|
exports.PureDateRangePicker = DateRangePicker; |
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref) { |
|
var _ref$reactDates = _ref.reactDates, |
|
color = _ref$reactDates.color, |
|
zIndex = _ref$reactDates.zIndex; |
|
return { |
|
DateRangePicker: { |
|
position: 'relative', |
|
display: 'inline-block' |
|
}, |
|
|
|
DateRangePicker__block: { |
|
display: 'block' |
|
}, |
|
|
|
DateRangePicker_picker: { |
|
zIndex: zIndex + 1, |
|
backgroundColor: color.background, |
|
position: 'absolute' |
|
}, |
|
|
|
DateRangePicker_picker__rtl: { |
|
direction: 'rtl' |
|
}, |
|
|
|
DateRangePicker_picker__directionLeft: { |
|
left: 0 |
|
}, |
|
|
|
DateRangePicker_picker__directionRight: { |
|
right: 0 |
|
}, |
|
|
|
DateRangePicker_picker__portal: { |
|
backgroundColor: 'rgba(0, 0, 0, 0.3)', |
|
position: 'fixed', |
|
top: 0, |
|
left: 0, |
|
height: '100%', |
|
width: '100%' |
|
}, |
|
|
|
DateRangePicker_picker__fullScreenPortal: { |
|
backgroundColor: color.background |
|
}, |
|
|
|
DateRangePicker_closeButton: { |
|
background: 'none', |
|
border: 0, |
|
color: 'inherit', |
|
font: 'inherit', |
|
lineHeight: 'normal', |
|
overflow: 'visible', |
|
cursor: 'pointer', |
|
|
|
position: 'absolute', |
|
top: 0, |
|
right: 0, |
|
padding: 15, |
|
zIndex: zIndex + 2, |
|
|
|
':hover': { |
|
color: 'darken(' + String(color.core.grayLighter) + ', 10%)', |
|
textDecoration: 'none' |
|
}, |
|
|
|
':focus': { |
|
color: 'darken(' + String(color.core.grayLighter) + ', 10%)', |
|
textDecoration: 'none' |
|
} |
|
}, |
|
|
|
DateRangePicker_closeButton_svg: { |
|
height: 15, |
|
width: 15, |
|
fill: color.core.grayLighter |
|
} |
|
}; |
|
})(DateRangePicker); |
|
|
|
/***/ }), |
|
/* 286 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _consolidatedEvents = __webpack_require__(105); |
|
|
|
var _object = __webpack_require__(135); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _document = __webpack_require__(293); |
|
|
|
var _document2 = _interopRequireDefault(_document); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
var DISPLAY = { |
|
BLOCK: 'block', |
|
FLEX: 'flex', |
|
INLINE: 'inline', |
|
INLINE_BLOCK: 'inline-block', |
|
CONTENTS: 'contents' |
|
}; |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)({ |
|
children: _propTypes2['default'].node.isRequired, |
|
onOutsideClick: _propTypes2['default'].func.isRequired, |
|
disabled: _propTypes2['default'].bool, |
|
useCapture: _propTypes2['default'].bool, |
|
display: _propTypes2['default'].oneOf((0, _object2['default'])(DISPLAY)) |
|
}); |
|
|
|
var defaultProps = { |
|
disabled: false, |
|
|
|
// `useCapture` is set to true by default so that a `stopPropagation` in the |
|
// children will not prevent all outside click handlers from firing - maja |
|
useCapture: true, |
|
display: DISPLAY.BLOCK |
|
}; |
|
|
|
var OutsideClickHandler = function (_React$Component) { |
|
_inherits(OutsideClickHandler, _React$Component); |
|
|
|
function OutsideClickHandler() { |
|
var _ref; |
|
|
|
_classCallCheck(this, OutsideClickHandler); |
|
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { |
|
args[_key] = arguments[_key]; |
|
} |
|
|
|
var _this = _possibleConstructorReturn(this, (_ref = OutsideClickHandler.__proto__ || Object.getPrototypeOf(OutsideClickHandler)).call.apply(_ref, [this].concat(args))); |
|
|
|
_this.onMouseDown = _this.onMouseDown.bind(_this); |
|
_this.onMouseUp = _this.onMouseUp.bind(_this); |
|
_this.setChildNodeRef = _this.setChildNodeRef.bind(_this); |
|
return _this; |
|
} |
|
|
|
_createClass(OutsideClickHandler, [{ |
|
key: 'componentDidMount', |
|
value: function () { |
|
function componentDidMount() { |
|
var _props = this.props, |
|
disabled = _props.disabled, |
|
useCapture = _props.useCapture; |
|
|
|
|
|
if (!disabled) this.addMouseDownEventListener(useCapture); |
|
} |
|
|
|
return componentDidMount; |
|
}() |
|
}, { |
|
key: 'componentDidUpdate', |
|
value: function () { |
|
function componentDidUpdate(_ref2) { |
|
var prevDisabled = _ref2.disabled; |
|
var _props2 = this.props, |
|
disabled = _props2.disabled, |
|
useCapture = _props2.useCapture; |
|
|
|
if (prevDisabled !== disabled) { |
|
if (disabled) { |
|
this.removeEventListeners(); |
|
} else { |
|
this.addMouseDownEventListener(useCapture); |
|
} |
|
} |
|
} |
|
|
|
return componentDidUpdate; |
|
}() |
|
}, { |
|
key: 'componentWillUnmount', |
|
value: function () { |
|
function componentWillUnmount() { |
|
this.removeEventListeners(); |
|
} |
|
|
|
return componentWillUnmount; |
|
}() |
|
|
|
// Use mousedown/mouseup to enforce that clicks remain outside the root's |
|
// descendant tree, even when dragged. This should also get triggered on |
|
// touch devices. |
|
|
|
}, { |
|
key: 'onMouseDown', |
|
value: function () { |
|
function onMouseDown(e) { |
|
var useCapture = this.props.useCapture; |
|
|
|
|
|
var isDescendantOfRoot = this.childNode && (0, _document2['default'])(this.childNode, e.target); |
|
if (!isDescendantOfRoot) { |
|
if (this.removeMouseUp) { |
|
this.removeMouseUp(); |
|
this.removeMouseUp = null; |
|
} |
|
this.removeMouseUp = (0, _consolidatedEvents.addEventListener)(document, 'mouseup', this.onMouseUp, { capture: useCapture }); |
|
} |
|
} |
|
|
|
return onMouseDown; |
|
}() |
|
|
|
// Use mousedown/mouseup to enforce that clicks remain outside the root's |
|
// descendant tree, even when dragged. This should also get triggered on |
|
// touch devices. |
|
|
|
}, { |
|
key: 'onMouseUp', |
|
value: function () { |
|
function onMouseUp(e) { |
|
var onOutsideClick = this.props.onOutsideClick; |
|
|
|
|
|
var isDescendantOfRoot = this.childNode && (0, _document2['default'])(this.childNode, e.target); |
|
if (this.removeMouseUp) { |
|
this.removeMouseUp(); |
|
this.removeMouseUp = null; |
|
} |
|
|
|
if (!isDescendantOfRoot) { |
|
onOutsideClick(e); |
|
} |
|
} |
|
|
|
return onMouseUp; |
|
}() |
|
}, { |
|
key: 'setChildNodeRef', |
|
value: function () { |
|
function setChildNodeRef(ref) { |
|
this.childNode = ref; |
|
} |
|
|
|
return setChildNodeRef; |
|
}() |
|
}, { |
|
key: 'addMouseDownEventListener', |
|
value: function () { |
|
function addMouseDownEventListener(useCapture) { |
|
this.removeMouseDown = (0, _consolidatedEvents.addEventListener)(document, 'mousedown', this.onMouseDown, { capture: useCapture }); |
|
} |
|
|
|
return addMouseDownEventListener; |
|
}() |
|
}, { |
|
key: 'removeEventListeners', |
|
value: function () { |
|
function removeEventListeners() { |
|
if (this.removeMouseDown) this.removeMouseDown(); |
|
if (this.removeMouseUp) this.removeMouseUp(); |
|
} |
|
|
|
return removeEventListeners; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _props3 = this.props, |
|
children = _props3.children, |
|
display = _props3.display; |
|
|
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
{ |
|
ref: this.setChildNodeRef, |
|
style: display !== DISPLAY.BLOCK && (0, _object2['default'])(DISPLAY).includes(display) ? { display: display } : undefined |
|
}, |
|
children |
|
); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return OutsideClickHandler; |
|
}(_react2['default'].Component); |
|
|
|
exports['default'] = OutsideClickHandler; |
|
|
|
|
|
OutsideClickHandler.propTypes = propTypes; |
|
OutsideClickHandler.defaultProps = defaultProps; |
|
|
|
/***/ }), |
|
/* 287 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
module.exports = __webpack_require__(288); |
|
|
|
|
|
/***/ }), |
|
/* 288 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var ES2015 = __webpack_require__(289); |
|
var assign = __webpack_require__(182); |
|
|
|
var ES2016 = assign(assign({}, ES2015), { |
|
// https://github.com/tc39/ecma262/pull/60 |
|
SameValueNonNumber: function SameValueNonNumber(x, y) { |
|
if (typeof x === 'number' || typeof x !== typeof y) { |
|
throw new TypeError('SameValueNonNumber requires two non-number values of the same type.'); |
|
} |
|
return this.SameValue(x, y); |
|
} |
|
}); |
|
|
|
module.exports = ES2016; |
|
|
|
|
|
/***/ }), |
|
/* 289 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var has = __webpack_require__(63); |
|
var toPrimitive = __webpack_require__(154); |
|
var keys = __webpack_require__(90); |
|
|
|
var GetIntrinsic = __webpack_require__(136); |
|
|
|
var $TypeError = GetIntrinsic('%TypeError%'); |
|
var $SyntaxError = GetIntrinsic('%SyntaxError%'); |
|
var $Array = GetIntrinsic('%Array%'); |
|
var $String = GetIntrinsic('%String%'); |
|
var $Object = GetIntrinsic('%Object%'); |
|
var $Number = GetIntrinsic('%Number%'); |
|
var $Symbol = GetIntrinsic('%Symbol%', true); |
|
var $RegExp = GetIntrinsic('%RegExp%'); |
|
|
|
var hasSymbols = !!$Symbol; |
|
|
|
var assertRecord = __webpack_require__(179); |
|
var $isNaN = __webpack_require__(180); |
|
var $isFinite = __webpack_require__(181); |
|
var MAX_SAFE_INTEGER = $Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1; |
|
|
|
var assign = __webpack_require__(182); |
|
var sign = __webpack_require__(183); |
|
var mod = __webpack_require__(184); |
|
var isPrimitive = __webpack_require__(290); |
|
var parseInteger = parseInt; |
|
var bind = __webpack_require__(59); |
|
var arraySlice = bind.call(Function.call, $Array.prototype.slice); |
|
var strSlice = bind.call(Function.call, $String.prototype.slice); |
|
var isBinary = bind.call(Function.call, $RegExp.prototype.test, /^0b[01]+$/i); |
|
var isOctal = bind.call(Function.call, $RegExp.prototype.test, /^0o[0-7]+$/i); |
|
var regexExec = bind.call(Function.call, $RegExp.prototype.exec); |
|
var nonWS = ['\u0085', '\u200b', '\ufffe'].join(''); |
|
var nonWSregex = new $RegExp('[' + nonWS + ']', 'g'); |
|
var hasNonWS = bind.call(Function.call, $RegExp.prototype.test, nonWSregex); |
|
var invalidHexLiteral = /^[-+]0x[0-9a-f]+$/i; |
|
var isInvalidHexLiteral = bind.call(Function.call, $RegExp.prototype.test, invalidHexLiteral); |
|
var $charCodeAt = bind.call(Function.call, $String.prototype.charCodeAt); |
|
|
|
var toStr = bind.call(Function.call, Object.prototype.toString); |
|
|
|
var $NumberValueOf = bind.call(Function.call, GetIntrinsic('%NumberPrototype%').valueOf); |
|
var $BooleanValueOf = bind.call(Function.call, GetIntrinsic('%BooleanPrototype%').valueOf); |
|
var $StringValueOf = bind.call(Function.call, GetIntrinsic('%StringPrototype%').valueOf); |
|
var $DateValueOf = bind.call(Function.call, GetIntrinsic('%DatePrototype%').valueOf); |
|
|
|
var $floor = Math.floor; |
|
var $abs = Math.abs; |
|
|
|
var $ObjectCreate = Object.create; |
|
var $gOPD = $Object.getOwnPropertyDescriptor; |
|
|
|
var $isExtensible = $Object.isExtensible; |
|
|
|
var $defineProperty = $Object.defineProperty; |
|
|
|
// whitespace from: http://es5.github.io/#x15.5.4.20 |
|
// implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324 |
|
var ws = [ |
|
'\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003', |
|
'\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028', |
|
'\u2029\uFEFF' |
|
].join(''); |
|
var trimRegex = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g'); |
|
var replace = bind.call(Function.call, $String.prototype.replace); |
|
var trim = function (value) { |
|
return replace(value, trimRegex, ''); |
|
}; |
|
|
|
var ES5 = __webpack_require__(291); |
|
|
|
var hasRegExpMatcher = __webpack_require__(166); |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-abstract-operations |
|
var ES6 = assign(assign({}, ES5), { |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-call-f-v-args |
|
Call: function Call(F, V) { |
|
var args = arguments.length > 2 ? arguments[2] : []; |
|
if (!this.IsCallable(F)) { |
|
throw new $TypeError(F + ' is not a function'); |
|
} |
|
return F.apply(V, args); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toprimitive |
|
ToPrimitive: toPrimitive, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toboolean |
|
// ToBoolean: ES5.ToBoolean, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-tonumber |
|
ToNumber: function ToNumber(argument) { |
|
var value = isPrimitive(argument) ? argument : toPrimitive(argument, $Number); |
|
if (typeof value === 'symbol') { |
|
throw new $TypeError('Cannot convert a Symbol value to a number'); |
|
} |
|
if (typeof value === 'string') { |
|
if (isBinary(value)) { |
|
return this.ToNumber(parseInteger(strSlice(value, 2), 2)); |
|
} else if (isOctal(value)) { |
|
return this.ToNumber(parseInteger(strSlice(value, 2), 8)); |
|
} else if (hasNonWS(value) || isInvalidHexLiteral(value)) { |
|
return NaN; |
|
} else { |
|
var trimmed = trim(value); |
|
if (trimmed !== value) { |
|
return this.ToNumber(trimmed); |
|
} |
|
} |
|
} |
|
return $Number(value); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tointeger |
|
// ToInteger: ES5.ToNumber, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toint32 |
|
// ToInt32: ES5.ToInt32, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint32 |
|
// ToUint32: ES5.ToUint32, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toint16 |
|
ToInt16: function ToInt16(argument) { |
|
var int16bit = this.ToUint16(argument); |
|
return int16bit >= 0x8000 ? int16bit - 0x10000 : int16bit; |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint16 |
|
// ToUint16: ES5.ToUint16, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toint8 |
|
ToInt8: function ToInt8(argument) { |
|
var int8bit = this.ToUint8(argument); |
|
return int8bit >= 0x80 ? int8bit - 0x100 : int8bit; |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint8 |
|
ToUint8: function ToUint8(argument) { |
|
var number = this.ToNumber(argument); |
|
if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; } |
|
var posInt = sign(number) * $floor($abs(number)); |
|
return mod(posInt, 0x100); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint8clamp |
|
ToUint8Clamp: function ToUint8Clamp(argument) { |
|
var number = this.ToNumber(argument); |
|
if ($isNaN(number) || number <= 0) { return 0; } |
|
if (number >= 0xFF) { return 0xFF; } |
|
var f = $floor(argument); |
|
if (f + 0.5 < number) { return f + 1; } |
|
if (number < f + 0.5) { return f; } |
|
if (f % 2 !== 0) { return f + 1; } |
|
return f; |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tostring |
|
ToString: function ToString(argument) { |
|
if (typeof argument === 'symbol') { |
|
throw new $TypeError('Cannot convert a Symbol value to a string'); |
|
} |
|
return $String(argument); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toobject |
|
ToObject: function ToObject(value) { |
|
this.RequireObjectCoercible(value); |
|
return $Object(value); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-topropertykey |
|
ToPropertyKey: function ToPropertyKey(argument) { |
|
var key = this.ToPrimitive(argument, $String); |
|
return typeof key === 'symbol' ? key : this.ToString(key); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength |
|
ToLength: function ToLength(argument) { |
|
var len = this.ToInteger(argument); |
|
if (len <= 0) { return 0; } // includes converting -0 to +0 |
|
if (len > MAX_SAFE_INTEGER) { return MAX_SAFE_INTEGER; } |
|
return len; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-canonicalnumericindexstring |
|
CanonicalNumericIndexString: function CanonicalNumericIndexString(argument) { |
|
if (toStr(argument) !== '[object String]') { |
|
throw new $TypeError('must be a string'); |
|
} |
|
if (argument === '-0') { return -0; } |
|
var n = this.ToNumber(argument); |
|
if (this.SameValue(this.ToString(n), argument)) { return n; } |
|
return void 0; |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-requireobjectcoercible |
|
RequireObjectCoercible: ES5.CheckObjectCoercible, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isarray |
|
IsArray: $Array.isArray || function IsArray(argument) { |
|
return toStr(argument) === '[object Array]'; |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-iscallable |
|
// IsCallable: ES5.IsCallable, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isconstructor |
|
IsConstructor: function IsConstructor(argument) { |
|
return typeof argument === 'function' && !!argument.prototype; // unfortunately there's no way to truly check this without try/catch `new argument` |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isextensible-o |
|
IsExtensible: Object.preventExtensions |
|
? function IsExtensible(obj) { |
|
if (isPrimitive(obj)) { |
|
return false; |
|
} |
|
return $isExtensible(obj); |
|
} |
|
: function isExtensible(obj) { return true; }, // eslint-disable-line no-unused-vars |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isinteger |
|
IsInteger: function IsInteger(argument) { |
|
if (typeof argument !== 'number' || $isNaN(argument) || !$isFinite(argument)) { |
|
return false; |
|
} |
|
var abs = $abs(argument); |
|
return $floor(abs) === abs; |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ispropertykey |
|
IsPropertyKey: function IsPropertyKey(argument) { |
|
return typeof argument === 'string' || typeof argument === 'symbol'; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-isregexp |
|
IsRegExp: function IsRegExp(argument) { |
|
if (!argument || typeof argument !== 'object') { |
|
return false; |
|
} |
|
if (hasSymbols) { |
|
var isRegExp = argument[$Symbol.match]; |
|
if (typeof isRegExp !== 'undefined') { |
|
return ES5.ToBoolean(isRegExp); |
|
} |
|
} |
|
return hasRegExpMatcher(argument); |
|
}, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevalue |
|
// SameValue: ES5.SameValue, |
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero |
|
SameValueZero: function SameValueZero(x, y) { |
|
return (x === y) || ($isNaN(x) && $isNaN(y)); |
|
}, |
|
|
|
/** |
|
* 7.3.2 GetV (V, P) |
|
* 1. Assert: IsPropertyKey(P) is true. |
|
* 2. Let O be ToObject(V). |
|
* 3. ReturnIfAbrupt(O). |
|
* 4. Return O.[[Get]](P, V). |
|
*/ |
|
GetV: function GetV(V, P) { |
|
// 7.3.2.1 |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
|
|
// 7.3.2.2-3 |
|
var O = this.ToObject(V); |
|
|
|
// 7.3.2.4 |
|
return O[P]; |
|
}, |
|
|
|
/** |
|
* 7.3.9 - https://ecma-international.org/ecma-262/6.0/#sec-getmethod |
|
* 1. Assert: IsPropertyKey(P) is true. |
|
* 2. Let func be GetV(O, P). |
|
* 3. ReturnIfAbrupt(func). |
|
* 4. If func is either undefined or null, return undefined. |
|
* 5. If IsCallable(func) is false, throw a TypeError exception. |
|
* 6. Return func. |
|
*/ |
|
GetMethod: function GetMethod(O, P) { |
|
// 7.3.9.1 |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
|
|
// 7.3.9.2 |
|
var func = this.GetV(O, P); |
|
|
|
// 7.3.9.4 |
|
if (func == null) { |
|
return void 0; |
|
} |
|
|
|
// 7.3.9.5 |
|
if (!this.IsCallable(func)) { |
|
throw new $TypeError(P + 'is not a function'); |
|
} |
|
|
|
// 7.3.9.6 |
|
return func; |
|
}, |
|
|
|
/** |
|
* 7.3.1 Get (O, P) - https://ecma-international.org/ecma-262/6.0/#sec-get-o-p |
|
* 1. Assert: Type(O) is Object. |
|
* 2. Assert: IsPropertyKey(P) is true. |
|
* 3. Return O.[[Get]](P, O). |
|
*/ |
|
Get: function Get(O, P) { |
|
// 7.3.1.1 |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
// 7.3.1.2 |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
// 7.3.1.3 |
|
return O[P]; |
|
}, |
|
|
|
Type: function Type(x) { |
|
if (typeof x === 'symbol') { |
|
return 'Symbol'; |
|
} |
|
return ES5.Type(x); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-speciesconstructor |
|
SpeciesConstructor: function SpeciesConstructor(O, defaultConstructor) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
var C = O.constructor; |
|
if (typeof C === 'undefined') { |
|
return defaultConstructor; |
|
} |
|
if (this.Type(C) !== 'Object') { |
|
throw new $TypeError('O.constructor is not an Object'); |
|
} |
|
var S = hasSymbols && $Symbol.species ? C[$Symbol.species] : void 0; |
|
if (S == null) { |
|
return defaultConstructor; |
|
} |
|
if (this.IsConstructor(S)) { |
|
return S; |
|
} |
|
throw new $TypeError('no constructor found'); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-completepropertydescriptor |
|
CompletePropertyDescriptor: function CompletePropertyDescriptor(Desc) { |
|
assertRecord(this, 'Property Descriptor', 'Desc', Desc); |
|
|
|
if (this.IsGenericDescriptor(Desc) || this.IsDataDescriptor(Desc)) { |
|
if (!has(Desc, '[[Value]]')) { |
|
Desc['[[Value]]'] = void 0; |
|
} |
|
if (!has(Desc, '[[Writable]]')) { |
|
Desc['[[Writable]]'] = false; |
|
} |
|
} else { |
|
if (!has(Desc, '[[Get]]')) { |
|
Desc['[[Get]]'] = void 0; |
|
} |
|
if (!has(Desc, '[[Set]]')) { |
|
Desc['[[Set]]'] = void 0; |
|
} |
|
} |
|
if (!has(Desc, '[[Enumerable]]')) { |
|
Desc['[[Enumerable]]'] = false; |
|
} |
|
if (!has(Desc, '[[Configurable]]')) { |
|
Desc['[[Configurable]]'] = false; |
|
} |
|
return Desc; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-set-o-p-v-throw |
|
Set: function Set(O, P, V, Throw) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('O must be an Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('P must be a Property Key'); |
|
} |
|
if (this.Type(Throw) !== 'Boolean') { |
|
throw new $TypeError('Throw must be a Boolean'); |
|
} |
|
if (Throw) { |
|
O[P] = V; |
|
return true; |
|
} else { |
|
try { |
|
O[P] = V; |
|
} catch (e) { |
|
return false; |
|
} |
|
} |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-hasownproperty |
|
HasOwnProperty: function HasOwnProperty(O, P) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('O must be an Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('P must be a Property Key'); |
|
} |
|
return has(O, P); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-hasproperty |
|
HasProperty: function HasProperty(O, P) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('O must be an Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('P must be a Property Key'); |
|
} |
|
return P in O; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-isconcatspreadable |
|
IsConcatSpreadable: function IsConcatSpreadable(O) { |
|
if (this.Type(O) !== 'Object') { |
|
return false; |
|
} |
|
if (hasSymbols && typeof $Symbol.isConcatSpreadable === 'symbol') { |
|
var spreadable = this.Get(O, Symbol.isConcatSpreadable); |
|
if (typeof spreadable !== 'undefined') { |
|
return this.ToBoolean(spreadable); |
|
} |
|
} |
|
return this.IsArray(O); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-invoke |
|
Invoke: function Invoke(O, P) { |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('P must be a Property Key'); |
|
} |
|
var argumentsList = arraySlice(arguments, 2); |
|
var func = this.GetV(O, P); |
|
return this.Call(func, O, argumentsList); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-getiterator |
|
GetIterator: function GetIterator(obj, method) { |
|
if (!hasSymbols) { |
|
throw new SyntaxError('ES.GetIterator depends on native iterator support.'); |
|
} |
|
|
|
var actualMethod = method; |
|
if (arguments.length < 2) { |
|
actualMethod = this.GetMethod(obj, $Symbol.iterator); |
|
} |
|
var iterator = this.Call(actualMethod, obj); |
|
if (this.Type(iterator) !== 'Object') { |
|
throw new $TypeError('iterator must return an object'); |
|
} |
|
|
|
return iterator; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-iteratornext |
|
IteratorNext: function IteratorNext(iterator, value) { |
|
var result = this.Invoke(iterator, 'next', arguments.length < 2 ? [] : [value]); |
|
if (this.Type(result) !== 'Object') { |
|
throw new $TypeError('iterator next must return an object'); |
|
} |
|
return result; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-iteratorcomplete |
|
IteratorComplete: function IteratorComplete(iterResult) { |
|
if (this.Type(iterResult) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(iterResult) is not Object'); |
|
} |
|
return this.ToBoolean(this.Get(iterResult, 'done')); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-iteratorvalue |
|
IteratorValue: function IteratorValue(iterResult) { |
|
if (this.Type(iterResult) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(iterResult) is not Object'); |
|
} |
|
return this.Get(iterResult, 'value'); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-iteratorstep |
|
IteratorStep: function IteratorStep(iterator) { |
|
var result = this.IteratorNext(iterator); |
|
var done = this.IteratorComplete(result); |
|
return done === true ? false : result; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-iteratorclose |
|
IteratorClose: function IteratorClose(iterator, completion) { |
|
if (this.Type(iterator) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(iterator) is not Object'); |
|
} |
|
if (!this.IsCallable(completion)) { |
|
throw new $TypeError('Assertion failed: completion is not a thunk for a Completion Record'); |
|
} |
|
var completionThunk = completion; |
|
|
|
var iteratorReturn = this.GetMethod(iterator, 'return'); |
|
|
|
if (typeof iteratorReturn === 'undefined') { |
|
return completionThunk(); |
|
} |
|
|
|
var completionRecord; |
|
try { |
|
var innerResult = this.Call(iteratorReturn, iterator, []); |
|
} catch (e) { |
|
// if we hit here, then "e" is the innerResult completion that needs re-throwing |
|
|
|
// if the completion is of type "throw", this will throw. |
|
completionRecord = completionThunk(); |
|
completionThunk = null; // ensure it's not called twice. |
|
|
|
// if not, then return the innerResult completion |
|
throw e; |
|
} |
|
completionRecord = completionThunk(); // if innerResult worked, then throw if the completion does |
|
completionThunk = null; // ensure it's not called twice. |
|
|
|
if (this.Type(innerResult) !== 'Object') { |
|
throw new $TypeError('iterator .return must return an object'); |
|
} |
|
|
|
return completionRecord; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-createiterresultobject |
|
CreateIterResultObject: function CreateIterResultObject(value, done) { |
|
if (this.Type(done) !== 'Boolean') { |
|
throw new $TypeError('Assertion failed: Type(done) is not Boolean'); |
|
} |
|
return { |
|
value: value, |
|
done: done |
|
}; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-regexpexec |
|
RegExpExec: function RegExpExec(R, S) { |
|
if (this.Type(R) !== 'Object') { |
|
throw new $TypeError('R must be an Object'); |
|
} |
|
if (this.Type(S) !== 'String') { |
|
throw new $TypeError('S must be a String'); |
|
} |
|
var exec = this.Get(R, 'exec'); |
|
if (this.IsCallable(exec)) { |
|
var result = this.Call(exec, R, [S]); |
|
if (result === null || this.Type(result) === 'Object') { |
|
return result; |
|
} |
|
throw new $TypeError('"exec" method must return `null` or an Object'); |
|
} |
|
return regexExec(R, S); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-arrayspeciescreate |
|
ArraySpeciesCreate: function ArraySpeciesCreate(originalArray, length) { |
|
if (!this.IsInteger(length) || length < 0) { |
|
throw new $TypeError('Assertion failed: length must be an integer >= 0'); |
|
} |
|
var len = length === 0 ? 0 : length; |
|
var C; |
|
var isArray = this.IsArray(originalArray); |
|
if (isArray) { |
|
C = this.Get(originalArray, 'constructor'); |
|
// TODO: figure out how to make a cross-realm normal Array, a same-realm Array |
|
// if (this.IsConstructor(C)) { |
|
// if C is another realm's Array, C = undefined |
|
// Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(Array))) === null ? |
|
// } |
|
if (this.Type(C) === 'Object' && hasSymbols && $Symbol.species) { |
|
C = this.Get(C, $Symbol.species); |
|
if (C === null) { |
|
C = void 0; |
|
} |
|
} |
|
} |
|
if (typeof C === 'undefined') { |
|
return $Array(len); |
|
} |
|
if (!this.IsConstructor(C)) { |
|
throw new $TypeError('C must be a constructor'); |
|
} |
|
return new C(len); // this.Construct(C, len); |
|
}, |
|
|
|
CreateDataProperty: function CreateDataProperty(O, P, V) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
var oldDesc = $gOPD(O, P); |
|
var extensible = oldDesc || (typeof $isExtensible !== 'function' || $isExtensible(O)); |
|
var immutable = oldDesc && (!oldDesc.writable || !oldDesc.configurable); |
|
if (immutable || !extensible) { |
|
return false; |
|
} |
|
var newDesc = { |
|
configurable: true, |
|
enumerable: true, |
|
value: V, |
|
writable: true |
|
}; |
|
$defineProperty(O, P, newDesc); |
|
return true; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-createdatapropertyorthrow |
|
CreateDataPropertyOrThrow: function CreateDataPropertyOrThrow(O, P, V) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
var success = this.CreateDataProperty(O, P, V); |
|
if (!success) { |
|
throw new $TypeError('unable to create data property'); |
|
} |
|
return success; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-objectcreate |
|
ObjectCreate: function ObjectCreate(proto, internalSlotsList) { |
|
if (proto !== null && this.Type(proto) !== 'Object') { |
|
throw new $TypeError('Assertion failed: proto must be null or an object'); |
|
} |
|
var slots = arguments.length < 2 ? [] : internalSlotsList; |
|
if (slots.length > 0) { |
|
throw new $SyntaxError('es-abstract does not yet support internal slots'); |
|
} |
|
|
|
if (proto === null && !$ObjectCreate) { |
|
throw new $SyntaxError('native Object.create support is required to create null objects'); |
|
} |
|
|
|
return $ObjectCreate(proto); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-advancestringindex |
|
AdvanceStringIndex: function AdvanceStringIndex(S, index, unicode) { |
|
if (this.Type(S) !== 'String') { |
|
throw new $TypeError('S must be a String'); |
|
} |
|
if (!this.IsInteger(index) || index < 0 || index > MAX_SAFE_INTEGER) { |
|
throw new $TypeError('Assertion failed: length must be an integer >= 0 and <= 2**53'); |
|
} |
|
if (this.Type(unicode) !== 'Boolean') { |
|
throw new $TypeError('Assertion failed: unicode must be a Boolean'); |
|
} |
|
if (!unicode) { |
|
return index + 1; |
|
} |
|
var length = S.length; |
|
if ((index + 1) >= length) { |
|
return index + 1; |
|
} |
|
|
|
var first = $charCodeAt(S, index); |
|
if (first < 0xD800 || first > 0xDBFF) { |
|
return index + 1; |
|
} |
|
|
|
var second = $charCodeAt(S, index + 1); |
|
if (second < 0xDC00 || second > 0xDFFF) { |
|
return index + 1; |
|
} |
|
|
|
return index + 2; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-createmethodproperty |
|
CreateMethodProperty: function CreateMethodProperty(O, P, V) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
|
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
|
|
var newDesc = { |
|
configurable: true, |
|
enumerable: false, |
|
value: V, |
|
writable: true |
|
}; |
|
return !!$defineProperty(O, P, newDesc); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-definepropertyorthrow |
|
DefinePropertyOrThrow: function DefinePropertyOrThrow(O, P, desc) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
|
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
|
|
return !!$defineProperty(O, P, desc); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-deletepropertyorthrow |
|
DeletePropertyOrThrow: function DeletePropertyOrThrow(O, P) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
|
|
if (!this.IsPropertyKey(P)) { |
|
throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true'); |
|
} |
|
|
|
var success = delete O[P]; |
|
if (!success) { |
|
throw new TypeError('Attempt to delete property failed.'); |
|
} |
|
return success; |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/6.0/#sec-enumerableownnames |
|
EnumerableOwnNames: function EnumerableOwnNames(O) { |
|
if (this.Type(O) !== 'Object') { |
|
throw new $TypeError('Assertion failed: Type(O) is not Object'); |
|
} |
|
|
|
return keys(O); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-number-prototype-object |
|
thisNumberValue: function thisNumberValue(value) { |
|
if (this.Type(value) === 'Number') { |
|
return value; |
|
} |
|
|
|
return $NumberValueOf(value); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-boolean-prototype-object |
|
thisBooleanValue: function thisBooleanValue(value) { |
|
if (this.Type(value) === 'Boolean') { |
|
return value; |
|
} |
|
|
|
return $BooleanValueOf(value); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-string-prototype-object |
|
thisStringValue: function thisStringValue(value) { |
|
if (this.Type(value) === 'String') { |
|
return value; |
|
} |
|
|
|
return $StringValueOf(value); |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-date-prototype-object |
|
thisTimeValue: function thisTimeValue(value) { |
|
return $DateValueOf(value); |
|
} |
|
}); |
|
|
|
delete ES6.CheckObjectCoercible; // renamed in ES6 to RequireObjectCoercible |
|
|
|
module.exports = ES6; |
|
|
|
|
|
/***/ }), |
|
/* 290 */ |
|
/***/ (function(module, exports) { |
|
|
|
module.exports = function isPrimitive(value) { |
|
return value === null || (typeof value !== 'function' && typeof value !== 'object'); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 291 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var GetIntrinsic = __webpack_require__(136); |
|
|
|
var $Object = GetIntrinsic('%Object%'); |
|
var $TypeError = GetIntrinsic('%TypeError%'); |
|
var $String = GetIntrinsic('%String%'); |
|
|
|
var assertRecord = __webpack_require__(179); |
|
var $isNaN = __webpack_require__(180); |
|
var $isFinite = __webpack_require__(181); |
|
|
|
var sign = __webpack_require__(183); |
|
var mod = __webpack_require__(184); |
|
|
|
var IsCallable = __webpack_require__(101); |
|
var toPrimitive = __webpack_require__(165); |
|
|
|
var has = __webpack_require__(63); |
|
|
|
// https://es5.github.io/#x9 |
|
var ES5 = { |
|
ToPrimitive: toPrimitive, |
|
|
|
ToBoolean: function ToBoolean(value) { |
|
return !!value; |
|
}, |
|
ToNumber: function ToNumber(value) { |
|
return +value; // eslint-disable-line no-implicit-coercion |
|
}, |
|
ToInteger: function ToInteger(value) { |
|
var number = this.ToNumber(value); |
|
if ($isNaN(number)) { return 0; } |
|
if (number === 0 || !$isFinite(number)) { return number; } |
|
return sign(number) * Math.floor(Math.abs(number)); |
|
}, |
|
ToInt32: function ToInt32(x) { |
|
return this.ToNumber(x) >> 0; |
|
}, |
|
ToUint32: function ToUint32(x) { |
|
return this.ToNumber(x) >>> 0; |
|
}, |
|
ToUint16: function ToUint16(value) { |
|
var number = this.ToNumber(value); |
|
if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; } |
|
var posInt = sign(number) * Math.floor(Math.abs(number)); |
|
return mod(posInt, 0x10000); |
|
}, |
|
ToString: function ToString(value) { |
|
return $String(value); |
|
}, |
|
ToObject: function ToObject(value) { |
|
this.CheckObjectCoercible(value); |
|
return $Object(value); |
|
}, |
|
CheckObjectCoercible: function CheckObjectCoercible(value, optMessage) { |
|
/* jshint eqnull:true */ |
|
if (value == null) { |
|
throw new $TypeError(optMessage || 'Cannot call method on ' + value); |
|
} |
|
return value; |
|
}, |
|
IsCallable: IsCallable, |
|
SameValue: function SameValue(x, y) { |
|
if (x === y) { // 0 === -0, but they are not identical. |
|
if (x === 0) { return 1 / x === 1 / y; } |
|
return true; |
|
} |
|
return $isNaN(x) && $isNaN(y); |
|
}, |
|
|
|
// https://www.ecma-international.org/ecma-262/5.1/#sec-8 |
|
Type: function Type(x) { |
|
if (x === null) { |
|
return 'Null'; |
|
} |
|
if (typeof x === 'undefined') { |
|
return 'Undefined'; |
|
} |
|
if (typeof x === 'function' || typeof x === 'object') { |
|
return 'Object'; |
|
} |
|
if (typeof x === 'number') { |
|
return 'Number'; |
|
} |
|
if (typeof x === 'boolean') { |
|
return 'Boolean'; |
|
} |
|
if (typeof x === 'string') { |
|
return 'String'; |
|
} |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/6.0/#sec-property-descriptor-specification-type |
|
IsPropertyDescriptor: function IsPropertyDescriptor(Desc) { |
|
if (this.Type(Desc) !== 'Object') { |
|
return false; |
|
} |
|
var allowed = { |
|
'[[Configurable]]': true, |
|
'[[Enumerable]]': true, |
|
'[[Get]]': true, |
|
'[[Set]]': true, |
|
'[[Value]]': true, |
|
'[[Writable]]': true |
|
}; |
|
|
|
for (var key in Desc) { // eslint-disable-line |
|
if (has(Desc, key) && !allowed[key]) { |
|
return false; |
|
} |
|
} |
|
|
|
var isData = has(Desc, '[[Value]]'); |
|
var IsAccessor = has(Desc, '[[Get]]') || has(Desc, '[[Set]]'); |
|
if (isData && IsAccessor) { |
|
throw new $TypeError('Property Descriptors may not be both accessor and data descriptors'); |
|
} |
|
return true; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-8.10.1 |
|
IsAccessorDescriptor: function IsAccessorDescriptor(Desc) { |
|
if (typeof Desc === 'undefined') { |
|
return false; |
|
} |
|
|
|
assertRecord(this, 'Property Descriptor', 'Desc', Desc); |
|
|
|
if (!has(Desc, '[[Get]]') && !has(Desc, '[[Set]]')) { |
|
return false; |
|
} |
|
|
|
return true; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-8.10.2 |
|
IsDataDescriptor: function IsDataDescriptor(Desc) { |
|
if (typeof Desc === 'undefined') { |
|
return false; |
|
} |
|
|
|
assertRecord(this, 'Property Descriptor', 'Desc', Desc); |
|
|
|
if (!has(Desc, '[[Value]]') && !has(Desc, '[[Writable]]')) { |
|
return false; |
|
} |
|
|
|
return true; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-8.10.3 |
|
IsGenericDescriptor: function IsGenericDescriptor(Desc) { |
|
if (typeof Desc === 'undefined') { |
|
return false; |
|
} |
|
|
|
assertRecord(this, 'Property Descriptor', 'Desc', Desc); |
|
|
|
if (!this.IsAccessorDescriptor(Desc) && !this.IsDataDescriptor(Desc)) { |
|
return true; |
|
} |
|
|
|
return false; |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-8.10.4 |
|
FromPropertyDescriptor: function FromPropertyDescriptor(Desc) { |
|
if (typeof Desc === 'undefined') { |
|
return Desc; |
|
} |
|
|
|
assertRecord(this, 'Property Descriptor', 'Desc', Desc); |
|
|
|
if (this.IsDataDescriptor(Desc)) { |
|
return { |
|
value: Desc['[[Value]]'], |
|
writable: !!Desc['[[Writable]]'], |
|
enumerable: !!Desc['[[Enumerable]]'], |
|
configurable: !!Desc['[[Configurable]]'] |
|
}; |
|
} else if (this.IsAccessorDescriptor(Desc)) { |
|
return { |
|
get: Desc['[[Get]]'], |
|
set: Desc['[[Set]]'], |
|
enumerable: !!Desc['[[Enumerable]]'], |
|
configurable: !!Desc['[[Configurable]]'] |
|
}; |
|
} else { |
|
throw new $TypeError('FromPropertyDescriptor must be called with a fully populated Property Descriptor'); |
|
} |
|
}, |
|
|
|
// https://ecma-international.org/ecma-262/5.1/#sec-8.10.5 |
|
ToPropertyDescriptor: function ToPropertyDescriptor(Obj) { |
|
if (this.Type(Obj) !== 'Object') { |
|
throw new $TypeError('ToPropertyDescriptor requires an object'); |
|
} |
|
|
|
var desc = {}; |
|
if (has(Obj, 'enumerable')) { |
|
desc['[[Enumerable]]'] = this.ToBoolean(Obj.enumerable); |
|
} |
|
if (has(Obj, 'configurable')) { |
|
desc['[[Configurable]]'] = this.ToBoolean(Obj.configurable); |
|
} |
|
if (has(Obj, 'value')) { |
|
desc['[[Value]]'] = Obj.value; |
|
} |
|
if (has(Obj, 'writable')) { |
|
desc['[[Writable]]'] = this.ToBoolean(Obj.writable); |
|
} |
|
if (has(Obj, 'get')) { |
|
var getter = Obj.get; |
|
if (typeof getter !== 'undefined' && !this.IsCallable(getter)) { |
|
throw new TypeError('getter must be a function'); |
|
} |
|
desc['[[Get]]'] = getter; |
|
} |
|
if (has(Obj, 'set')) { |
|
var setter = Obj.set; |
|
if (typeof setter !== 'undefined' && !this.IsCallable(setter)) { |
|
throw new $TypeError('setter must be a function'); |
|
} |
|
desc['[[Set]]'] = setter; |
|
} |
|
|
|
if ((has(desc, '[[Get]]') || has(desc, '[[Set]]')) && (has(desc, '[[Value]]') || has(desc, '[[Writable]]'))) { |
|
throw new $TypeError('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute'); |
|
} |
|
return desc; |
|
} |
|
}; |
|
|
|
module.exports = ES5; |
|
|
|
|
|
/***/ }), |
|
/* 292 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var getPolyfill = __webpack_require__(185); |
|
var define = __webpack_require__(55); |
|
|
|
module.exports = function shimValues() { |
|
var polyfill = getPolyfill(); |
|
define(Object, { values: polyfill }, { |
|
values: function testValues() { |
|
return Object.values !== polyfill; |
|
} |
|
}); |
|
return polyfill; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 293 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var define = __webpack_require__(55); |
|
|
|
var implementation = __webpack_require__(186); |
|
var getPolyfill = __webpack_require__(187); |
|
var polyfill = getPolyfill(); |
|
var shim = __webpack_require__(294); |
|
|
|
var boundContains = function contains(node, other) { |
|
return polyfill.apply(node, [other]); |
|
}; |
|
|
|
define(boundContains, { |
|
getPolyfill: getPolyfill, |
|
implementation: implementation, |
|
shim: shim |
|
}); |
|
|
|
module.exports = boundContains; |
|
|
|
|
|
/***/ }), |
|
/* 294 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var define = __webpack_require__(55); |
|
var getPolyfill = __webpack_require__(187); |
|
|
|
module.exports = function shimContains() { |
|
var polyfill = getPolyfill(); |
|
if (typeof document !== 'undefined') { |
|
define( |
|
document, |
|
{ contains: polyfill }, |
|
{ contains: function () { return document.contains !== polyfill; } } |
|
); |
|
if (typeof Element !== 'undefined') { |
|
define( |
|
Element.prototype, |
|
{ contains: polyfill }, |
|
{ contains: function () { return Element.prototype.contains !== polyfill; } } |
|
); |
|
} |
|
} |
|
return polyfill; |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 295 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var isObject = __webpack_require__(138), |
|
now = __webpack_require__(296), |
|
toNumber = __webpack_require__(298); |
|
|
|
/** Error message constants. */ |
|
var FUNC_ERROR_TEXT = 'Expected a function'; |
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */ |
|
var nativeMax = Math.max, |
|
nativeMin = Math.min; |
|
|
|
/** |
|
* Creates a debounced function that delays invoking `func` until after `wait` |
|
* milliseconds have elapsed since the last time the debounced function was |
|
* invoked. The debounced function comes with a `cancel` method to cancel |
|
* delayed `func` invocations and a `flush` method to immediately invoke them. |
|
* Provide `options` to indicate whether `func` should be invoked on the |
|
* leading and/or trailing edge of the `wait` timeout. The `func` is invoked |
|
* with the last arguments provided to the debounced function. Subsequent |
|
* calls to the debounced function return the result of the last `func` |
|
* invocation. |
|
* |
|
* **Note:** If `leading` and `trailing` options are `true`, `func` is |
|
* invoked on the trailing edge of the timeout only if the debounced function |
|
* is invoked more than once during the `wait` timeout. |
|
* |
|
* If `wait` is `0` and `leading` is `false`, `func` invocation is deferred |
|
* until to the next tick, similar to `setTimeout` with a timeout of `0`. |
|
* |
|
* See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) |
|
* for details over the differences between `_.debounce` and `_.throttle`. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @since 0.1.0 |
|
* @category Function |
|
* @param {Function} func The function to debounce. |
|
* @param {number} [wait=0] The number of milliseconds to delay. |
|
* @param {Object} [options={}] The options object. |
|
* @param {boolean} [options.leading=false] |
|
* Specify invoking on the leading edge of the timeout. |
|
* @param {number} [options.maxWait] |
|
* The maximum time `func` is allowed to be delayed before it's invoked. |
|
* @param {boolean} [options.trailing=true] |
|
* Specify invoking on the trailing edge of the timeout. |
|
* @returns {Function} Returns the new debounced function. |
|
* @example |
|
* |
|
* // Avoid costly calculations while the window size is in flux. |
|
* jQuery(window).on('resize', _.debounce(calculateLayout, 150)); |
|
* |
|
* // Invoke `sendMail` when clicked, debouncing subsequent calls. |
|
* jQuery(element).on('click', _.debounce(sendMail, 300, { |
|
* 'leading': true, |
|
* 'trailing': false |
|
* })); |
|
* |
|
* // Ensure `batchLog` is invoked once after 1 second of debounced calls. |
|
* var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); |
|
* var source = new EventSource('/stream'); |
|
* jQuery(source).on('message', debounced); |
|
* |
|
* // Cancel the trailing debounced invocation. |
|
* jQuery(window).on('popstate', debounced.cancel); |
|
*/ |
|
function debounce(func, wait, options) { |
|
var lastArgs, |
|
lastThis, |
|
maxWait, |
|
result, |
|
timerId, |
|
lastCallTime, |
|
lastInvokeTime = 0, |
|
leading = false, |
|
maxing = false, |
|
trailing = true; |
|
|
|
if (typeof func != 'function') { |
|
throw new TypeError(FUNC_ERROR_TEXT); |
|
} |
|
wait = toNumber(wait) || 0; |
|
if (isObject(options)) { |
|
leading = !!options.leading; |
|
maxing = 'maxWait' in options; |
|
maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; |
|
trailing = 'trailing' in options ? !!options.trailing : trailing; |
|
} |
|
|
|
function invokeFunc(time) { |
|
var args = lastArgs, |
|
thisArg = lastThis; |
|
|
|
lastArgs = lastThis = undefined; |
|
lastInvokeTime = time; |
|
result = func.apply(thisArg, args); |
|
return result; |
|
} |
|
|
|
function leadingEdge(time) { |
|
// Reset any `maxWait` timer. |
|
lastInvokeTime = time; |
|
// Start the timer for the trailing edge. |
|
timerId = setTimeout(timerExpired, wait); |
|
// Invoke the leading edge. |
|
return leading ? invokeFunc(time) : result; |
|
} |
|
|
|
function remainingWait(time) { |
|
var timeSinceLastCall = time - lastCallTime, |
|
timeSinceLastInvoke = time - lastInvokeTime, |
|
timeWaiting = wait - timeSinceLastCall; |
|
|
|
return maxing |
|
? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) |
|
: timeWaiting; |
|
} |
|
|
|
function shouldInvoke(time) { |
|
var timeSinceLastCall = time - lastCallTime, |
|
timeSinceLastInvoke = time - lastInvokeTime; |
|
|
|
// Either this is the first call, activity has stopped and we're at the |
|
// trailing edge, the system time has gone backwards and we're treating |
|
// it as the trailing edge, or we've hit the `maxWait` limit. |
|
return (lastCallTime === undefined || (timeSinceLastCall >= wait) || |
|
(timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); |
|
} |
|
|
|
function timerExpired() { |
|
var time = now(); |
|
if (shouldInvoke(time)) { |
|
return trailingEdge(time); |
|
} |
|
// Restart the timer. |
|
timerId = setTimeout(timerExpired, remainingWait(time)); |
|
} |
|
|
|
function trailingEdge(time) { |
|
timerId = undefined; |
|
|
|
// Only invoke if we have `lastArgs` which means `func` has been |
|
// debounced at least once. |
|
if (trailing && lastArgs) { |
|
return invokeFunc(time); |
|
} |
|
lastArgs = lastThis = undefined; |
|
return result; |
|
} |
|
|
|
function cancel() { |
|
if (timerId !== undefined) { |
|
clearTimeout(timerId); |
|
} |
|
lastInvokeTime = 0; |
|
lastArgs = lastCallTime = lastThis = timerId = undefined; |
|
} |
|
|
|
function flush() { |
|
return timerId === undefined ? result : trailingEdge(now()); |
|
} |
|
|
|
function debounced() { |
|
var time = now(), |
|
isInvoking = shouldInvoke(time); |
|
|
|
lastArgs = arguments; |
|
lastThis = this; |
|
lastCallTime = time; |
|
|
|
if (isInvoking) { |
|
if (timerId === undefined) { |
|
return leadingEdge(lastCallTime); |
|
} |
|
if (maxing) { |
|
// Handle invocations in a tight loop. |
|
clearTimeout(timerId); |
|
timerId = setTimeout(timerExpired, wait); |
|
return invokeFunc(lastCallTime); |
|
} |
|
} |
|
if (timerId === undefined) { |
|
timerId = setTimeout(timerExpired, wait); |
|
} |
|
return result; |
|
} |
|
debounced.cancel = cancel; |
|
debounced.flush = flush; |
|
return debounced; |
|
} |
|
|
|
module.exports = debounce; |
|
|
|
|
|
/***/ }), |
|
/* 296 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var root = __webpack_require__(199); |
|
|
|
/** |
|
* Gets the timestamp of the number of milliseconds that have elapsed since |
|
* the Unix epoch (1 January 1970 00:00:00 UTC). |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @since 2.4.0 |
|
* @category Date |
|
* @returns {number} Returns the timestamp. |
|
* @example |
|
* |
|
* _.defer(function(stamp) { |
|
* console.log(_.now() - stamp); |
|
* }, _.now()); |
|
* // => Logs the number of milliseconds it took for the deferred invocation. |
|
*/ |
|
var now = function() { |
|
return root.Date.now(); |
|
}; |
|
|
|
module.exports = now; |
|
|
|
|
|
/***/ }), |
|
/* 297 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */ |
|
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; |
|
|
|
module.exports = freeGlobal; |
|
|
|
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(65))) |
|
|
|
/***/ }), |
|
/* 298 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var isObject = __webpack_require__(138), |
|
isSymbol = __webpack_require__(299); |
|
|
|
/** Used as references for various `Number` constants. */ |
|
var NAN = 0 / 0; |
|
|
|
/** Used to match leading and trailing whitespace. */ |
|
var reTrim = /^\s+|\s+$/g; |
|
|
|
/** Used to detect bad signed hexadecimal string values. */ |
|
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; |
|
|
|
/** Used to detect binary string values. */ |
|
var reIsBinary = /^0b[01]+$/i; |
|
|
|
/** Used to detect octal string values. */ |
|
var reIsOctal = /^0o[0-7]+$/i; |
|
|
|
/** Built-in method references without a dependency on `root`. */ |
|
var freeParseInt = parseInt; |
|
|
|
/** |
|
* Converts `value` to a number. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @since 4.0.0 |
|
* @category Lang |
|
* @param {*} value The value to process. |
|
* @returns {number} Returns the number. |
|
* @example |
|
* |
|
* _.toNumber(3.2); |
|
* // => 3.2 |
|
* |
|
* _.toNumber(Number.MIN_VALUE); |
|
* // => 5e-324 |
|
* |
|
* _.toNumber(Infinity); |
|
* // => Infinity |
|
* |
|
* _.toNumber('3.2'); |
|
* // => 3.2 |
|
*/ |
|
function toNumber(value) { |
|
if (typeof value == 'number') { |
|
return value; |
|
} |
|
if (isSymbol(value)) { |
|
return NAN; |
|
} |
|
if (isObject(value)) { |
|
var other = typeof value.valueOf == 'function' ? value.valueOf() : value; |
|
value = isObject(other) ? (other + '') : other; |
|
} |
|
if (typeof value != 'string') { |
|
return value === 0 ? value : +value; |
|
} |
|
value = value.replace(reTrim, ''); |
|
var isBinary = reIsBinary.test(value); |
|
return (isBinary || reIsOctal.test(value)) |
|
? freeParseInt(value.slice(2), isBinary ? 2 : 8) |
|
: (reIsBadHex.test(value) ? NAN : +value); |
|
} |
|
|
|
module.exports = toNumber; |
|
|
|
|
|
/***/ }), |
|
/* 299 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var baseGetTag = __webpack_require__(300), |
|
isObjectLike = __webpack_require__(303); |
|
|
|
/** `Object#toString` result references. */ |
|
var symbolTag = '[object Symbol]'; |
|
|
|
/** |
|
* Checks if `value` is classified as a `Symbol` primitive or object. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @since 4.0.0 |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is a symbol, else `false`. |
|
* @example |
|
* |
|
* _.isSymbol(Symbol.iterator); |
|
* // => true |
|
* |
|
* _.isSymbol('abc'); |
|
* // => false |
|
*/ |
|
function isSymbol(value) { |
|
return typeof value == 'symbol' || |
|
(isObjectLike(value) && baseGetTag(value) == symbolTag); |
|
} |
|
|
|
module.exports = isSymbol; |
|
|
|
|
|
/***/ }), |
|
/* 300 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var Symbol = __webpack_require__(200), |
|
getRawTag = __webpack_require__(301), |
|
objectToString = __webpack_require__(302); |
|
|
|
/** `Object#toString` result references. */ |
|
var nullTag = '[object Null]', |
|
undefinedTag = '[object Undefined]'; |
|
|
|
/** Built-in value references. */ |
|
var symToStringTag = Symbol ? Symbol.toStringTag : undefined; |
|
|
|
/** |
|
* The base implementation of `getTag` without fallbacks for buggy environments. |
|
* |
|
* @private |
|
* @param {*} value The value to query. |
|
* @returns {string} Returns the `toStringTag`. |
|
*/ |
|
function baseGetTag(value) { |
|
if (value == null) { |
|
return value === undefined ? undefinedTag : nullTag; |
|
} |
|
return (symToStringTag && symToStringTag in Object(value)) |
|
? getRawTag(value) |
|
: objectToString(value); |
|
} |
|
|
|
module.exports = baseGetTag; |
|
|
|
|
|
/***/ }), |
|
/* 301 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var Symbol = __webpack_require__(200); |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** Used to check objects for own properties. */ |
|
var hasOwnProperty = objectProto.hasOwnProperty; |
|
|
|
/** |
|
* Used to resolve the |
|
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) |
|
* of values. |
|
*/ |
|
var nativeObjectToString = objectProto.toString; |
|
|
|
/** Built-in value references. */ |
|
var symToStringTag = Symbol ? Symbol.toStringTag : undefined; |
|
|
|
/** |
|
* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. |
|
* |
|
* @private |
|
* @param {*} value The value to query. |
|
* @returns {string} Returns the raw `toStringTag`. |
|
*/ |
|
function getRawTag(value) { |
|
var isOwn = hasOwnProperty.call(value, symToStringTag), |
|
tag = value[symToStringTag]; |
|
|
|
try { |
|
value[symToStringTag] = undefined; |
|
var unmasked = true; |
|
} catch (e) {} |
|
|
|
var result = nativeObjectToString.call(value); |
|
if (unmasked) { |
|
if (isOwn) { |
|
value[symToStringTag] = tag; |
|
} else { |
|
delete value[symToStringTag]; |
|
} |
|
} |
|
return result; |
|
} |
|
|
|
module.exports = getRawTag; |
|
|
|
|
|
/***/ }), |
|
/* 302 */ |
|
/***/ (function(module, exports) { |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** |
|
* Used to resolve the |
|
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) |
|
* of values. |
|
*/ |
|
var nativeObjectToString = objectProto.toString; |
|
|
|
/** |
|
* Converts `value` to a string using `Object.prototype.toString`. |
|
* |
|
* @private |
|
* @param {*} value The value to convert. |
|
* @returns {string} Returns the converted string. |
|
*/ |
|
function objectToString(value) { |
|
return nativeObjectToString.call(value); |
|
} |
|
|
|
module.exports = objectToString; |
|
|
|
|
|
/***/ }), |
|
/* 303 */ |
|
/***/ (function(module, exports) { |
|
|
|
/** |
|
* Checks if `value` is object-like. A value is object-like if it's not `null` |
|
* and has a `typeof` result of "object". |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @since 4.0.0 |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is object-like, else `false`. |
|
* @example |
|
* |
|
* _.isObjectLike({}); |
|
* // => true |
|
* |
|
* _.isObjectLike([1, 2, 3]); |
|
* // => true |
|
* |
|
* _.isObjectLike(_.noop); |
|
* // => false |
|
* |
|
* _.isObjectLike(null); |
|
* // => false |
|
*/ |
|
function isObjectLike(value) { |
|
return value != null && typeof value == 'object'; |
|
} |
|
|
|
module.exports = isObjectLike; |
|
|
|
|
|
/***/ }), |
|
/* 304 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports["default"] = getSelectedDateOffset; |
|
var defaultModifier = function defaultModifier(day) { |
|
return day; |
|
}; |
|
|
|
function getSelectedDateOffset(fn, day) { |
|
var modifier = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultModifier; |
|
|
|
if (!fn) return day; |
|
return modifier(fn(day.clone())); |
|
} |
|
|
|
/***/ }), |
|
/* 305 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _LeftArrow = __webpack_require__(202); |
|
|
|
var _LeftArrow2 = _interopRequireDefault(_LeftArrow); |
|
|
|
var _RightArrow = __webpack_require__(201); |
|
|
|
var _RightArrow2 = _interopRequireDefault(_RightArrow); |
|
|
|
var _ChevronUp = __webpack_require__(306); |
|
|
|
var _ChevronUp2 = _interopRequireDefault(_ChevronUp); |
|
|
|
var _ChevronDown = __webpack_require__(307); |
|
|
|
var _ChevronDown2 = _interopRequireDefault(_ChevronDown); |
|
|
|
var _ScrollableOrientationShape = __webpack_require__(79); |
|
|
|
var _ScrollableOrientationShape2 = _interopRequireDefault(_ScrollableOrientationShape); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, { |
|
navPrev: _propTypes2['default'].node, |
|
navNext: _propTypes2['default'].node, |
|
orientation: _ScrollableOrientationShape2['default'], |
|
|
|
onPrevMonthClick: _propTypes2['default'].func, |
|
onNextMonthClick: _propTypes2['default'].func, |
|
|
|
// internationalization |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.DayPickerNavigationPhrases)), |
|
|
|
isRTL: _propTypes2['default'].bool |
|
})); |
|
|
|
var defaultProps = { |
|
navPrev: null, |
|
navNext: null, |
|
orientation: _constants.HORIZONTAL_ORIENTATION, |
|
|
|
onPrevMonthClick: function () { |
|
function onPrevMonthClick() {} |
|
|
|
return onPrevMonthClick; |
|
}(), |
|
onNextMonthClick: function () { |
|
function onNextMonthClick() {} |
|
|
|
return onNextMonthClick; |
|
}(), |
|
|
|
|
|
// internationalization |
|
phrases: _defaultPhrases.DayPickerNavigationPhrases, |
|
isRTL: false |
|
}; |
|
|
|
function DayPickerNavigation(_ref) { |
|
var navPrev = _ref.navPrev, |
|
navNext = _ref.navNext, |
|
onPrevMonthClick = _ref.onPrevMonthClick, |
|
onNextMonthClick = _ref.onNextMonthClick, |
|
orientation = _ref.orientation, |
|
phrases = _ref.phrases, |
|
isRTL = _ref.isRTL, |
|
styles = _ref.styles; |
|
|
|
var isHorizontal = orientation === _constants.HORIZONTAL_ORIENTATION; |
|
var isVertical = orientation !== _constants.HORIZONTAL_ORIENTATION; |
|
var isVerticalScrollable = orientation === _constants.VERTICAL_SCROLLABLE; |
|
|
|
var navPrevIcon = navPrev; |
|
var navNextIcon = navNext; |
|
var isDefaultNavPrev = false; |
|
var isDefaultNavNext = false; |
|
if (!navPrevIcon) { |
|
isDefaultNavPrev = true; |
|
var Icon = isVertical ? _ChevronUp2['default'] : _LeftArrow2['default']; |
|
if (isRTL && !isVertical) { |
|
Icon = _RightArrow2['default']; |
|
} |
|
navPrevIcon = _react2['default'].createElement(Icon, (0, _reactWithStyles.css)(isHorizontal && styles.DayPickerNavigation_svg__horizontal, isVertical && styles.DayPickerNavigation_svg__vertical)); |
|
} |
|
|
|
if (!navNextIcon) { |
|
isDefaultNavNext = true; |
|
var _Icon = isVertical ? _ChevronDown2['default'] : _RightArrow2['default']; |
|
if (isRTL && !isVertical) { |
|
_Icon = _LeftArrow2['default']; |
|
} |
|
navNextIcon = _react2['default'].createElement(_Icon, (0, _reactWithStyles.css)(isHorizontal && styles.DayPickerNavigation_svg__horizontal, isVertical && styles.DayPickerNavigation_svg__vertical)); |
|
} |
|
|
|
var isDefaultNav = isVerticalScrollable ? isDefaultNavNext : isDefaultNavNext || isDefaultNavPrev; |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
_reactWithStyles.css.apply(undefined, [styles.DayPickerNavigation, isHorizontal && styles.DayPickerNavigation__horizontal].concat(_toConsumableArray(isVertical && [styles.DayPickerNavigation__vertical, isDefaultNav && styles.DayPickerNavigation__verticalDefault]), _toConsumableArray(isVerticalScrollable && [styles.DayPickerNavigation__verticalScrollable, isDefaultNav && styles.DayPickerNavigation__verticalScrollableDefault]))), |
|
!isVerticalScrollable && _react2['default'].createElement( |
|
'div', |
|
_extends({ |
|
role: 'button', |
|
tabIndex: '0' |
|
}, _reactWithStyles.css.apply(undefined, [styles.DayPickerNavigation_button, isDefaultNavPrev && styles.DayPickerNavigation_button__default].concat(_toConsumableArray(isHorizontal && [styles.DayPickerNavigation_button__horizontal].concat(_toConsumableArray(isDefaultNavPrev && [styles.DayPickerNavigation_button__horizontalDefault, !isRTL && styles.DayPickerNavigation_leftButton__horizontalDefault, isRTL && styles.DayPickerNavigation_rightButton__horizontalDefault]))), _toConsumableArray(isVertical && [styles.DayPickerNavigation_button__vertical].concat(_toConsumableArray(isDefaultNavPrev && [styles.DayPickerNavigation_button__verticalDefault, styles.DayPickerNavigation_prevButton__verticalDefault]))))), { |
|
'aria-label': phrases.jumpToPrevMonth, |
|
onClick: onPrevMonthClick, |
|
onKeyUp: function () { |
|
function onKeyUp(e) { |
|
var key = e.key; |
|
|
|
if (key === 'Enter' || key === ' ') onPrevMonthClick(e); |
|
} |
|
|
|
return onKeyUp; |
|
}(), |
|
onMouseUp: function () { |
|
function onMouseUp(e) { |
|
e.currentTarget.blur(); |
|
} |
|
|
|
return onMouseUp; |
|
}() |
|
}), |
|
navPrevIcon |
|
), |
|
_react2['default'].createElement( |
|
'div', |
|
_extends({ |
|
role: 'button', |
|
tabIndex: '0' |
|
}, _reactWithStyles.css.apply(undefined, [styles.DayPickerNavigation_button, isDefaultNavNext && styles.DayPickerNavigation_button__default].concat(_toConsumableArray(isHorizontal && [styles.DayPickerNavigation_button__horizontal].concat(_toConsumableArray(isDefaultNavNext && [styles.DayPickerNavigation_button__horizontalDefault, isRTL && styles.DayPickerNavigation_leftButton__horizontalDefault, !isRTL && styles.DayPickerNavigation_rightButton__horizontalDefault]))), _toConsumableArray(isVertical && [styles.DayPickerNavigation_button__vertical, styles.DayPickerNavigation_nextButton__vertical].concat(_toConsumableArray(isDefaultNavNext && [styles.DayPickerNavigation_button__verticalDefault, styles.DayPickerNavigation_nextButton__verticalDefault, isVerticalScrollable && styles.DayPickerNavigation_nextButton__verticalScrollableDefault]))))), { |
|
'aria-label': phrases.jumpToNextMonth, |
|
onClick: onNextMonthClick, |
|
onKeyUp: function () { |
|
function onKeyUp(e) { |
|
var key = e.key; |
|
|
|
if (key === 'Enter' || key === ' ') onNextMonthClick(e); |
|
} |
|
|
|
return onKeyUp; |
|
}(), |
|
onMouseUp: function () { |
|
function onMouseUp(e) { |
|
e.currentTarget.blur(); |
|
} |
|
|
|
return onMouseUp; |
|
}() |
|
}), |
|
navNextIcon |
|
) |
|
); |
|
} |
|
|
|
DayPickerNavigation.propTypes = propTypes; |
|
DayPickerNavigation.defaultProps = defaultProps; |
|
|
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref2) { |
|
var _ref2$reactDates = _ref2.reactDates, |
|
color = _ref2$reactDates.color, |
|
zIndex = _ref2$reactDates.zIndex; |
|
return { |
|
DayPickerNavigation: { |
|
position: 'relative', |
|
zIndex: zIndex + 2 |
|
}, |
|
|
|
DayPickerNavigation__horizontal: { |
|
height: 0 |
|
}, |
|
|
|
DayPickerNavigation__vertical: {}, |
|
DayPickerNavigation__verticalScrollable: {}, |
|
|
|
DayPickerNavigation__verticalDefault: { |
|
position: 'absolute', |
|
width: '100%', |
|
height: 52, |
|
bottom: 0, |
|
left: 0 |
|
}, |
|
|
|
DayPickerNavigation__verticalScrollableDefault: { |
|
position: 'relative' |
|
}, |
|
|
|
DayPickerNavigation_button: { |
|
cursor: 'pointer', |
|
userSelect: 'none', |
|
border: 0, |
|
padding: 0, |
|
margin: 0 |
|
}, |
|
|
|
DayPickerNavigation_button__default: { |
|
border: '1px solid ' + String(color.core.borderLight), |
|
backgroundColor: color.background, |
|
color: color.placeholderText, |
|
|
|
':focus': { |
|
border: '1px solid ' + String(color.core.borderMedium) |
|
}, |
|
|
|
':hover': { |
|
border: '1px solid ' + String(color.core.borderMedium) |
|
}, |
|
|
|
':active': { |
|
background: color.backgroundDark |
|
} |
|
}, |
|
|
|
DayPickerNavigation_button__horizontal: {}, |
|
|
|
DayPickerNavigation_button__horizontalDefault: { |
|
position: 'absolute', |
|
top: 18, |
|
lineHeight: 0.78, |
|
borderRadius: 3, |
|
padding: '6px 9px' |
|
}, |
|
|
|
DayPickerNavigation_leftButton__horizontalDefault: { |
|
left: 22 |
|
}, |
|
|
|
DayPickerNavigation_rightButton__horizontalDefault: { |
|
right: 22 |
|
}, |
|
|
|
DayPickerNavigation_button__vertical: {}, |
|
|
|
DayPickerNavigation_button__verticalDefault: { |
|
padding: 5, |
|
background: color.background, |
|
boxShadow: '0 0 5px 2px rgba(0, 0, 0, 0.1)', |
|
position: 'relative', |
|
display: 'inline-block', |
|
height: '100%', |
|
width: '50%' |
|
}, |
|
|
|
DayPickerNavigation_prevButton__verticalDefault: {}, |
|
|
|
DayPickerNavigation_nextButton__verticalDefault: { |
|
borderLeft: 0 |
|
}, |
|
|
|
DayPickerNavigation_nextButton__verticalScrollableDefault: { |
|
width: '100%' |
|
}, |
|
|
|
DayPickerNavigation_svg__horizontal: { |
|
height: 19, |
|
width: 19, |
|
fill: color.core.grayLight, |
|
display: 'block' |
|
}, |
|
|
|
DayPickerNavigation_svg__vertical: { |
|
height: 42, |
|
width: 42, |
|
fill: color.text, |
|
display: 'block' |
|
} |
|
}; |
|
})(DayPickerNavigation); |
|
|
|
/***/ }), |
|
/* 306 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
var ChevronUp = function () { |
|
function ChevronUp(props) { |
|
return _react2['default'].createElement( |
|
'svg', |
|
props, |
|
_react2['default'].createElement('path', { |
|
d: 'M32.1 712.6l453.2-452.2c11-11 21-11 32 0l453.2 452.2c4 5 6 10 6 16 0 13-10 23-22 23-7 0-12-2-16-7L501.3 308.5 64.1 744.7c-4 5-9 7-15 7-7 0-12-2-17-7-9-11-9-21 0-32.1z' |
|
}) |
|
); |
|
} |
|
|
|
return ChevronUp; |
|
}(); |
|
|
|
ChevronUp.defaultProps = { |
|
viewBox: '0 0 1000 1000' |
|
}; |
|
exports['default'] = ChevronUp; |
|
|
|
/***/ }), |
|
/* 307 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
var ChevronDown = function () { |
|
function ChevronDown(props) { |
|
return _react2['default'].createElement( |
|
'svg', |
|
props, |
|
_react2['default'].createElement('path', { |
|
d: 'M967.5 288.5L514.3 740.7c-11 11-21 11-32 0L29.1 288.5c-4-5-6-11-6-16 0-13 10-23 23-23 6 0 11 2 15 7l437.2 436.2 437.2-436.2c4-5 9-7 16-7 6 0 11 2 16 7 9 10.9 9 21 0 32z' |
|
}) |
|
); |
|
} |
|
|
|
return ChevronDown; |
|
}(); |
|
|
|
ChevronDown.defaultProps = { |
|
viewBox: '0 0 1000 1000' |
|
}; |
|
exports['default'] = ChevronDown; |
|
|
|
/***/ }), |
|
/* 308 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.BOTTOM_RIGHT = exports.TOP_RIGHT = exports.TOP_LEFT = undefined; |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _getPhrasePropTypes = __webpack_require__(54); |
|
|
|
var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes); |
|
|
|
var _KeyboardShortcutRow = __webpack_require__(309); |
|
|
|
var _KeyboardShortcutRow2 = _interopRequireDefault(_KeyboardShortcutRow); |
|
|
|
var _CloseButton = __webpack_require__(96); |
|
|
|
var _CloseButton2 = _interopRequireDefault(_CloseButton); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
var TOP_LEFT = exports.TOP_LEFT = 'top-left'; |
|
var TOP_RIGHT = exports.TOP_RIGHT = 'top-right'; |
|
var BOTTOM_RIGHT = exports.BOTTOM_RIGHT = 'bottom-right'; |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, { |
|
block: _propTypes2['default'].bool, |
|
buttonLocation: _propTypes2['default'].oneOf([TOP_LEFT, TOP_RIGHT, BOTTOM_RIGHT]), |
|
showKeyboardShortcutsPanel: _propTypes2['default'].bool, |
|
openKeyboardShortcutsPanel: _propTypes2['default'].func, |
|
closeKeyboardShortcutsPanel: _propTypes2['default'].func, |
|
phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.DayPickerKeyboardShortcutsPhrases)) |
|
})); |
|
|
|
var defaultProps = { |
|
block: false, |
|
buttonLocation: BOTTOM_RIGHT, |
|
showKeyboardShortcutsPanel: false, |
|
openKeyboardShortcutsPanel: function () { |
|
function openKeyboardShortcutsPanel() {} |
|
|
|
return openKeyboardShortcutsPanel; |
|
}(), |
|
closeKeyboardShortcutsPanel: function () { |
|
function closeKeyboardShortcutsPanel() {} |
|
|
|
return closeKeyboardShortcutsPanel; |
|
}(), |
|
|
|
phrases: _defaultPhrases.DayPickerKeyboardShortcutsPhrases |
|
}; |
|
|
|
function getKeyboardShortcuts(phrases) { |
|
return [{ |
|
unicode: '↵', |
|
label: phrases.enterKey, |
|
action: phrases.selectFocusedDate |
|
}, { |
|
unicode: '←/→', |
|
label: phrases.leftArrowRightArrow, |
|
action: phrases.moveFocusByOneDay |
|
}, { |
|
unicode: '↑/↓', |
|
label: phrases.upArrowDownArrow, |
|
action: phrases.moveFocusByOneWeek |
|
}, { |
|
unicode: 'PgUp/PgDn', |
|
label: phrases.pageUpPageDown, |
|
action: phrases.moveFocusByOneMonth |
|
}, { |
|
unicode: 'Home/End', |
|
label: phrases.homeEnd, |
|
action: phrases.moveFocustoStartAndEndOfWeek |
|
}, { |
|
unicode: 'Esc', |
|
label: phrases.escape, |
|
action: phrases.returnFocusToInput |
|
}, { |
|
unicode: '?', |
|
label: phrases.questionMark, |
|
action: phrases.openThisPanel |
|
}]; |
|
} |
|
|
|
var DayPickerKeyboardShortcuts = function (_React$Component) { |
|
_inherits(DayPickerKeyboardShortcuts, _React$Component); |
|
|
|
function DayPickerKeyboardShortcuts() { |
|
var _ref; |
|
|
|
_classCallCheck(this, DayPickerKeyboardShortcuts); |
|
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { |
|
args[_key] = arguments[_key]; |
|
} |
|
|
|
var _this = _possibleConstructorReturn(this, (_ref = DayPickerKeyboardShortcuts.__proto__ || Object.getPrototypeOf(DayPickerKeyboardShortcuts)).call.apply(_ref, [this].concat(args))); |
|
|
|
var phrases = _this.props.phrases; |
|
|
|
_this.keyboardShortcuts = getKeyboardShortcuts(phrases); |
|
|
|
_this.onShowKeyboardShortcutsButtonClick = _this.onShowKeyboardShortcutsButtonClick.bind(_this); |
|
_this.setShowKeyboardShortcutsButtonRef = _this.setShowKeyboardShortcutsButtonRef.bind(_this); |
|
_this.setHideKeyboardShortcutsButtonRef = _this.setHideKeyboardShortcutsButtonRef.bind(_this); |
|
_this.handleFocus = _this.handleFocus.bind(_this); |
|
_this.onKeyDown = _this.onKeyDown.bind(_this); |
|
return _this; |
|
} |
|
|
|
_createClass(DayPickerKeyboardShortcuts, [{ |
|
key: 'componentWillReceiveProps', |
|
value: function () { |
|
function componentWillReceiveProps(nextProps) { |
|
var phrases = this.props.phrases; |
|
|
|
if (nextProps.phrases !== phrases) { |
|
this.keyboardShortcuts = getKeyboardShortcuts(nextProps.phrases); |
|
} |
|
} |
|
|
|
return componentWillReceiveProps; |
|
}() |
|
}, { |
|
key: 'componentDidUpdate', |
|
value: function () { |
|
function componentDidUpdate() { |
|
this.handleFocus(); |
|
} |
|
|
|
return componentDidUpdate; |
|
}() |
|
}, { |
|
key: 'onKeyDown', |
|
value: function () { |
|
function onKeyDown(e) { |
|
e.stopPropagation(); |
|
|
|
var closeKeyboardShortcutsPanel = this.props.closeKeyboardShortcutsPanel; |
|
// Because the close button is the only focusable element inside of the panel, this |
|
// amounts to a very basic focus trap. The user can exit the panel by "pressing" the |
|
// close button or hitting escape |
|
|
|
switch (e.key) { |
|
case 'Enter': |
|
case ' ': |
|
case 'Spacebar': // for older browsers |
|
case 'Escape': |
|
closeKeyboardShortcutsPanel(); |
|
break; |
|
|
|
// do nothing - this allows the up and down arrows continue their |
|
// default behavior of scrolling the content of the Keyboard Shortcuts Panel |
|
// which is needed when only a single month is shown for instance. |
|
case 'ArrowUp': |
|
case 'ArrowDown': |
|
break; |
|
|
|
// completely block the rest of the keys that have functionality outside of this panel |
|
case 'Tab': |
|
case 'Home': |
|
case 'End': |
|
case 'PageUp': |
|
case 'PageDown': |
|
case 'ArrowLeft': |
|
case 'ArrowRight': |
|
e.preventDefault(); |
|
break; |
|
|
|
default: |
|
break; |
|
} |
|
} |
|
|
|
return onKeyDown; |
|
}() |
|
}, { |
|
key: 'onShowKeyboardShortcutsButtonClick', |
|
value: function () { |
|
function onShowKeyboardShortcutsButtonClick() { |
|
var _this2 = this; |
|
|
|
var openKeyboardShortcutsPanel = this.props.openKeyboardShortcutsPanel; |
|
|
|
// we want to return focus to this button after closing the keyboard shortcuts panel |
|
|
|
openKeyboardShortcutsPanel(function () { |
|
_this2.showKeyboardShortcutsButton.focus(); |
|
}); |
|
} |
|
|
|
return onShowKeyboardShortcutsButtonClick; |
|
}() |
|
}, { |
|
key: 'setShowKeyboardShortcutsButtonRef', |
|
value: function () { |
|
function setShowKeyboardShortcutsButtonRef(ref) { |
|
this.showKeyboardShortcutsButton = ref; |
|
} |
|
|
|
return setShowKeyboardShortcutsButtonRef; |
|
}() |
|
}, { |
|
key: 'setHideKeyboardShortcutsButtonRef', |
|
value: function () { |
|
function setHideKeyboardShortcutsButtonRef(ref) { |
|
this.hideKeyboardShortcutsButton = ref; |
|
} |
|
|
|
return setHideKeyboardShortcutsButtonRef; |
|
}() |
|
}, { |
|
key: 'handleFocus', |
|
value: function () { |
|
function handleFocus() { |
|
if (this.hideKeyboardShortcutsButton) { |
|
// automatically move focus into the dialog by moving |
|
// to the only interactive element, the hide button |
|
this.hideKeyboardShortcutsButton.focus(); |
|
} |
|
} |
|
|
|
return handleFocus; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _this3 = this; |
|
|
|
var _props = this.props, |
|
block = _props.block, |
|
buttonLocation = _props.buttonLocation, |
|
showKeyboardShortcutsPanel = _props.showKeyboardShortcutsPanel, |
|
closeKeyboardShortcutsPanel = _props.closeKeyboardShortcutsPanel, |
|
styles = _props.styles, |
|
phrases = _props.phrases; |
|
|
|
|
|
var toggleButtonText = showKeyboardShortcutsPanel ? phrases.hideKeyboardShortcutsPanel : phrases.showKeyboardShortcutsPanel; |
|
|
|
var bottomRight = buttonLocation === BOTTOM_RIGHT; |
|
var topRight = buttonLocation === TOP_RIGHT; |
|
var topLeft = buttonLocation === TOP_LEFT; |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
null, |
|
_react2['default'].createElement( |
|
'button', |
|
_extends({ |
|
ref: this.setShowKeyboardShortcutsButtonRef |
|
}, (0, _reactWithStyles.css)(styles.DayPickerKeyboardShortcuts_buttonReset, styles.DayPickerKeyboardShortcuts_show, bottomRight && styles.DayPickerKeyboardShortcuts_show__bottomRight, topRight && styles.DayPickerKeyboardShortcuts_show__topRight, topLeft && styles.DayPickerKeyboardShortcuts_show__topLeft), { |
|
type: 'button', |
|
'aria-label': toggleButtonText, |
|
onClick: this.onShowKeyboardShortcutsButtonClick, |
|
onKeyDown: function () { |
|
function onKeyDown(e) { |
|
if (e.key === 'Enter') { |
|
e.preventDefault(); |
|
} else if (e.key === 'Space') { |
|
_this3.onShowKeyboardShortcutsButtonClick(e); |
|
} |
|
} |
|
|
|
return onKeyDown; |
|
}(), |
|
onMouseUp: function () { |
|
function onMouseUp(e) { |
|
e.currentTarget.blur(); |
|
} |
|
|
|
return onMouseUp; |
|
}() |
|
}), |
|
_react2['default'].createElement( |
|
'span', |
|
(0, _reactWithStyles.css)(styles.DayPickerKeyboardShortcuts_showSpan, bottomRight && styles.DayPickerKeyboardShortcuts_showSpan__bottomRight, topRight && styles.DayPickerKeyboardShortcuts_showSpan__topRight, topLeft && styles.DayPickerKeyboardShortcuts_showSpan__topLeft), |
|
'?' |
|
) |
|
), |
|
showKeyboardShortcutsPanel && _react2['default'].createElement( |
|
'div', |
|
_extends({}, (0, _reactWithStyles.css)(styles.DayPickerKeyboardShortcuts_panel), { |
|
role: 'dialog', |
|
'aria-labelledby': 'DayPickerKeyboardShortcuts_title', |
|
'aria-describedby': 'DayPickerKeyboardShortcuts_description' |
|
}), |
|
_react2['default'].createElement( |
|
'div', |
|
_extends({}, (0, _reactWithStyles.css)(styles.DayPickerKeyboardShortcuts_title), { |
|
id: 'DayPickerKeyboardShortcuts_title' |
|
}), |
|
phrases.keyboardShortcuts |
|
), |
|
_react2['default'].createElement( |
|
'button', |
|
_extends({ |
|
ref: this.setHideKeyboardShortcutsButtonRef |
|
}, (0, _reactWithStyles.css)(styles.DayPickerKeyboardShortcuts_buttonReset, styles.DayPickerKeyboardShortcuts_close), { |
|
type: 'button', |
|
tabIndex: '0', |
|
'aria-label': phrases.hideKeyboardShortcutsPanel, |
|
onClick: closeKeyboardShortcutsPanel, |
|
onKeyDown: this.onKeyDown |
|
}), |
|
_react2['default'].createElement(_CloseButton2['default'], (0, _reactWithStyles.css)(styles.DayPickerKeyboardShortcuts_closeSvg)) |
|
), |
|
_react2['default'].createElement( |
|
'ul', |
|
_extends({}, (0, _reactWithStyles.css)(styles.DayPickerKeyboardShortcuts_list), { |
|
id: 'DayPickerKeyboardShortcuts_description' |
|
}), |
|
this.keyboardShortcuts.map(function (_ref2) { |
|
var unicode = _ref2.unicode, |
|
label = _ref2.label, |
|
action = _ref2.action; |
|
return _react2['default'].createElement(_KeyboardShortcutRow2['default'], { |
|
key: label, |
|
unicode: unicode, |
|
label: label, |
|
action: action, |
|
block: block |
|
}); |
|
}) |
|
) |
|
) |
|
); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return DayPickerKeyboardShortcuts; |
|
}(_react2['default'].Component); |
|
|
|
DayPickerKeyboardShortcuts.propTypes = propTypes; |
|
DayPickerKeyboardShortcuts.defaultProps = defaultProps; |
|
|
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref3) { |
|
var _ref3$reactDates = _ref3.reactDates, |
|
color = _ref3$reactDates.color, |
|
font = _ref3$reactDates.font, |
|
zIndex = _ref3$reactDates.zIndex; |
|
return { |
|
DayPickerKeyboardShortcuts_buttonReset: { |
|
background: 'none', |
|
border: 0, |
|
borderRadius: 0, |
|
color: 'inherit', |
|
font: 'inherit', |
|
lineHeight: 'normal', |
|
overflow: 'visible', |
|
padding: 0, |
|
cursor: 'pointer', |
|
fontSize: font.size, |
|
|
|
':active': { |
|
outline: 'none' |
|
} |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_show: { |
|
width: 22, |
|
position: 'absolute', |
|
zIndex: zIndex + 2 |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_show__bottomRight: { |
|
borderTop: '26px solid transparent', |
|
borderRight: '33px solid ' + String(color.core.primary), |
|
bottom: 0, |
|
right: 0, |
|
|
|
':hover': { |
|
borderRight: '33px solid ' + String(color.core.primary_dark) |
|
} |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_show__topRight: { |
|
borderBottom: '26px solid transparent', |
|
borderRight: '33px solid ' + String(color.core.primary), |
|
top: 0, |
|
right: 0, |
|
|
|
':hover': { |
|
borderRight: '33px solid ' + String(color.core.primary_dark) |
|
} |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_show__topLeft: { |
|
borderBottom: '26px solid transparent', |
|
borderLeft: '33px solid ' + String(color.core.primary), |
|
top: 0, |
|
left: 0, |
|
|
|
':hover': { |
|
borderLeft: '33px solid ' + String(color.core.primary_dark) |
|
} |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_showSpan: { |
|
color: color.core.white, |
|
position: 'absolute' |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_showSpan__bottomRight: { |
|
bottom: 0, |
|
right: -28 |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_showSpan__topRight: { |
|
top: 1, |
|
right: -28 |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_showSpan__topLeft: { |
|
top: 1, |
|
left: -28 |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_panel: { |
|
overflow: 'auto', |
|
background: color.background, |
|
border: '1px solid ' + String(color.core.border), |
|
borderRadius: 2, |
|
position: 'absolute', |
|
top: 0, |
|
bottom: 0, |
|
right: 0, |
|
left: 0, |
|
zIndex: zIndex + 2, |
|
padding: 22, |
|
margin: 33 |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_title: { |
|
fontSize: 16, |
|
fontWeight: 'bold', |
|
margin: 0 |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_list: { |
|
listStyle: 'none', |
|
padding: 0, |
|
fontSize: font.size |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_close: { |
|
position: 'absolute', |
|
right: 22, |
|
top: 22, |
|
zIndex: zIndex + 2, |
|
|
|
':active': { |
|
outline: 'none' |
|
} |
|
}, |
|
|
|
DayPickerKeyboardShortcuts_closeSvg: { |
|
height: 15, |
|
width: 15, |
|
fill: color.core.grayLighter, |
|
|
|
':hover': { |
|
fill: color.core.grayLight |
|
}, |
|
|
|
':focus': { |
|
fill: color.core.grayLight |
|
} |
|
} |
|
}; |
|
})(DayPickerKeyboardShortcuts); |
|
|
|
/***/ }), |
|
/* 309 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _propTypes = __webpack_require__(33); |
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, { |
|
unicode: _propTypes2['default'].string.isRequired, |
|
label: _propTypes2['default'].string.isRequired, |
|
action: _propTypes2['default'].string.isRequired, |
|
block: _propTypes2['default'].bool |
|
})); |
|
|
|
var defaultProps = { |
|
block: false |
|
}; |
|
|
|
function KeyboardShortcutRow(_ref) { |
|
var unicode = _ref.unicode, |
|
label = _ref.label, |
|
action = _ref.action, |
|
block = _ref.block, |
|
styles = _ref.styles; |
|
|
|
return _react2['default'].createElement( |
|
'li', |
|
(0, _reactWithStyles.css)(styles.KeyboardShortcutRow, block && styles.KeyboardShortcutRow__block), |
|
_react2['default'].createElement( |
|
'div', |
|
(0, _reactWithStyles.css)(styles.KeyboardShortcutRow_keyContainer, block && styles.KeyboardShortcutRow_keyContainer__block), |
|
_react2['default'].createElement( |
|
'span', |
|
_extends({}, (0, _reactWithStyles.css)(styles.KeyboardShortcutRow_key), { |
|
role: 'img', |
|
'aria-label': String(label) + ',' // add comma so screen readers will pause before reading action |
|
}), |
|
unicode |
|
) |
|
), |
|
_react2['default'].createElement( |
|
'div', |
|
(0, _reactWithStyles.css)(styles.KeyboardShortcutRow_action), |
|
action |
|
) |
|
); |
|
} |
|
|
|
KeyboardShortcutRow.propTypes = propTypes; |
|
KeyboardShortcutRow.defaultProps = defaultProps; |
|
|
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref2) { |
|
var color = _ref2.reactDates.color; |
|
return { |
|
KeyboardShortcutRow: { |
|
listStyle: 'none', |
|
margin: '6px 0' |
|
}, |
|
|
|
KeyboardShortcutRow__block: { |
|
marginBottom: 16 |
|
}, |
|
|
|
KeyboardShortcutRow_keyContainer: { |
|
display: 'inline-block', |
|
whiteSpace: 'nowrap', |
|
textAlign: 'right', |
|
marginRight: 6 |
|
}, |
|
|
|
KeyboardShortcutRow_keyContainer__block: { |
|
textAlign: 'left', |
|
display: 'inline' |
|
}, |
|
|
|
KeyboardShortcutRow_key: { |
|
fontFamily: 'monospace', |
|
fontSize: 12, |
|
textTransform: 'uppercase', |
|
background: color.core.grayLightest, |
|
padding: '2px 6px' |
|
}, |
|
|
|
KeyboardShortcutRow_action: { |
|
display: 'inline', |
|
wordBreak: 'break-word', |
|
marginLeft: 8 |
|
} |
|
}; |
|
})(KeyboardShortcutRow); |
|
|
|
/***/ }), |
|
/* 310 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = getNumberOfCalendarMonthWeeks; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function getBlankDaysBeforeFirstDay(firstDayOfMonth, firstDayOfWeek) { |
|
var weekDayDiff = firstDayOfMonth.day() - firstDayOfWeek; |
|
return (weekDayDiff + 7) % 7; |
|
} |
|
|
|
function getNumberOfCalendarMonthWeeks(month) { |
|
var firstDayOfWeek = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _moment2['default'].localeData().firstDayOfWeek(); |
|
|
|
var firstDayOfMonth = month.clone().startOf('month'); |
|
var numBlankDays = getBlankDaysBeforeFirstDay(firstDayOfMonth, firstDayOfWeek); |
|
return Math.ceil((numBlankDays + month.daysInMonth()) / 7); |
|
} |
|
|
|
/***/ }), |
|
/* 311 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = getActiveElement; |
|
function getActiveElement() { |
|
return typeof document !== 'undefined' && document.activeElement; |
|
} |
|
|
|
/***/ }), |
|
/* 312 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.PureSingleDatePicker = undefined; |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
var _object = __webpack_require__(49); |
|
|
|
var _object2 = _interopRequireDefault(_object); |
|
|
|
var _react = __webpack_require__(28); |
|
|
|
var _react2 = _interopRequireDefault(_react); |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _reactWithStyles = __webpack_require__(56); |
|
|
|
var _reactPortal = __webpack_require__(216); |
|
|
|
var _airbnbPropTypes = __webpack_require__(46); |
|
|
|
var _consolidatedEvents = __webpack_require__(105); |
|
|
|
var _isTouchDevice = __webpack_require__(80); |
|
|
|
var _isTouchDevice2 = _interopRequireDefault(_isTouchDevice); |
|
|
|
var _reactOutsideClickHandler = __webpack_require__(134); |
|
|
|
var _reactOutsideClickHandler2 = _interopRequireDefault(_reactOutsideClickHandler); |
|
|
|
var _SingleDatePickerShape = __webpack_require__(208); |
|
|
|
var _SingleDatePickerShape2 = _interopRequireDefault(_SingleDatePickerShape); |
|
|
|
var _defaultPhrases = __webpack_require__(50); |
|
|
|
var _toMomentObject = __webpack_require__(78); |
|
|
|
var _toMomentObject2 = _interopRequireDefault(_toMomentObject); |
|
|
|
var _toLocalizedDateString = __webpack_require__(139); |
|
|
|
var _toLocalizedDateString2 = _interopRequireDefault(_toLocalizedDateString); |
|
|
|
var _getResponsiveContainerStyles = __webpack_require__(192); |
|
|
|
var _getResponsiveContainerStyles2 = _interopRequireDefault(_getResponsiveContainerStyles); |
|
|
|
var _getDetachedContainerStyles = __webpack_require__(193); |
|
|
|
var _getDetachedContainerStyles2 = _interopRequireDefault(_getDetachedContainerStyles); |
|
|
|
var _getInputHeight = __webpack_require__(137); |
|
|
|
var _getInputHeight2 = _interopRequireDefault(_getInputHeight); |
|
|
|
var _isInclusivelyAfterDay = __webpack_require__(94); |
|
|
|
var _isInclusivelyAfterDay2 = _interopRequireDefault(_isInclusivelyAfterDay); |
|
|
|
var _disableScroll2 = __webpack_require__(194); |
|
|
|
var _disableScroll3 = _interopRequireDefault(_disableScroll2); |
|
|
|
var _SingleDatePickerInput = __webpack_require__(209); |
|
|
|
var _SingleDatePickerInput2 = _interopRequireDefault(_SingleDatePickerInput); |
|
|
|
var _DayPickerSingleDateController = __webpack_require__(207); |
|
|
|
var _DayPickerSingleDateController2 = _interopRequireDefault(_DayPickerSingleDateController); |
|
|
|
var _CloseButton = __webpack_require__(96); |
|
|
|
var _CloseButton2 = _interopRequireDefault(_CloseButton); |
|
|
|
var _constants = __webpack_require__(40); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } |
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
|
|
|
var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, _SingleDatePickerShape2['default'])); |
|
|
|
var defaultProps = { |
|
// required props for a functional interactive SingleDatePicker |
|
date: null, |
|
focused: false, |
|
|
|
// input related props |
|
id: 'date', |
|
placeholder: 'Date', |
|
disabled: false, |
|
required: false, |
|
readOnly: false, |
|
screenReaderInputMessage: '', |
|
showClearDate: false, |
|
showDefaultInputIcon: false, |
|
inputIconPosition: _constants.ICON_BEFORE_POSITION, |
|
customInputIcon: null, |
|
customCloseIcon: null, |
|
noBorder: false, |
|
block: false, |
|
small: false, |
|
regular: false, |
|
verticalSpacing: _constants.DEFAULT_VERTICAL_SPACING, |
|
keepFocusOnInput: false, |
|
|
|
// calendar presentation and interaction related props |
|
orientation: _constants.HORIZONTAL_ORIENTATION, |
|
anchorDirection: _constants.ANCHOR_LEFT, |
|
openDirection: _constants.OPEN_DOWN, |
|
horizontalMargin: 0, |
|
withPortal: false, |
|
withFullScreenPortal: false, |
|
appendToBody: false, |
|
disableScroll: false, |
|
initialVisibleMonth: null, |
|
firstDayOfWeek: null, |
|
numberOfMonths: 2, |
|
keepOpenOnDateSelect: false, |
|
reopenPickerOnClearDate: false, |
|
renderCalendarInfo: null, |
|
calendarInfoPosition: _constants.INFO_POSITION_BOTTOM, |
|
hideKeyboardShortcutsPanel: false, |
|
daySize: _constants.DAY_SIZE, |
|
isRTL: false, |
|
verticalHeight: null, |
|
transitionDuration: undefined, |
|
horizontalMonthPadding: 13, |
|
|
|
// navigation related props |
|
navPrev: null, |
|
navNext: null, |
|
|
|
onPrevMonthClick: function () { |
|
function onPrevMonthClick() {} |
|
|
|
return onPrevMonthClick; |
|
}(), |
|
onNextMonthClick: function () { |
|
function onNextMonthClick() {} |
|
|
|
return onNextMonthClick; |
|
}(), |
|
onClose: function () { |
|
function onClose() {} |
|
|
|
return onClose; |
|
}(), |
|
|
|
|
|
// month presentation and interaction related props |
|
renderMonthText: null, |
|
|
|
// day presentation and interaction related props |
|
renderCalendarDay: undefined, |
|
renderDayContents: null, |
|
renderMonthElement: null, |
|
enableOutsideDays: false, |
|
isDayBlocked: function () { |
|
function isDayBlocked() { |
|
return false; |
|
} |
|
|
|
return isDayBlocked; |
|
}(), |
|
isOutsideRange: function () { |
|
function isOutsideRange(day) { |
|
return !(0, _isInclusivelyAfterDay2['default'])(day, (0, _moment2['default'])()); |
|
} |
|
|
|
return isOutsideRange; |
|
}(), |
|
isDayHighlighted: function () { |
|
function isDayHighlighted() {} |
|
|
|
return isDayHighlighted; |
|
}(), |
|
|
|
// internationalization props |
|
displayFormat: function () { |
|
function displayFormat() { |
|
return _moment2['default'].localeData().longDateFormat('L'); |
|
} |
|
|
|
return displayFormat; |
|
}(), |
|
monthFormat: 'MMMM YYYY', |
|
weekDayFormat: 'dd', |
|
phrases: _defaultPhrases.SingleDatePickerPhrases, |
|
dayAriaLabelFormat: undefined |
|
}; |
|
|
|
var SingleDatePicker = function (_React$Component) { |
|
_inherits(SingleDatePicker, _React$Component); |
|
|
|
function SingleDatePicker(props) { |
|
_classCallCheck(this, SingleDatePicker); |
|
|
|
var _this = _possibleConstructorReturn(this, (SingleDatePicker.__proto__ || Object.getPrototypeOf(SingleDatePicker)).call(this, props)); |
|
|
|
_this.isTouchDevice = false; |
|
|
|
_this.state = { |
|
dayPickerContainerStyles: {}, |
|
isDayPickerFocused: false, |
|
isInputFocused: false, |
|
showKeyboardShortcuts: false |
|
}; |
|
|
|
_this.onDayPickerFocus = _this.onDayPickerFocus.bind(_this); |
|
_this.onDayPickerBlur = _this.onDayPickerBlur.bind(_this); |
|
_this.showKeyboardShortcutsPanel = _this.showKeyboardShortcutsPanel.bind(_this); |
|
|
|
_this.onChange = _this.onChange.bind(_this); |
|
_this.onFocus = _this.onFocus.bind(_this); |
|
_this.onClearFocus = _this.onClearFocus.bind(_this); |
|
_this.clearDate = _this.clearDate.bind(_this); |
|
|
|
_this.responsivizePickerPosition = _this.responsivizePickerPosition.bind(_this); |
|
_this.disableScroll = _this.disableScroll.bind(_this); |
|
|
|
_this.setDayPickerContainerRef = _this.setDayPickerContainerRef.bind(_this); |
|
_this.setContainerRef = _this.setContainerRef.bind(_this); |
|
return _this; |
|
} |
|
|
|
/* istanbul ignore next */ |
|
|
|
|
|
_createClass(SingleDatePicker, [{ |
|
key: 'componentDidMount', |
|
value: function () { |
|
function componentDidMount() { |
|
this.removeEventListener = (0, _consolidatedEvents.addEventListener)(window, 'resize', this.responsivizePickerPosition, { passive: true }); |
|
this.responsivizePickerPosition(); |
|
this.disableScroll(); |
|
|
|
var focused = this.props.focused; |
|
|
|
|
|
if (focused) { |
|
this.setState({ |
|
isInputFocused: true |
|
}); |
|
} |
|
|
|
this.isTouchDevice = (0, _isTouchDevice2['default'])(); |
|
} |
|
|
|
return componentDidMount; |
|
}() |
|
}, { |
|
key: 'componentDidUpdate', |
|
value: function () { |
|
function componentDidUpdate(prevProps) { |
|
var focused = this.props.focused; |
|
|
|
if (!prevProps.focused && focused) { |
|
this.responsivizePickerPosition(); |
|
this.disableScroll(); |
|
} else if (prevProps.focused && !focused) { |
|
if (this.enableScroll) this.enableScroll(); |
|
} |
|
} |
|
|
|
return componentDidUpdate; |
|
}() |
|
|
|
/* istanbul ignore next */ |
|
|
|
}, { |
|
key: 'componentWillUnmount', |
|
value: function () { |
|
function componentWillUnmount() { |
|
if (this.removeEventListener) this.removeEventListener(); |
|
if (this.enableScroll) this.enableScroll(); |
|
} |
|
|
|
return componentWillUnmount; |
|
}() |
|
}, { |
|
key: 'onChange', |
|
value: function () { |
|
function onChange(dateString) { |
|
var _props = this.props, |
|
isOutsideRange = _props.isOutsideRange, |
|
keepOpenOnDateSelect = _props.keepOpenOnDateSelect, |
|
onDateChange = _props.onDateChange, |
|
onFocusChange = _props.onFocusChange, |
|
onClose = _props.onClose; |
|
|
|
var newDate = (0, _toMomentObject2['default'])(dateString, this.getDisplayFormat()); |
|
|
|
var isValid = newDate && !isOutsideRange(newDate); |
|
if (isValid) { |
|
onDateChange(newDate); |
|
if (!keepOpenOnDateSelect) { |
|
onFocusChange({ focused: false }); |
|
onClose({ date: newDate }); |
|
} |
|
} else { |
|
onDateChange(null); |
|
} |
|
} |
|
|
|
return onChange; |
|
}() |
|
}, { |
|
key: 'onFocus', |
|
value: function () { |
|
function onFocus() { |
|
var _props2 = this.props, |
|
disabled = _props2.disabled, |
|
onFocusChange = _props2.onFocusChange, |
|
readOnly = _props2.readOnly, |
|
withPortal = _props2.withPortal, |
|
withFullScreenPortal = _props2.withFullScreenPortal, |
|
keepFocusOnInput = _props2.keepFocusOnInput; |
|
|
|
|
|
var withAnyPortal = withPortal || withFullScreenPortal; |
|
var moveFocusToDayPicker = withAnyPortal || readOnly && !keepFocusOnInput || this.isTouchDevice && !keepFocusOnInput; |
|
|
|
if (moveFocusToDayPicker) { |
|
this.onDayPickerFocus(); |
|
} else { |
|
this.onDayPickerBlur(); |
|
} |
|
|
|
if (!disabled) { |
|
onFocusChange({ focused: true }); |
|
} |
|
} |
|
|
|
return onFocus; |
|
}() |
|
}, { |
|
key: 'onClearFocus', |
|
value: function () { |
|
function onClearFocus(event) { |
|
var _props3 = this.props, |
|
date = _props3.date, |
|
focused = _props3.focused, |
|
onFocusChange = _props3.onFocusChange, |
|
onClose = _props3.onClose, |
|
appendToBody = _props3.appendToBody; |
|
|
|
if (!focused) return; |
|
if (appendToBody && this.dayPickerContainer.contains(event.target)) return; |
|
|
|
this.setState({ |
|
isInputFocused: false, |
|
isDayPickerFocused: false |
|
}); |
|
|
|
onFocusChange({ focused: false }); |
|
onClose({ date: date }); |
|
} |
|
|
|
return onClearFocus; |
|
}() |
|
}, { |
|
key: 'onDayPickerFocus', |
|
value: function () { |
|
function onDayPickerFocus() { |
|
this.setState({ |
|
isInputFocused: false, |
|
isDayPickerFocused: true, |
|
showKeyboardShortcuts: false |
|
}); |
|
} |
|
|
|
return onDayPickerFocus; |
|
}() |
|
}, { |
|
key: 'onDayPickerBlur', |
|
value: function () { |
|
function onDayPickerBlur() { |
|
this.setState({ |
|
isInputFocused: true, |
|
isDayPickerFocused: false, |
|
showKeyboardShortcuts: false |
|
}); |
|
} |
|
|
|
return onDayPickerBlur; |
|
}() |
|
}, { |
|
key: 'getDateString', |
|
value: function () { |
|
function getDateString(date) { |
|
var displayFormat = this.getDisplayFormat(); |
|
if (date && displayFormat) { |
|
return date && date.format(displayFormat); |
|
} |
|
return (0, _toLocalizedDateString2['default'])(date); |
|
} |
|
|
|
return getDateString; |
|
}() |
|
}, { |
|
key: 'getDisplayFormat', |
|
value: function () { |
|
function getDisplayFormat() { |
|
var displayFormat = this.props.displayFormat; |
|
|
|
return typeof displayFormat === 'string' ? displayFormat : displayFormat(); |
|
} |
|
|
|
return getDisplayFormat; |
|
}() |
|
}, { |
|
key: 'setDayPickerContainerRef', |
|
value: function () { |
|
function setDayPickerContainerRef(ref) { |
|
this.dayPickerContainer = ref; |
|
} |
|
|
|
return setDayPickerContainerRef; |
|
}() |
|
}, { |
|
key: 'setContainerRef', |
|
value: function () { |
|
function setContainerRef(ref) { |
|
this.container = ref; |
|
} |
|
|
|
return setContainerRef; |
|
}() |
|
}, { |
|
key: 'clearDate', |
|
value: function () { |
|
function clearDate() { |
|
var _props4 = this.props, |
|
onDateChange = _props4.onDateChange, |
|
reopenPickerOnClearDate = _props4.reopenPickerOnClearDate, |
|
onFocusChange = _props4.onFocusChange; |
|
|
|
onDateChange(null); |
|
if (reopenPickerOnClearDate) { |
|
onFocusChange({ focused: true }); |
|
} |
|
} |
|
|
|
return clearDate; |
|
}() |
|
}, { |
|
key: 'disableScroll', |
|
value: function () { |
|
function disableScroll() { |
|
var _props5 = this.props, |
|
appendToBody = _props5.appendToBody, |
|
propDisableScroll = _props5.disableScroll, |
|
focused = _props5.focused; |
|
|
|
if (!appendToBody && !propDisableScroll) return; |
|
if (!focused) return; |
|
|
|
// Disable scroll for every ancestor of this <SingleDatePicker> up to the |
|
// document level. This ensures the input and the picker never move. Other |
|
// sibling elements or the picker itself can scroll. |
|
this.enableScroll = (0, _disableScroll3['default'])(this.container); |
|
} |
|
|
|
return disableScroll; |
|
}() |
|
|
|
/* istanbul ignore next */ |
|
|
|
}, { |
|
key: 'responsivizePickerPosition', |
|
value: function () { |
|
function responsivizePickerPosition() { |
|
// It's possible the portal props have been changed in response to window resizes |
|
// So let's ensure we reset this back to the base state each time |
|
this.setState({ dayPickerContainerStyles: {} }); |
|
|
|
var _props6 = this.props, |
|
openDirection = _props6.openDirection, |
|
anchorDirection = _props6.anchorDirection, |
|
horizontalMargin = _props6.horizontalMargin, |
|
withPortal = _props6.withPortal, |
|
withFullScreenPortal = _props6.withFullScreenPortal, |
|
appendToBody = _props6.appendToBody, |
|
focused = _props6.focused; |
|
var dayPickerContainerStyles = this.state.dayPickerContainerStyles; |
|
|
|
|
|
if (!focused) { |
|
return; |
|
} |
|
|
|
var isAnchoredLeft = anchorDirection === _constants.ANCHOR_LEFT; |
|
|
|
if (!withPortal && !withFullScreenPortal) { |
|
var containerRect = this.dayPickerContainer.getBoundingClientRect(); |
|
var currentOffset = dayPickerContainerStyles[anchorDirection] || 0; |
|
var containerEdge = isAnchoredLeft ? containerRect[_constants.ANCHOR_RIGHT] : containerRect[_constants.ANCHOR_LEFT]; |
|
|
|
this.setState({ |
|
dayPickerContainerStyles: (0, _object2['default'])({}, (0, _getResponsiveContainerStyles2['default'])(anchorDirection, currentOffset, containerEdge, horizontalMargin), appendToBody && (0, _getDetachedContainerStyles2['default'])(openDirection, anchorDirection, this.container)) |
|
}); |
|
} |
|
} |
|
|
|
return responsivizePickerPosition; |
|
}() |
|
}, { |
|
key: 'showKeyboardShortcutsPanel', |
|
value: function () { |
|
function showKeyboardShortcutsPanel() { |
|
this.setState({ |
|
isInputFocused: false, |
|
isDayPickerFocused: true, |
|
showKeyboardShortcuts: true |
|
}); |
|
} |
|
|
|
return showKeyboardShortcutsPanel; |
|
}() |
|
}, { |
|
key: 'maybeRenderDayPickerWithPortal', |
|
value: function () { |
|
function maybeRenderDayPickerWithPortal() { |
|
var _props7 = this.props, |
|
focused = _props7.focused, |
|
withPortal = _props7.withPortal, |
|
withFullScreenPortal = _props7.withFullScreenPortal, |
|
appendToBody = _props7.appendToBody; |
|
|
|
|
|
if (!focused) { |
|
return null; |
|
} |
|
|
|
if (withPortal || withFullScreenPortal || appendToBody) { |
|
return _react2['default'].createElement( |
|
_reactPortal.Portal, |
|
null, |
|
this.renderDayPicker() |
|
); |
|
} |
|
|
|
return this.renderDayPicker(); |
|
} |
|
|
|
return maybeRenderDayPickerWithPortal; |
|
}() |
|
}, { |
|
key: 'renderDayPicker', |
|
value: function () { |
|
function renderDayPicker() { |
|
var _props8 = this.props, |
|
anchorDirection = _props8.anchorDirection, |
|
openDirection = _props8.openDirection, |
|
onDateChange = _props8.onDateChange, |
|
date = _props8.date, |
|
onFocusChange = _props8.onFocusChange, |
|
focused = _props8.focused, |
|
enableOutsideDays = _props8.enableOutsideDays, |
|
numberOfMonths = _props8.numberOfMonths, |
|
orientation = _props8.orientation, |
|
monthFormat = _props8.monthFormat, |
|
navPrev = _props8.navPrev, |
|
navNext = _props8.navNext, |
|
onPrevMonthClick = _props8.onPrevMonthClick, |
|
onNextMonthClick = _props8.onNextMonthClick, |
|
onClose = _props8.onClose, |
|
withPortal = _props8.withPortal, |
|
withFullScreenPortal = _props8.withFullScreenPortal, |
|
keepOpenOnDateSelect = _props8.keepOpenOnDateSelect, |
|
initialVisibleMonth = _props8.initialVisibleMonth, |
|
renderMonthText = _props8.renderMonthText, |
|
renderCalendarDay = _props8.renderCalendarDay, |
|
renderDayContents = _props8.renderDayContents, |
|
renderCalendarInfo = _props8.renderCalendarInfo, |
|
renderMonthElement = _props8.renderMonthElement, |
|
calendarInfoPosition = _props8.calendarInfoPosition, |
|
hideKeyboardShortcutsPanel = _props8.hideKeyboardShortcutsPanel, |
|
firstDayOfWeek = _props8.firstDayOfWeek, |
|
customCloseIcon = _props8.customCloseIcon, |
|
phrases = _props8.phrases, |
|
dayAriaLabelFormat = _props8.dayAriaLabelFormat, |
|
daySize = _props8.daySize, |
|
isRTL = _props8.isRTL, |
|
isOutsideRange = _props8.isOutsideRange, |
|
isDayBlocked = _props8.isDayBlocked, |
|
isDayHighlighted = _props8.isDayHighlighted, |
|
weekDayFormat = _props8.weekDayFormat, |
|
styles = _props8.styles, |
|
verticalHeight = _props8.verticalHeight, |
|
transitionDuration = _props8.transitionDuration, |
|
verticalSpacing = _props8.verticalSpacing, |
|
horizontalMonthPadding = _props8.horizontalMonthPadding, |
|
small = _props8.small, |
|
reactDates = _props8.theme.reactDates; |
|
var _state = this.state, |
|
dayPickerContainerStyles = _state.dayPickerContainerStyles, |
|
isDayPickerFocused = _state.isDayPickerFocused, |
|
showKeyboardShortcuts = _state.showKeyboardShortcuts; |
|
|
|
|
|
var onOutsideClick = !withFullScreenPortal && withPortal ? this.onClearFocus : undefined; |
|
var closeIcon = customCloseIcon || _react2['default'].createElement(_CloseButton2['default'], null); |
|
|
|
var inputHeight = (0, _getInputHeight2['default'])(reactDates, small); |
|
|
|
var withAnyPortal = withPortal || withFullScreenPortal; |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
_extends({ // eslint-disable-line jsx-a11y/no-static-element-interactions |
|
ref: this.setDayPickerContainerRef |
|
}, (0, _reactWithStyles.css)(styles.SingleDatePicker_picker, anchorDirection === _constants.ANCHOR_LEFT && styles.SingleDatePicker_picker__directionLeft, anchorDirection === _constants.ANCHOR_RIGHT && styles.SingleDatePicker_picker__directionRight, openDirection === _constants.OPEN_DOWN && styles.SingleDatePicker_picker__openDown, openDirection === _constants.OPEN_UP && styles.SingleDatePicker_picker__openUp, !withAnyPortal && openDirection === _constants.OPEN_DOWN && { |
|
top: inputHeight + verticalSpacing |
|
}, !withAnyPortal && openDirection === _constants.OPEN_UP && { |
|
bottom: inputHeight + verticalSpacing |
|
}, orientation === _constants.HORIZONTAL_ORIENTATION && styles.SingleDatePicker_picker__horizontal, orientation === _constants.VERTICAL_ORIENTATION && styles.SingleDatePicker_picker__vertical, withAnyPortal && styles.SingleDatePicker_picker__portal, withFullScreenPortal && styles.SingleDatePicker_picker__fullScreenPortal, isRTL && styles.SingleDatePicker_picker__rtl, dayPickerContainerStyles), { |
|
onClick: onOutsideClick |
|
}), |
|
_react2['default'].createElement(_DayPickerSingleDateController2['default'], { |
|
date: date, |
|
onDateChange: onDateChange, |
|
onFocusChange: onFocusChange, |
|
orientation: orientation, |
|
enableOutsideDays: enableOutsideDays, |
|
numberOfMonths: numberOfMonths, |
|
monthFormat: monthFormat, |
|
withPortal: withAnyPortal, |
|
focused: focused, |
|
keepOpenOnDateSelect: keepOpenOnDateSelect, |
|
hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel, |
|
initialVisibleMonth: initialVisibleMonth, |
|
navPrev: navPrev, |
|
navNext: navNext, |
|
onPrevMonthClick: onPrevMonthClick, |
|
onNextMonthClick: onNextMonthClick, |
|
onClose: onClose, |
|
renderMonthText: renderMonthText, |
|
renderCalendarDay: renderCalendarDay, |
|
renderDayContents: renderDayContents, |
|
renderCalendarInfo: renderCalendarInfo, |
|
renderMonthElement: renderMonthElement, |
|
calendarInfoPosition: calendarInfoPosition, |
|
isFocused: isDayPickerFocused, |
|
showKeyboardShortcuts: showKeyboardShortcuts, |
|
onBlur: this.onDayPickerBlur, |
|
phrases: phrases, |
|
dayAriaLabelFormat: dayAriaLabelFormat, |
|
daySize: daySize, |
|
isRTL: isRTL, |
|
isOutsideRange: isOutsideRange, |
|
isDayBlocked: isDayBlocked, |
|
isDayHighlighted: isDayHighlighted, |
|
firstDayOfWeek: firstDayOfWeek, |
|
weekDayFormat: weekDayFormat, |
|
verticalHeight: verticalHeight, |
|
transitionDuration: transitionDuration, |
|
horizontalMonthPadding: horizontalMonthPadding |
|
}), |
|
withFullScreenPortal && _react2['default'].createElement( |
|
'button', |
|
_extends({}, (0, _reactWithStyles.css)(styles.SingleDatePicker_closeButton), { |
|
'aria-label': phrases.closeDatePicker, |
|
type: 'button', |
|
onClick: this.onClearFocus |
|
}), |
|
_react2['default'].createElement( |
|
'div', |
|
(0, _reactWithStyles.css)(styles.SingleDatePicker_closeButton_svg), |
|
closeIcon |
|
) |
|
) |
|
); |
|
} |
|
|
|
return renderDayPicker; |
|
}() |
|
}, { |
|
key: 'render', |
|
value: function () { |
|
function render() { |
|
var _props9 = this.props, |
|
id = _props9.id, |
|
placeholder = _props9.placeholder, |
|
disabled = _props9.disabled, |
|
focused = _props9.focused, |
|
required = _props9.required, |
|
readOnly = _props9.readOnly, |
|
openDirection = _props9.openDirection, |
|
showClearDate = _props9.showClearDate, |
|
showDefaultInputIcon = _props9.showDefaultInputIcon, |
|
inputIconPosition = _props9.inputIconPosition, |
|
customCloseIcon = _props9.customCloseIcon, |
|
customInputIcon = _props9.customInputIcon, |
|
date = _props9.date, |
|
phrases = _props9.phrases, |
|
withPortal = _props9.withPortal, |
|
withFullScreenPortal = _props9.withFullScreenPortal, |
|
screenReaderInputMessage = _props9.screenReaderInputMessage, |
|
isRTL = _props9.isRTL, |
|
noBorder = _props9.noBorder, |
|
block = _props9.block, |
|
small = _props9.small, |
|
regular = _props9.regular, |
|
verticalSpacing = _props9.verticalSpacing, |
|
styles = _props9.styles; |
|
var isInputFocused = this.state.isInputFocused; |
|
|
|
|
|
var displayValue = this.getDateString(date); |
|
|
|
var enableOutsideClick = !withPortal && !withFullScreenPortal; |
|
|
|
var hideFang = verticalSpacing < _constants.FANG_HEIGHT_PX; |
|
|
|
var input = _react2['default'].createElement(_SingleDatePickerInput2['default'], { |
|
id: id, |
|
placeholder: placeholder, |
|
focused: focused, |
|
isFocused: isInputFocused, |
|
disabled: disabled, |
|
required: required, |
|
readOnly: readOnly, |
|
openDirection: openDirection, |
|
showCaret: !withPortal && !withFullScreenPortal && !hideFang, |
|
onClearDate: this.clearDate, |
|
showClearDate: showClearDate, |
|
showDefaultInputIcon: showDefaultInputIcon, |
|
inputIconPosition: inputIconPosition, |
|
customCloseIcon: customCloseIcon, |
|
customInputIcon: customInputIcon, |
|
displayValue: displayValue, |
|
onChange: this.onChange, |
|
onFocus: this.onFocus, |
|
onKeyDownShiftTab: this.onClearFocus, |
|
onKeyDownTab: this.onClearFocus, |
|
onKeyDownArrowDown: this.onDayPickerFocus, |
|
onKeyDownQuestionMark: this.showKeyboardShortcutsPanel, |
|
screenReaderMessage: screenReaderInputMessage, |
|
phrases: phrases, |
|
isRTL: isRTL, |
|
noBorder: noBorder, |
|
block: block, |
|
small: small, |
|
regular: regular, |
|
verticalSpacing: verticalSpacing |
|
}); |
|
|
|
return _react2['default'].createElement( |
|
'div', |
|
_extends({ |
|
ref: this.setContainerRef |
|
}, (0, _reactWithStyles.css)(styles.SingleDatePicker, block && styles.SingleDatePicker__block)), |
|
enableOutsideClick && _react2['default'].createElement( |
|
_reactOutsideClickHandler2['default'], |
|
{ onOutsideClick: this.onClearFocus }, |
|
input, |
|
this.maybeRenderDayPickerWithPortal() |
|
), |
|
!enableOutsideClick && input, |
|
!enableOutsideClick && this.maybeRenderDayPickerWithPortal() |
|
); |
|
} |
|
|
|
return render; |
|
}() |
|
}]); |
|
|
|
return SingleDatePicker; |
|
}(_react2['default'].Component); |
|
|
|
SingleDatePicker.propTypes = propTypes; |
|
SingleDatePicker.defaultProps = defaultProps; |
|
|
|
exports.PureSingleDatePicker = SingleDatePicker; |
|
exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref) { |
|
var _ref$reactDates = _ref.reactDates, |
|
color = _ref$reactDates.color, |
|
zIndex = _ref$reactDates.zIndex; |
|
return { |
|
SingleDatePicker: { |
|
position: 'relative', |
|
display: 'inline-block' |
|
}, |
|
|
|
SingleDatePicker__block: { |
|
display: 'block' |
|
}, |
|
|
|
SingleDatePicker_picker: { |
|
zIndex: zIndex + 1, |
|
backgroundColor: color.background, |
|
position: 'absolute' |
|
}, |
|
|
|
SingleDatePicker_picker__rtl: { |
|
direction: 'rtl' |
|
}, |
|
|
|
SingleDatePicker_picker__directionLeft: { |
|
left: 0 |
|
}, |
|
|
|
SingleDatePicker_picker__directionRight: { |
|
right: 0 |
|
}, |
|
|
|
SingleDatePicker_picker__portal: { |
|
backgroundColor: 'rgba(0, 0, 0, 0.3)', |
|
position: 'fixed', |
|
top: 0, |
|
left: 0, |
|
height: '100%', |
|
width: '100%' |
|
}, |
|
|
|
SingleDatePicker_picker__fullScreenPortal: { |
|
backgroundColor: color.background |
|
}, |
|
|
|
SingleDatePicker_closeButton: { |
|
background: 'none', |
|
border: 0, |
|
color: 'inherit', |
|
font: 'inherit', |
|
lineHeight: 'normal', |
|
overflow: 'visible', |
|
cursor: 'pointer', |
|
|
|
position: 'absolute', |
|
top: 0, |
|
right: 0, |
|
padding: 15, |
|
zIndex: zIndex + 2, |
|
|
|
':hover': { |
|
color: 'darken(' + String(color.core.grayLighter) + ', 10%)', |
|
textDecoration: 'none' |
|
}, |
|
|
|
':focus': { |
|
color: 'darken(' + String(color.core.grayLighter) + ', 10%)', |
|
textDecoration: 'none' |
|
} |
|
}, |
|
|
|
SingleDatePicker_closeButton_svg: { |
|
height: 15, |
|
width: 15, |
|
fill: color.core.grayLighter |
|
} |
|
}; |
|
})(SingleDatePicker); |
|
|
|
/***/ }), |
|
/* 313 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports['default'] = isInclusivelyBeforeDay; |
|
|
|
var _moment = __webpack_require__(29); |
|
|
|
var _moment2 = _interopRequireDefault(_moment); |
|
|
|
var _isAfterDay = __webpack_require__(108); |
|
|
|
var _isAfterDay2 = _interopRequireDefault(_isAfterDay); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } |
|
|
|
function isInclusivelyBeforeDay(a, b) { |
|
if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false; |
|
return !(0, _isAfterDay2['default'])(a, b); |
|
} |
|
|
|
/***/ }), |
|
/* 314 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
var __assign = (this && this.__assign) || function () { |
|
__assign = Object.assign || function(t) { |
|
for (var s, i = 1, n = arguments.length; i < n; i++) { |
|
s = arguments[i]; |
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) |
|
t[p] = s[p]; |
|
} |
|
return t; |
|
}; |
|
return __assign.apply(this, arguments); |
|
}; |
|
var __importStar = (this && this.__importStar) || function (mod) { |
|
if (mod && mod.__esModule) return mod; |
|
var result = {}; |
|
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; |
|
result["default"] = mod; |
|
return result; |
|
}; |
|
Object.defineProperty(exports, "__esModule", { value: true }); |
|
var React = __importStar(__webpack_require__(28)); |
|
var styles = { |
|
top: { |
|
width: '100%', |
|
height: '10px', |
|
top: '-5px', |
|
left: '0px', |
|
cursor: 'row-resize', |
|
}, |
|
right: { |
|
width: '10px', |
|
height: '100%', |
|
top: '0px', |
|
right: '-5px', |
|
cursor: 'col-resize', |
|
}, |
|
bottom: { |
|
width: '100%', |
|
height: '10px', |
|
bottom: '-5px', |
|
left: '0px', |
|
cursor: 'row-resize', |
|
}, |
|
left: { |
|
width: '10px', |
|
height: '100%', |
|
top: '0px', |
|
left: '-5px', |
|
cursor: 'col-resize', |
|
}, |
|
topRight: { |
|
width: '20px', |
|
height: '20px', |
|
position: 'absolute', |
|
right: '-10px', |
|
top: '-10px', |
|
cursor: 'ne-resize', |
|
}, |
|
bottomRight: { |
|
width: '20px', |
|
height: '20px', |
|
position: 'absolute', |
|
right: '-10px', |
|
bottom: '-10px', |
|
cursor: 'se-resize', |
|
}, |
|
bottomLeft: { |
|
width: '20px', |
|
height: '20px', |
|
position: 'absolute', |
|
left: '-10px', |
|
bottom: '-10px', |
|
cursor: 'sw-resize', |
|
}, |
|
topLeft: { |
|
width: '20px', |
|
height: '20px', |
|
position: 'absolute', |
|
left: '-10px', |
|
top: '-10px', |
|
cursor: 'nw-resize', |
|
}, |
|
}; |
|
function Resizer(props) { |
|
return (React.createElement("div", { className: props.className || '', style: __assign({ position: 'absolute', userSelect: 'none' }, styles[props.direction], (props.replaceStyles || {})), onMouseDown: function (e) { |
|
props.onResizeStart(e, props.direction); |
|
}, onTouchStart: function (e) { |
|
props.onResizeStart(e, props.direction); |
|
} }, props.children)); |
|
} |
|
exports.Resizer = Resizer; |
|
|
|
|
|
/***/ }), |
|
/* 315 */ |
|
/***/ (function(module, exports) { |
|
|
|
// |
|
// Main |
|
// |
|
|
|
function memoize (fn, options) { |
|
var cache = options && options.cache |
|
? options.cache |
|
: cacheDefault |
|
|
|
var serializer = options && options.serializer |
|
? options.serializer |
|
: serializerDefault |
|
|
|
var strategy = options && options.strategy |
|
? options.strategy |
|
: strategyDefault |
|
|
|
return strategy(fn, { |
|
cache: cache, |
|
serializer: serializer |
|
}) |
|
} |
|
|
|
// |
|
// Strategy |
|
// |
|
|
|
function isPrimitive (value) { |
|
return value == null || typeof value === 'number' || typeof value === 'boolean' // || typeof value === "string" 'unsafe' primitive for our needs |
|
} |
|
|
|
function monadic (fn, cache, serializer, arg) { |
|
var cacheKey = isPrimitive(arg) ? arg : serializer(arg) |
|
|
|
var computedValue = cache.get(cacheKey) |
|
if (typeof computedValue === 'undefined') { |
|
computedValue = fn.call(this, arg) |
|
cache.set(cacheKey, computedValue) |
|
} |
|
|
|
return computedValue |
|
} |
|
|
|
function variadic (fn, cache, serializer) { |
|
var args = Array.prototype.slice.call(arguments, 3) |
|
var cacheKey = serializer(args) |
|
|
|
var computedValue = cache.get(cacheKey) |
|
if (typeof computedValue === 'undefined') { |
|
computedValue = fn.apply(this, args) |
|
cache.set(cacheKey, computedValue) |
|
} |
|
|
|
return computedValue |
|
} |
|
|
|
function assemble (fn, context, strategy, cache, serialize) { |
|
return strategy.bind( |
|
context, |
|
fn, |
|
cache, |
|
serialize |
|
) |
|
} |
|
|
|
function strategyDefault (fn, options) { |
|
var strategy = fn.length === 1 ? monadic : variadic |
|
|
|
return assemble( |
|
fn, |
|
this, |
|
strategy, |
|
options.cache.create(), |
|
options.serializer |
|
) |
|
} |
|
|
|
function strategyVariadic (fn, options) { |
|
var strategy = variadic |
|
|
|
return assemble( |
|
fn, |
|
this, |
|
strategy, |
|
options.cache.create(), |
|
options.serializer |
|
) |
|
} |
|
|
|
function strategyMonadic (fn, options) { |
|
var strategy = monadic |
|
|
|
return assemble( |
|
fn, |
|
this, |
|
strategy, |
|
options.cache.create(), |
|
options.serializer |
|
) |
|
} |
|
|
|
// |
|
// Serializer |
|
// |
|
|
|
function serializerDefault () { |
|
return JSON.stringify(arguments) |
|
} |
|
|
|
// |
|
// Cache |
|
// |
|
|
|
function ObjectWithoutPrototypeCache () { |
|
this.cache = Object.create(null) |
|
} |
|
|
|
ObjectWithoutPrototypeCache.prototype.has = function (key) { |
|
return (key in this.cache) |
|
} |
|
|
|
ObjectWithoutPrototypeCache.prototype.get = function (key) { |
|
return this.cache[key] |
|
} |
|
|
|
ObjectWithoutPrototypeCache.prototype.set = function (key, value) { |
|
this.cache[key] = value |
|
} |
|
|
|
var cacheDefault = { |
|
create: function create () { |
|
return new ObjectWithoutPrototypeCache() |
|
} |
|
} |
|
|
|
// |
|
// API |
|
// |
|
|
|
module.exports = memoize |
|
module.exports.strategies = { |
|
variadic: strategyVariadic, |
|
monadic: strategyMonadic |
|
} |
|
|
|
|
|
/***/ }), |
|
/* 316 */, |
|
/* 317 */, |
|
/* 318 */, |
|
/* 319 */, |
|
/* 320 */, |
|
/* 321 */, |
|
/* 322 */, |
|
/* 323 */, |
|
/* 324 */, |
|
/* 325 */, |
|
/* 326 */, |
|
/* 327 */, |
|
/* 328 */, |
|
/* 329 */, |
|
/* 330 */, |
|
/* 331 */, |
|
/* 332 */, |
|
/* 333 */, |
|
/* 334 */, |
|
/* 335 */, |
|
/* 336 */, |
|
/* 337 */, |
|
/* 338 */, |
|
/* 339 */, |
|
/* 340 */, |
|
/* 341 */, |
|
/* 342 */, |
|
/* 343 */, |
|
/* 344 */ |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
__webpack_require__.r(__webpack_exports__); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread.js |
|
var objectSpread = __webpack_require__(7); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","element"]} |
|
var external_this_wp_element_ = __webpack_require__(0); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/primitives/svg/index.js |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
var svg_Circle = function Circle(props) { |
|
return Object(external_this_wp_element_["createElement"])('circle', props); |
|
}; |
|
var svg_G = function G(props) { |
|
return Object(external_this_wp_element_["createElement"])('g', props); |
|
}; |
|
var svg_Path = function Path(props) { |
|
return Object(external_this_wp_element_["createElement"])('path', props); |
|
}; |
|
var svg_Polygon = function Polygon(props) { |
|
return Object(external_this_wp_element_["createElement"])('polygon', props); |
|
}; |
|
var svg_Rect = function Rect(props) { |
|
return Object(external_this_wp_element_["createElement"])('rect', props); |
|
}; |
|
var svg_SVG = function SVG(props) { |
|
var appliedProps = Object(objectSpread["a" /* default */])({}, props, { |
|
role: 'img', |
|
'aria-hidden': 'true', |
|
focusable: 'false' |
|
}); // Disable reason: We need to have a way to render HTML tag for web. |
|
// eslint-disable-next-line react/forbid-elements |
|
|
|
|
|
return Object(external_this_wp_element_["createElement"])("svg", appliedProps); |
|
}; |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/primitives/horizontal-rule/index.js |
|
var HorizontalRule = 'hr'; |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/primitives/block-quotation/index.js |
|
var BlockQuotation = 'blockquote'; |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/primitives/index.js |
|
|
|
|
|
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js |
|
var defineProperty = __webpack_require__(10); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules |
|
var slicedToArray = __webpack_require__(23); |
|
|
|
// EXTERNAL MODULE: ./node_modules/classnames/index.js |
|
var classnames = __webpack_require__(16); |
|
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/animate/index.js |
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
function Animate(_ref) { |
|
var type = _ref.type, |
|
_ref$options = _ref.options, |
|
options = _ref$options === void 0 ? {} : _ref$options, |
|
children = _ref.children; |
|
|
|
if (type === 'appear') { |
|
var _classnames; |
|
|
|
var _options$origin = options.origin, |
|
origin = _options$origin === void 0 ? 'top' : _options$origin; |
|
|
|
var _origin$split = origin.split(' '), |
|
_origin$split2 = Object(slicedToArray["a" /* default */])(_origin$split, 2), |
|
yAxis = _origin$split2[0], |
|
_origin$split2$ = _origin$split2[1], |
|
xAxis = _origin$split2$ === void 0 ? 'center' : _origin$split2$; |
|
|
|
return children({ |
|
className: classnames_default()('components-animate__appear', (_classnames = {}, Object(defineProperty["a" /* default */])(_classnames, 'is-from-' + xAxis, xAxis !== 'center'), Object(defineProperty["a" /* default */])(_classnames, 'is-from-' + yAxis, yAxis !== 'middle'), _classnames)) |
|
}); |
|
} |
|
|
|
if (type === 'slide-in') { |
|
var _options$origin2 = options.origin, |
|
_origin = _options$origin2 === void 0 ? 'left' : _options$origin2; |
|
|
|
return children({ |
|
className: classnames_default()('components-animate__slide-in', 'is-from-' + _origin) |
|
}); |
|
} |
|
|
|
if (type === 'loading') { |
|
return children({ |
|
className: classnames_default()('components-animate__loading') |
|
}); |
|
} |
|
|
|
return children({}); |
|
} |
|
|
|
/* harmony default export */ var build_module_animate = (Animate); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js |
|
var classCallCheck = __webpack_require__(12); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js |
|
var possibleConstructorReturn = __webpack_require__(13); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js |
|
var getPrototypeOf = __webpack_require__(14); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js |
|
var assertThisInitialized = __webpack_require__(5); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js |
|
var createClass = __webpack_require__(11); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js + 1 modules |
|
var inherits = __webpack_require__(15); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules |
|
var toConsumableArray = __webpack_require__(17); |
|
|
|
// EXTERNAL MODULE: external "lodash" |
|
var external_lodash_ = __webpack_require__(2); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","keycodes"]} |
|
var external_this_wp_keycodes_ = __webpack_require__(19); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","i18n"]} |
|
var external_this_wp_i18n_ = __webpack_require__(1); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","compose"]} |
|
var external_this_wp_compose_ = __webpack_require__(8); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","richText"]} |
|
var external_this_wp_richText_ = __webpack_require__(22); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","dom"]} |
|
var external_this_wp_dom_ = __webpack_require__(25); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js + 1 modules |
|
var objectWithoutProperties = __webpack_require__(21); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/button/index.js |
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
function Button(props, ref) { |
|
var href = props.href, |
|
target = props.target, |
|
isPrimary = props.isPrimary, |
|
isLarge = props.isLarge, |
|
isSmall = props.isSmall, |
|
isTertiary = props.isTertiary, |
|
isToggled = props.isToggled, |
|
isBusy = props.isBusy, |
|
isDefault = props.isDefault, |
|
isLink = props.isLink, |
|
isDestructive = props.isDestructive, |
|
className = props.className, |
|
disabled = props.disabled, |
|
additionalProps = Object(objectWithoutProperties["a" /* default */])(props, ["href", "target", "isPrimary", "isLarge", "isSmall", "isTertiary", "isToggled", "isBusy", "isDefault", "isLink", "isDestructive", "className", "disabled"]); |
|
|
|
var classes = classnames_default()('components-button', className, { |
|
'is-button': isDefault || isPrimary || isLarge || isSmall, |
|
'is-default': isDefault || !isPrimary && (isLarge || isSmall), |
|
'is-primary': isPrimary, |
|
'is-large': isLarge, |
|
'is-small': isSmall, |
|
'is-tertiary': isTertiary, |
|
'is-toggled': isToggled, |
|
'is-busy': isBusy, |
|
'is-link': isLink, |
|
'is-destructive': isDestructive |
|
}); |
|
var tag = href !== undefined && !disabled ? 'a' : 'button'; |
|
var tagProps = tag === 'a' ? { |
|
href: href, |
|
target: target |
|
} : { |
|
type: 'button', |
|
disabled: disabled |
|
}; |
|
return Object(external_this_wp_element_["createElement"])(tag, Object(objectSpread["a" /* default */])({}, tagProps, additionalProps, { |
|
className: classes, |
|
ref: ref |
|
})); |
|
} |
|
/* harmony default export */ var build_module_button = (Object(external_this_wp_element_["forwardRef"])(Button)); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js |
|
var esm_extends = __webpack_require__(18); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","isShallowEqual"]} |
|
var external_this_wp_isShallowEqual_ = __webpack_require__(41); |
|
var external_this_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_isShallowEqual_); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","deprecated"]} |
|
var external_this_wp_deprecated_ = __webpack_require__(37); |
|
var external_this_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_deprecated_); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/popover/utils.js |
|
|
|
|
|
|
|
/** |
|
* Module constants |
|
*/ |
|
var HEIGHT_OFFSET = 10; // used by the arrow and a bit of empty space |
|
|
|
var isMobileViewport = function isMobileViewport() { |
|
return window.innerWidth < 782; |
|
}; |
|
|
|
var isRTL = function isRTL() { |
|
return document.documentElement.dir === 'rtl'; |
|
}; |
|
/** |
|
* Utility used to compute the popover position over the xAxis |
|
* |
|
* @param {Object} anchorRect Anchor Rect. |
|
* @param {Object} contentSize Content Size. |
|
* @param {string} xAxis Desired xAxis. |
|
* @param {string} chosenYAxis yAxis to be used. |
|
* |
|
* @return {Object} Popover xAxis position and constraints. |
|
*/ |
|
|
|
|
|
function computePopoverXAxisPosition(anchorRect, contentSize, xAxis, chosenYAxis) { |
|
var width = contentSize.width; // Correct xAxis for RTL support |
|
|
|
if (xAxis === 'left' && isRTL()) { |
|
xAxis = 'right'; |
|
} else if (xAxis === 'right' && isRTL()) { |
|
xAxis = 'left'; |
|
} // x axis alignment choices |
|
|
|
|
|
var anchorMidPoint = Math.round(anchorRect.left + anchorRect.width / 2); |
|
var centerAlignment = { |
|
popoverLeft: anchorMidPoint, |
|
contentWidth: (anchorMidPoint - width / 2 > 0 ? width / 2 : anchorMidPoint) + (anchorMidPoint + width / 2 > window.innerWidth ? window.innerWidth - anchorMidPoint : width / 2) |
|
}; |
|
var leftAlignmentX = chosenYAxis === 'middle' ? anchorRect.left : anchorMidPoint; |
|
var leftAlignment = { |
|
popoverLeft: leftAlignmentX, |
|
contentWidth: leftAlignmentX - width > 0 ? width : leftAlignmentX |
|
}; |
|
var rightAlignmentX = chosenYAxis === 'middle' ? anchorRect.right : anchorMidPoint; |
|
var rightAlignment = { |
|
popoverLeft: rightAlignmentX, |
|
contentWidth: rightAlignmentX + width > window.innerWidth ? window.innerWidth - rightAlignmentX : width |
|
}; // Choosing the x axis |
|
|
|
var chosenXAxis; |
|
var contentWidth = null; |
|
|
|
if (xAxis === 'center' && centerAlignment.contentWidth === width) { |
|
chosenXAxis = 'center'; |
|
} else if (xAxis === 'left' && leftAlignment.contentWidth === width) { |
|
chosenXAxis = 'left'; |
|
} else if (xAxis === 'right' && rightAlignment.contentWidth === width) { |
|
chosenXAxis = 'right'; |
|
} else { |
|
chosenXAxis = leftAlignment.contentWidth > rightAlignment.contentWidth ? 'left' : 'right'; |
|
var chosenWidth = chosenXAxis === 'left' ? leftAlignment.contentWidth : rightAlignment.contentWidth; |
|
contentWidth = chosenWidth !== width ? chosenWidth : null; |
|
} |
|
|
|
var popoverLeft; |
|
|
|
if (chosenXAxis === 'center') { |
|
popoverLeft = centerAlignment.popoverLeft; |
|
} else if (chosenXAxis === 'left') { |
|
popoverLeft = leftAlignment.popoverLeft; |
|
} else { |
|
popoverLeft = rightAlignment.popoverLeft; |
|
} |
|
|
|
return { |
|
xAxis: chosenXAxis, |
|
popoverLeft: popoverLeft, |
|
contentWidth: contentWidth |
|
}; |
|
} |
|
/** |
|
* Utility used to compute the popover position over the yAxis |
|
* |
|
* @param {Object} anchorRect Anchor Rect. |
|
* @param {Object} contentSize Content Size. |
|
* @param {string} yAxis Desired yAxis. |
|
* |
|
* @return {Object} Popover xAxis position and constraints. |
|
*/ |
|
|
|
function computePopoverYAxisPosition(anchorRect, contentSize, yAxis) { |
|
var height = contentSize.height; // y axis alignment choices |
|
|
|
var anchorMidPoint = anchorRect.top + anchorRect.height / 2; |
|
var middleAlignment = { |
|
popoverTop: anchorMidPoint, |
|
contentHeight: (anchorMidPoint - height / 2 > 0 ? height / 2 : anchorMidPoint) + (anchorMidPoint + height / 2 > window.innerHeight ? window.innerHeight - anchorMidPoint : height / 2) |
|
}; |
|
var topAlignment = { |
|
popoverTop: anchorRect.top, |
|
contentHeight: anchorRect.top - HEIGHT_OFFSET - height > 0 ? height : anchorRect.top - HEIGHT_OFFSET |
|
}; |
|
var bottomAlignment = { |
|
popoverTop: anchorRect.bottom, |
|
contentHeight: anchorRect.bottom + HEIGHT_OFFSET + height > window.innerHeight ? window.innerHeight - HEIGHT_OFFSET - anchorRect.bottom : height |
|
}; // Choosing the y axis |
|
|
|
var chosenYAxis; |
|
var contentHeight = null; |
|
|
|
if (yAxis === 'middle' && middleAlignment.contentHeight === height) { |
|
chosenYAxis = 'middle'; |
|
} else if (yAxis === 'top' && topAlignment.contentHeight === height) { |
|
chosenYAxis = 'top'; |
|
} else if (yAxis === 'bottom' && bottomAlignment.contentHeight === height) { |
|
chosenYAxis = 'bottom'; |
|
} else { |
|
chosenYAxis = topAlignment.contentHeight > bottomAlignment.contentHeight ? 'top' : 'bottom'; |
|
var chosenHeight = chosenYAxis === 'top' ? topAlignment.contentHeight : bottomAlignment.contentHeight; |
|
contentHeight = chosenHeight !== height ? chosenHeight : null; |
|
} |
|
|
|
var popoverTop; |
|
|
|
if (chosenYAxis === 'middle') { |
|
popoverTop = middleAlignment.popoverTop; |
|
} else if (chosenYAxis === 'top') { |
|
popoverTop = topAlignment.popoverTop; |
|
} else { |
|
popoverTop = bottomAlignment.popoverTop; |
|
} |
|
|
|
return { |
|
yAxis: chosenYAxis, |
|
popoverTop: popoverTop, |
|
contentHeight: contentHeight |
|
}; |
|
} |
|
/** |
|
* Utility used to compute the popover position and the content max width/height for a popover |
|
* given its anchor rect and its content size. |
|
* |
|
* @param {Object} anchorRect Anchor Rect. |
|
* @param {Object} contentSize Content Size. |
|
* @param {string} position Position. |
|
* @param {boolean} expandOnMobile Whether to expand the popover on mobile or not. |
|
* |
|
* @return {Object} Popover position and constraints. |
|
*/ |
|
|
|
function computePopoverPosition(anchorRect, contentSize) { |
|
var position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'top'; |
|
var expandOnMobile = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; |
|
|
|
var _position$split = position.split(' '), |
|
_position$split2 = Object(slicedToArray["a" /* default */])(_position$split, 2), |
|
yAxis = _position$split2[0], |
|
_position$split2$ = _position$split2[1], |
|
xAxis = _position$split2$ === void 0 ? 'center' : _position$split2$; |
|
|
|
var yAxisPosition = computePopoverYAxisPosition(anchorRect, contentSize, yAxis); |
|
var xAxisPosition = computePopoverXAxisPosition(anchorRect, contentSize, xAxis, yAxisPosition.yAxis); |
|
return Object(objectSpread["a" /* default */])({ |
|
isMobile: isMobileViewport() && expandOnMobile |
|
}, xAxisPosition, yAxisPosition); |
|
} |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/higher-order/with-focus-return/context.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
var _createContext = Object(external_this_wp_element_["createContext"])({ |
|
focusHistory: [] |
|
}), |
|
Provider = _createContext.Provider, |
|
Consumer = _createContext.Consumer; |
|
|
|
Provider.displayName = 'FocusReturnProvider'; |
|
Consumer.displayName = 'FocusReturnConsumer'; |
|
/** |
|
* The maximum history length to capture for the focus stack. When exceeded, |
|
* items should be shifted from the stack for each consecutive push. |
|
* |
|
* @type {number} |
|
*/ |
|
|
|
var MAX_STACK_LENGTH = 100; |
|
|
|
var context_FocusReturnProvider = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(FocusReturnProvider, _Component); |
|
|
|
function FocusReturnProvider() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, FocusReturnProvider); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(FocusReturnProvider).apply(this, arguments)); |
|
_this.onFocus = _this.onFocus.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.state = { |
|
focusHistory: [] |
|
}; |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(FocusReturnProvider, [{ |
|
key: "onFocus", |
|
value: function onFocus(event) { |
|
var focusHistory = this.state.focusHistory; // Push the focused element to the history stack, keeping only unique |
|
// members but preferring the _last_ occurrence of any duplicates. |
|
// Lodash's `uniq` behavior favors the first occurrence, so the array |
|
// is temporarily reversed prior to it being called upon. Uniqueness |
|
// helps avoid situations where, such as in a constrained tabbing area, |
|
// the user changes focus enough within a transient element that the |
|
// stack may otherwise only consist of members pending destruction, at |
|
// which point focus might have been lost. |
|
|
|
var nextFocusHistory = Object(external_lodash_["uniq"])([].concat(Object(toConsumableArray["a" /* default */])(focusHistory), [event.target]).slice(-1 * MAX_STACK_LENGTH).reverse()).reverse(); |
|
this.setState({ |
|
focusHistory: nextFocusHistory |
|
}); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
children = _this$props.children, |
|
className = _this$props.className; |
|
return Object(external_this_wp_element_["createElement"])(Provider, { |
|
value: this.state |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
onFocus: this.onFocus, |
|
className: className |
|
}, children)); |
|
} |
|
}]); |
|
|
|
return FocusReturnProvider; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var with_focus_return_context = (context_FocusReturnProvider); |
|
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/higher-order/with-focus-return/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Returns true if the given object is component-like. An object is component- |
|
* like if it is an instance of wp.element.Component, or is a function. |
|
* |
|
* @param {*} object Object to test. |
|
* |
|
* @return {boolean} Whether object is component-like. |
|
*/ |
|
|
|
function isComponentLike(object) { |
|
return object instanceof external_this_wp_element_["Component"] || typeof object === 'function'; |
|
} |
|
/** |
|
* Higher Order Component used to be used to wrap disposable elements like |
|
* sidebars, modals, dropdowns. When mounting the wrapped component, we track a |
|
* reference to the current active element so we know where to restore focus |
|
* when the component is unmounted. |
|
* |
|
* @param {(WPComponent|Object)} options The component to be enhanced with |
|
* focus return behavior, or an object |
|
* describing the component and the |
|
* focus return characteristics. |
|
* |
|
* @return {Component} Component with the focus restauration behaviour. |
|
*/ |
|
|
|
|
|
function withFocusReturn(options) { |
|
// Normalize as overloaded form `withFocusReturn( options )( Component )` |
|
// or as `withFocusReturn( Component )`. |
|
if (isComponentLike(options)) { |
|
var WrappedComponent = options; |
|
return withFocusReturn({})(WrappedComponent); |
|
} |
|
|
|
var _options$onFocusRetur = options.onFocusReturn, |
|
onFocusReturn = _options$onFocusRetur === void 0 ? external_lodash_["stubTrue"] : _options$onFocusRetur; |
|
return function (WrappedComponent) { |
|
var FocusReturn = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(FocusReturn, _Component); |
|
|
|
function FocusReturn() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, FocusReturn); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(FocusReturn).apply(this, arguments)); |
|
_this.ownFocusedElements = new Set(); |
|
_this.activeElementOnMount = document.activeElement; |
|
|
|
_this.setIsFocusedFalse = function () { |
|
return _this.isFocused = false; |
|
}; |
|
|
|
_this.setIsFocusedTrue = function (event) { |
|
_this.ownFocusedElements.add(event.target); |
|
|
|
_this.isFocused = true; |
|
}; |
|
|
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(FocusReturn, [{ |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
var activeElementOnMount = this.activeElementOnMount, |
|
isFocused = this.isFocused, |
|
ownFocusedElements = this.ownFocusedElements; |
|
|
|
if (!isFocused) { |
|
return; |
|
} // Defer to the component's own explicit focus return behavior, |
|
// if specified. The function should return `false` to prevent |
|
// the default behavior otherwise occurring here. This allows |
|
// for support that the `onFocusReturn` decides to allow the |
|
// default behavior to occur under some conditions. |
|
|
|
|
|
if (onFocusReturn() === false) { |
|
return; |
|
} |
|
|
|
var stack = [].concat(Object(toConsumableArray["a" /* default */])(external_lodash_["without"].apply(void 0, [this.props.focus.focusHistory].concat(Object(toConsumableArray["a" /* default */])(ownFocusedElements)))), [activeElementOnMount]); |
|
var candidate; |
|
|
|
while (candidate = stack.pop()) { |
|
if (document.body.contains(candidate)) { |
|
candidate.focus(); |
|
return; |
|
} |
|
} |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
onFocus: this.setIsFocusedTrue, |
|
onBlur: this.setIsFocusedFalse |
|
}, Object(external_this_wp_element_["createElement"])(WrappedComponent, this.props.childProps)); |
|
} |
|
}]); |
|
|
|
return FocusReturn; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
return function (props) { |
|
return Object(external_this_wp_element_["createElement"])(Consumer, null, function (context) { |
|
return Object(external_this_wp_element_["createElement"])(FocusReturn, { |
|
childProps: props, |
|
focus: context |
|
}); |
|
}); |
|
}; |
|
}; |
|
} |
|
|
|
/* harmony default export */ var with_focus_return = (Object(external_this_wp_compose_["createHigherOrderComponent"])(withFocusReturn, 'withFocusReturn')); |
|
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/higher-order/with-constrained-tabbing/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
var withConstrainedTabbing = Object(external_this_wp_compose_["createHigherOrderComponent"])(function (WrappedComponent) { |
|
return ( |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(_class, _Component); |
|
|
|
function _class() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, _class); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).apply(this, arguments)); |
|
_this.focusContainRef = Object(external_this_wp_element_["createRef"])(); |
|
_this.handleTabBehaviour = _this.handleTabBehaviour.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(_class, [{ |
|
key: "handleTabBehaviour", |
|
value: function handleTabBehaviour(event) { |
|
if (event.keyCode !== external_this_wp_keycodes_["TAB"]) { |
|
return; |
|
} |
|
|
|
var tabbables = external_this_wp_dom_["focus"].tabbable.find(this.focusContainRef.current); |
|
|
|
if (!tabbables.length) { |
|
return; |
|
} |
|
|
|
var firstTabbable = tabbables[0]; |
|
var lastTabbable = tabbables[tabbables.length - 1]; |
|
|
|
if (event.shiftKey && event.target === firstTabbable) { |
|
event.preventDefault(); |
|
lastTabbable.focus(); |
|
} else if (!event.shiftKey && event.target === lastTabbable) { |
|
event.preventDefault(); |
|
firstTabbable.focus(); |
|
/* |
|
* When pressing Tab and none of the tabbables has focus, the keydown |
|
* event happens on the wrapper div: move focus on the first tabbable. |
|
*/ |
|
} else if (!tabbables.includes(event.target)) { |
|
event.preventDefault(); |
|
firstTabbable.focus(); |
|
} |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
// Disable reason: this component is non-interactive, but must capture |
|
// events from the wrapped component to determine when the Tab key is used. |
|
|
|
/* eslint-disable jsx-a11y/no-static-element-interactions */ |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
onKeyDown: this.handleTabBehaviour, |
|
ref: this.focusContainRef, |
|
tabIndex: "-1" |
|
}, Object(external_this_wp_element_["createElement"])(WrappedComponent, this.props)); |
|
/* eslint-enable jsx-a11y/no-static-element-interactions */ |
|
} |
|
}]); |
|
|
|
return _class; |
|
}(external_this_wp_element_["Component"]) |
|
); |
|
}, 'withConstrainedTabbing'); |
|
/* harmony default export */ var with_constrained_tabbing = (withConstrainedTabbing); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/higher-order/with-focus-outside/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Input types which are classified as button types, for use in considering |
|
* whether element is a (focus-normalized) button. |
|
* |
|
* @type {string[]} |
|
*/ |
|
|
|
var INPUT_BUTTON_TYPES = ['button', 'submit']; |
|
/** |
|
* Returns true if the given element is a button element subject to focus |
|
* normalization, or false otherwise. |
|
* |
|
* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus |
|
* |
|
* @param {Element} element Element to test. |
|
* |
|
* @return {boolean} Whether element is a button. |
|
*/ |
|
|
|
function isFocusNormalizedButton(element) { |
|
switch (element.nodeName) { |
|
case 'A': |
|
case 'BUTTON': |
|
return true; |
|
|
|
case 'INPUT': |
|
return Object(external_lodash_["includes"])(INPUT_BUTTON_TYPES, element.type); |
|
} |
|
|
|
return false; |
|
} |
|
|
|
/* harmony default export */ var with_focus_outside = (Object(external_this_wp_compose_["createHigherOrderComponent"])(function (WrappedComponent) { |
|
return ( |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(_class, _Component); |
|
|
|
function _class() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, _class); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).apply(this, arguments)); |
|
_this.bindNode = _this.bindNode.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.cancelBlurCheck = _this.cancelBlurCheck.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.queueBlurCheck = _this.queueBlurCheck.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.normalizeButtonFocus = _this.normalizeButtonFocus.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(_class, [{ |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.cancelBlurCheck(); |
|
} |
|
}, { |
|
key: "bindNode", |
|
value: function bindNode(node) { |
|
if (node) { |
|
this.node = node; |
|
} else { |
|
delete this.node; |
|
this.cancelBlurCheck(); |
|
} |
|
} |
|
}, { |
|
key: "queueBlurCheck", |
|
value: function queueBlurCheck(event) { |
|
var _this2 = this; |
|
|
|
// React does not allow using an event reference asynchronously |
|
// due to recycling behavior, except when explicitly persisted. |
|
event.persist(); // Skip blur check if clicking button. See `normalizeButtonFocus`. |
|
|
|
if (this.preventBlurCheck) { |
|
return; |
|
} |
|
|
|
this.blurCheckTimeout = setTimeout(function () { |
|
// If document is not focused then focus should remain |
|
// inside the wrapped component and therefore we cancel |
|
// this blur event thereby leaving focus in place. |
|
// https://developer.mozilla.org/en-US/docs/Web/API/Document/hasFocus. |
|
if (!document.hasFocus()) { |
|
event.preventDefault(); |
|
return; |
|
} |
|
|
|
if ('function' === typeof _this2.node.handleFocusOutside) { |
|
_this2.node.handleFocusOutside(event); |
|
} |
|
}, 0); |
|
} |
|
}, { |
|
key: "cancelBlurCheck", |
|
value: function cancelBlurCheck() { |
|
clearTimeout(this.blurCheckTimeout); |
|
} |
|
/** |
|
* Handles a mousedown or mouseup event to respectively assign and |
|
* unassign a flag for preventing blur check on button elements. Some |
|
* browsers, namely Firefox and Safari, do not emit a focus event on |
|
* button elements when clicked, while others do. The logic here |
|
* intends to normalize this as treating click on buttons as focus. |
|
* |
|
* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus |
|
* |
|
* @param {MouseEvent} event Event for mousedown or mouseup. |
|
*/ |
|
|
|
}, { |
|
key: "normalizeButtonFocus", |
|
value: function normalizeButtonFocus(event) { |
|
var type = event.type, |
|
target = event.target; |
|
var isInteractionEnd = Object(external_lodash_["includes"])(['mouseup', 'touchend'], type); |
|
|
|
if (isInteractionEnd) { |
|
this.preventBlurCheck = false; |
|
} else if (isFocusNormalizedButton(target)) { |
|
this.preventBlurCheck = true; |
|
} |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
// Disable reason: See `normalizeButtonFocus` for browser-specific |
|
// focus event normalization. |
|
|
|
/* eslint-disable jsx-a11y/no-static-element-interactions */ |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
onFocus: this.cancelBlurCheck, |
|
onMouseDown: this.normalizeButtonFocus, |
|
onMouseUp: this.normalizeButtonFocus, |
|
onTouchStart: this.normalizeButtonFocus, |
|
onTouchEnd: this.normalizeButtonFocus, |
|
onBlur: this.queueBlurCheck |
|
}, Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({ |
|
ref: this.bindNode |
|
}, this.props))); |
|
/* eslint-enable jsx-a11y/no-static-element-interactions */ |
|
} |
|
}]); |
|
|
|
return _class; |
|
}(external_this_wp_element_["Component"]) |
|
); |
|
}, 'withFocusOutside')); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/popover/detect-outside.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
var detect_outside_PopoverDetectOutside = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(PopoverDetectOutside, _Component); |
|
|
|
function PopoverDetectOutside() { |
|
Object(classCallCheck["a" /* default */])(this, PopoverDetectOutside); |
|
|
|
return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PopoverDetectOutside).apply(this, arguments)); |
|
} |
|
|
|
Object(createClass["a" /* default */])(PopoverDetectOutside, [{ |
|
key: "handleFocusOutside", |
|
value: function handleFocusOutside(event) { |
|
this.props.onFocusOutside(event); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
return this.props.children; |
|
} |
|
}]); |
|
|
|
return PopoverDetectOutside; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var detect_outside = (with_focus_outside(detect_outside_PopoverDetectOutside)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/shortcut/index.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
function Shortcut(_ref) { |
|
var shortcut = _ref.shortcut, |
|
className = _ref.className; |
|
|
|
if (!shortcut) { |
|
return null; |
|
} |
|
|
|
var displayText; |
|
var ariaLabel; |
|
|
|
if (Object(external_lodash_["isString"])(shortcut)) { |
|
displayText = shortcut; |
|
} |
|
|
|
if (Object(external_lodash_["isObject"])(shortcut)) { |
|
displayText = shortcut.display; |
|
ariaLabel = shortcut.ariaLabel; |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])("span", { |
|
className: className, |
|
"aria-label": ariaLabel |
|
}, displayText); |
|
} |
|
|
|
/* harmony default export */ var build_module_shortcut = (Shortcut); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/tooltip/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Time over children to wait before showing tooltip |
|
* |
|
* @type {number} |
|
*/ |
|
|
|
var TOOLTIP_DELAY = 700; |
|
|
|
var tooltip_Tooltip = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Tooltip, _Component); |
|
|
|
function Tooltip() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Tooltip); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Tooltip).apply(this, arguments)); |
|
_this.delayedSetIsOver = Object(external_lodash_["debounce"])(function (isOver) { |
|
return _this.setState({ |
|
isOver: isOver |
|
}); |
|
}, TOOLTIP_DELAY); |
|
/** |
|
* Prebound `isInMouseDown` handler, created as a constant reference to |
|
* assure ability to remove in component unmount. |
|
* |
|
* @type {Function} |
|
*/ |
|
|
|
_this.cancelIsMouseDown = _this.createSetIsMouseDown(false); |
|
/** |
|
* Whether a the mouse is currently pressed, used in determining whether |
|
* to handle a focus event as displaying the tooltip immediately. |
|
* |
|
* @type {boolean} |
|
*/ |
|
|
|
_this.isInMouseDown = false; |
|
_this.state = { |
|
isOver: false |
|
}; |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(Tooltip, [{ |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.delayedSetIsOver.cancel(); |
|
document.removeEventListener('mouseup', this.cancelIsMouseDown); |
|
} |
|
}, { |
|
key: "emitToChild", |
|
value: function emitToChild(eventName, event) { |
|
var children = this.props.children; |
|
|
|
if (external_this_wp_element_["Children"].count(children) !== 1) { |
|
return; |
|
} |
|
|
|
var child = external_this_wp_element_["Children"].only(children); |
|
|
|
if (typeof child.props[eventName] === 'function') { |
|
child.props[eventName](event); |
|
} |
|
} |
|
}, { |
|
key: "createToggleIsOver", |
|
value: function createToggleIsOver(eventName, isDelayed) { |
|
var _this2 = this; |
|
|
|
return function (event) { |
|
// Preserve original child callback behavior |
|
_this2.emitToChild(eventName, event); // Mouse events behave unreliably in React for disabled elements, |
|
// firing on mouseenter but not mouseleave. Further, the default |
|
// behavior for disabled elements in some browsers is to ignore |
|
// mouse events. Don't bother trying to to handle them. |
|
// |
|
// See: https://github.com/facebook/react/issues/4251 |
|
|
|
|
|
if (event.currentTarget.disabled) { |
|
return; |
|
} // A focus event will occur as a result of a mouse click, but it |
|
// should be disambiguated between interacting with the button and |
|
// using an explicit focus shift as a cue to display the tooltip. |
|
|
|
|
|
if ('focus' === event.type && _this2.isInMouseDown) { |
|
return; |
|
} // Needed in case unsetting is over while delayed set pending, i.e. |
|
// quickly blur/mouseleave before delayedSetIsOver is called |
|
|
|
|
|
_this2.delayedSetIsOver.cancel(); |
|
|
|
var isOver = Object(external_lodash_["includes"])(['focus', 'mouseenter'], event.type); |
|
|
|
if (isOver === _this2.state.isOver) { |
|
return; |
|
} |
|
|
|
if (isDelayed) { |
|
_this2.delayedSetIsOver(isOver); |
|
} else { |
|
_this2.setState({ |
|
isOver: isOver |
|
}); |
|
} |
|
}; |
|
} |
|
/** |
|
* Creates an event callback to handle assignment of the `isInMouseDown` |
|
* instance property in response to a `mousedown` or `mouseup` event. |
|
* |
|
* @param {boolean} isMouseDown Whether handler is to be created for the |
|
* `mousedown` event, as opposed to `mouseup`. |
|
* |
|
* @return {Function} Event callback handler. |
|
*/ |
|
|
|
}, { |
|
key: "createSetIsMouseDown", |
|
value: function createSetIsMouseDown(isMouseDown) { |
|
var _this3 = this; |
|
|
|
return function (event) { |
|
// Preserve original child callback behavior |
|
_this3.emitToChild(isMouseDown ? 'onMouseDown' : 'onMouseUp', event); // On mouse down, the next `mouseup` should revert the value of the |
|
// instance property and remove its own event handler. The bind is |
|
// made on the document since the `mouseup` might not occur within |
|
// the bounds of the element. |
|
|
|
|
|
document[isMouseDown ? 'addEventListener' : 'removeEventListener']('mouseup', _this3.cancelIsMouseDown); |
|
_this3.isInMouseDown = isMouseDown; |
|
}; |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
children = _this$props.children, |
|
position = _this$props.position, |
|
text = _this$props.text, |
|
shortcut = _this$props.shortcut; |
|
|
|
if (external_this_wp_element_["Children"].count(children) !== 1) { |
|
if (false) {} |
|
|
|
return children; |
|
} |
|
|
|
var child = external_this_wp_element_["Children"].only(children); |
|
var isOver = this.state.isOver; |
|
return Object(external_this_wp_element_["cloneElement"])(child, { |
|
onMouseEnter: this.createToggleIsOver('onMouseEnter', true), |
|
onMouseLeave: this.createToggleIsOver('onMouseLeave'), |
|
onClick: this.createToggleIsOver('onClick'), |
|
onFocus: this.createToggleIsOver('onFocus'), |
|
onBlur: this.createToggleIsOver('onBlur'), |
|
onMouseDown: this.createSetIsMouseDown(true), |
|
children: Object(external_this_wp_element_["concatChildren"])(child.props.children, isOver && Object(external_this_wp_element_["createElement"])(popover, { |
|
focusOnMount: false, |
|
position: position, |
|
className: "components-tooltip", |
|
"aria-hidden": "true", |
|
animate: false |
|
}, text, Object(external_this_wp_element_["createElement"])(build_module_shortcut, { |
|
className: "components-tooltip__shortcut", |
|
shortcut: shortcut |
|
}))) |
|
}); |
|
} |
|
}]); |
|
|
|
return Tooltip; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var build_module_tooltip = (tooltip_Tooltip); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/dashicon/icon-class.js |
|
var getIconClassName = function getIconClassName(icon, className) { |
|
return ['dashicon', 'dashicons-' + icon, className].filter(Boolean).join(' '); |
|
}; |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/dashicon/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* !!! |
|
IF YOU ARE EDITING dashicon/index.jsx |
|
THEN YOU ARE EDITING A FILE THAT GETS OUTPUT FROM THE DASHICONS REPO! |
|
DO NOT EDIT THAT FILE! EDIT index-header.jsx and index-footer.jsx instead |
|
OR if you're looking to change now SVGs get output, you'll need to edit strings in the Gruntfile :) |
|
!!! */ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
var dashicon_Dashicon = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Dashicon, _Component); |
|
|
|
function Dashicon() { |
|
Object(classCallCheck["a" /* default */])(this, Dashicon); |
|
|
|
return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Dashicon).apply(this, arguments)); |
|
} |
|
|
|
Object(createClass["a" /* default */])(Dashicon, [{ |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
icon = _this$props.icon, |
|
_this$props$size = _this$props.size, |
|
size = _this$props$size === void 0 ? 20 : _this$props$size, |
|
className = _this$props.className, |
|
ariaPressed = _this$props.ariaPressed, |
|
extraProps = Object(objectWithoutProperties["a" /* default */])(_this$props, ["icon", "size", "className", "ariaPressed"]); |
|
|
|
var path; |
|
|
|
switch (icon) { |
|
case 'admin-appearance': |
|
path = 'M14.48 11.06L7.41 3.99l1.5-1.5c.5-.56 2.3-.47 3.51.32 1.21.8 1.43 1.28 2.91 2.1 1.18.64 2.45 1.26 4.45.85zm-.71.71L6.7 4.7 4.93 6.47c-.39.39-.39 1.02 0 1.41l1.06 1.06c.39.39.39 1.03 0 1.42-.6.6-1.43 1.11-2.21 1.69-.35.26-.7.53-1.01.84C1.43 14.23.4 16.08 1.4 17.07c.99 1 2.84-.03 4.18-1.36.31-.31.58-.66.85-1.02.57-.78 1.08-1.61 1.69-2.21.39-.39 1.02-.39 1.41 0l1.06 1.06c.39.39 1.02.39 1.41 0z'; |
|
break; |
|
|
|
case 'admin-collapse': |
|
path = 'M10 2.16c4.33 0 7.84 3.51 7.84 7.84s-3.51 7.84-7.84 7.84S2.16 14.33 2.16 10 5.71 2.16 10 2.16zm2 11.72V6.12L6.18 9.97z'; |
|
break; |
|
|
|
case 'admin-comments': |
|
path = 'M5 2h9c1.1 0 2 .9 2 2v7c0 1.1-.9 2-2 2h-2l-5 5v-5H5c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2z'; |
|
break; |
|
|
|
case 'admin-customizer': |
|
path = 'M18.33 3.57s.27-.8-.31-1.36c-.53-.52-1.22-.24-1.22-.24-.61.3-5.76 3.47-7.67 5.57-.86.96-2.06 3.79-1.09 4.82.92.98 3.96-.17 4.79-1 2.06-2.06 5.21-7.17 5.5-7.79zM1.4 17.65c2.37-1.56 1.46-3.41 3.23-4.64.93-.65 2.22-.62 3.08.29.63.67.8 2.57-.16 3.46-1.57 1.45-4 1.55-6.15.89z'; |
|
break; |
|
|
|
case 'admin-generic': |
|
path = 'M18 12h-2.18c-.17.7-.44 1.35-.81 1.93l1.54 1.54-2.1 2.1-1.54-1.54c-.58.36-1.23.63-1.91.79V19H8v-2.18c-.68-.16-1.33-.43-1.91-.79l-1.54 1.54-2.12-2.12 1.54-1.54c-.36-.58-.63-1.23-.79-1.91H1V9.03h2.17c.16-.7.44-1.35.8-1.94L2.43 5.55l2.1-2.1 1.54 1.54c.58-.37 1.24-.64 1.93-.81V2h3v2.18c.68.16 1.33.43 1.91.79l1.54-1.54 2.12 2.12-1.54 1.54c.36.59.64 1.24.8 1.94H18V12zm-8.5 1.5c1.66 0 3-1.34 3-3s-1.34-3-3-3-3 1.34-3 3 1.34 3 3 3z'; |
|
break; |
|
|
|
case 'admin-home': |
|
path = 'M16 8.5l1.53 1.53-1.06 1.06L10 4.62l-6.47 6.47-1.06-1.06L10 2.5l4 4v-2h2v4zm-6-2.46l6 5.99V18H4v-5.97zM12 17v-5H8v5h4z'; |
|
break; |
|
|
|
case 'admin-links': |
|
path = 'M17.74 2.76c1.68 1.69 1.68 4.41 0 6.1l-1.53 1.52c-1.12 1.12-2.7 1.47-4.14 1.09l2.62-2.61.76-.77.76-.76c.84-.84.84-2.2 0-3.04-.84-.85-2.2-.85-3.04 0l-.77.76-3.38 3.38c-.37-1.44-.02-3.02 1.1-4.14l1.52-1.53c1.69-1.68 4.42-1.68 6.1 0zM8.59 13.43l5.34-5.34c.42-.42.42-1.1 0-1.52-.44-.43-1.13-.39-1.53 0l-5.33 5.34c-.42.42-.42 1.1 0 1.52.44.43 1.13.39 1.52 0zm-.76 2.29l4.14-4.15c.38 1.44.03 3.02-1.09 4.14l-1.52 1.53c-1.69 1.68-4.41 1.68-6.1 0-1.68-1.68-1.68-4.42 0-6.1l1.53-1.52c1.12-1.12 2.7-1.47 4.14-1.1l-4.14 4.15c-.85.84-.85 2.2 0 3.05.84.84 2.2.84 3.04 0z'; |
|
break; |
|
|
|
case 'admin-media': |
|
path = 'M13 11V4c0-.55-.45-1-1-1h-1.67L9 1H5L3.67 3H2c-.55 0-1 .45-1 1v7c0 .55.45 1 1 1h10c.55 0 1-.45 1-1zM7 4.5c1.38 0 2.5 1.12 2.5 2.5S8.38 9.5 7 9.5 4.5 8.38 4.5 7 5.62 4.5 7 4.5zM14 6h5v10.5c0 1.38-1.12 2.5-2.5 2.5S14 17.88 14 16.5s1.12-2.5 2.5-2.5c.17 0 .34.02.5.05V9h-3V6zm-4 8.05V13h2v3.5c0 1.38-1.12 2.5-2.5 2.5S7 17.88 7 16.5 8.12 14 9.5 14c.17 0 .34.02.5.05z'; |
|
break; |
|
|
|
case 'admin-multisite': |
|
path = 'M14.27 6.87L10 3.14 5.73 6.87 5 6.14l5-4.38 5 4.38zM14 8.42l-4.05 3.43L6 8.38v-.74l4-3.5 4 3.5v.78zM11 9.7V8H9v1.7h2zm-1.73 4.03L5 10 .73 13.73 0 13l5-4.38L10 13zm10 0L15 10l-4.27 3.73L10 13l5-4.38L20 13zM5 11l4 3.5V18H1v-3.5zm10 0l4 3.5V18h-8v-3.5zm-9 6v-2H4v2h2zm10 0v-2h-2v2h2z'; |
|
break; |
|
|
|
case 'admin-network': |
|
path = 'M16.95 2.58c1.96 1.95 1.96 5.12 0 7.07-1.51 1.51-3.75 1.84-5.59 1.01l-1.87 3.31-2.99.31L5 18H2l-1-2 7.95-7.69c-.92-1.87-.62-4.18.93-5.73 1.95-1.96 5.12-1.96 7.07 0zm-2.51 3.79c.74 0 1.33-.6 1.33-1.34 0-.73-.59-1.33-1.33-1.33-.73 0-1.33.6-1.33 1.33 0 .74.6 1.34 1.33 1.34z'; |
|
break; |
|
|
|
case 'admin-page': |
|
path = 'M6 15V2h10v13H6zm-1 1h8v2H3V5h2v11z'; |
|
break; |
|
|
|
case 'admin-plugins': |
|
path = 'M13.11 4.36L9.87 7.6 8 5.73l3.24-3.24c.35-.34 1.05-.2 1.56.32.52.51.66 1.21.31 1.55zm-8 1.77l.91-1.12 9.01 9.01-1.19.84c-.71.71-2.63 1.16-3.82 1.16H6.14L4.9 17.26c-.59.59-1.54.59-2.12 0-.59-.58-.59-1.53 0-2.12l1.24-1.24v-3.88c0-1.13.4-3.19 1.09-3.89zm7.26 3.97l3.24-3.24c.34-.35 1.04-.21 1.55.31.52.51.66 1.21.31 1.55l-3.24 3.25z'; |
|
break; |
|
|
|
case 'admin-post': |
|
path = 'M10.44 3.02l1.82-1.82 6.36 6.35-1.83 1.82c-1.05-.68-2.48-.57-3.41.36l-.75.75c-.92.93-1.04 2.35-.35 3.41l-1.83 1.82-2.41-2.41-2.8 2.79c-.42.42-3.38 2.71-3.8 2.29s1.86-3.39 2.28-3.81l2.79-2.79L4.1 9.36l1.83-1.82c1.05.69 2.48.57 3.4-.36l.75-.75c.93-.92 1.05-2.35.36-3.41z'; |
|
break; |
|
|
|
case 'admin-settings': |
|
path = 'M18 16V4c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h13c.55 0 1-.45 1-1zM8 11h1c.55 0 1 .45 1 1s-.45 1-1 1H8v1.5c0 .28-.22.5-.5.5s-.5-.22-.5-.5V13H6c-.55 0-1-.45-1-1s.45-1 1-1h1V5.5c0-.28.22-.5.5-.5s.5.22.5.5V11zm5-2h-1c-.55 0-1-.45-1-1s.45-1 1-1h1V5.5c0-.28.22-.5.5-.5s.5.22.5.5V7h1c.55 0 1 .45 1 1s-.45 1-1 1h-1v5.5c0 .28-.22.5-.5.5s-.5-.22-.5-.5V9z'; |
|
break; |
|
|
|
case 'admin-site-alt': |
|
path = 'M9 0C4.03 0 0 4.03 0 9s4.03 9 9 9 9-4.03 9-9-4.03-9-9-9zm7.5 6.48c-.274.896-.908 1.64-1.75 2.05-.45-1.69-1.658-3.074-3.27-3.75.13-.444.41-.83.79-1.09-.43-.28-1-.42-1.34.07-.53.69 0 1.61.21 2v.14c-.555-.337-.99-.84-1.24-1.44-.966-.03-1.922.208-2.76.69-.087-.565-.032-1.142.16-1.68.733.07 1.453-.23 1.92-.8.46-.52-.13-1.18-.59-1.58h.36c1.36-.01 2.702.335 3.89 1 1.36 1.005 2.194 2.57 2.27 4.26.24 0 .7-.55.91-.92.172.34.32.69.44 1.05zM9 16.84c-2.05-2.08.25-3.75-1-5.24-.92-.85-2.29-.26-3.11-1.23-.282-1.473.267-2.982 1.43-3.93.52-.44 4-1 5.42.22.83.715 1.415 1.674 1.67 2.74.46.035.918-.066 1.32-.29.41 2.98-3.15 6.74-5.73 7.73zM5.15 2.09c.786-.3 1.676-.028 2.16.66-.42.38-.94.63-1.5.72.02-.294.085-.584.19-.86l-.85-.52z'; |
|
break; |
|
|
|
case 'admin-site-alt2': |
|
path = 'M9 0C4.03 0 0 4.03 0 9s4.03 9 9 9 9-4.03 9-9-4.03-9-9-9zm2.92 12.34c0 .35.14.63.36.66.22.03.47-.22.58-.6l.2.08c.718.384 1.07 1.22.84 2-.15.69-.743 1.198-1.45 1.24-.49-1.21-2.11.06-3.56-.22-.612-.154-1.11-.6-1.33-1.19 1.19-.11 2.85-1.73 4.36-1.97zM8 11.27c.918 0 1.695-.68 1.82-1.59.44.54.41 1.324-.07 1.83-.255.223-.594.325-.93.28-.335-.047-.635-.236-.82-.52zm3-.76c.41.39 3-.06 3.52 1.09-.95-.2-2.95.61-3.47-1.08l-.05-.01zM9.73 5.45v.27c-.65-.77-1.33-1.07-1.61-.57-.28.5 1 1.11.76 1.88-.24.77-1.27.56-1.88 1.61-.61 1.05-.49 2.42 1.24 3.67-1.192-.132-2.19-.962-2.54-2.11-.4-1.2-.09-2.26-.78-2.46C4 7.46 3 8.71 3 9.8c-1.26-1.26.05-2.86-1.2-4.18C3.5 1.998 7.644.223 11.44 1.49c-1.1 1.02-1.722 2.458-1.71 3.96z'; |
|
break; |
|
|
|
case 'admin-site-alt3': |
|
path = 'M9 0C4.03 0 0 4.03 0 9s4.03 9 9 9 9-4.03 9-9-4.03-9-9-9zM1.11 9.68h2.51c.04.91.167 1.814.38 2.7H1.84c-.403-.85-.65-1.764-.73-2.7zm8.57-5.4V1.19c.964.366 1.756 1.08 2.22 2 .205.347.386.708.54 1.08l-2.76.01zm3.22 1.35c.232.883.37 1.788.41 2.7H9.68v-2.7h3.22zM8.32 1.19v3.09H5.56c.154-.372.335-.733.54-1.08.462-.924 1.255-1.64 2.22-2.01zm0 4.44v2.7H4.7c.04-.912.178-1.817.41-2.7h3.21zm-4.7 2.69H1.11c.08-.936.327-1.85.73-2.7H4c-.213.886-.34 1.79-.38 2.7zM4.7 9.68h3.62v2.7H5.11c-.232-.883-.37-1.788-.41-2.7zm3.63 4v3.09c-.964-.366-1.756-1.08-2.22-2-.205-.347-.386-.708-.54-1.08l2.76-.01zm1.35 3.09v-3.04h2.76c-.154.372-.335.733-.54 1.08-.464.92-1.256 1.634-2.22 2v-.04zm0-4.44v-2.7h3.62c-.04.912-.178 1.817-.41 2.7H9.68zm4.71-2.7h2.51c-.08.936-.327 1.85-.73 2.7H14c.21-.87.337-1.757.38-2.65l.01-.05zm0-1.35c-.046-.894-.176-1.78-.39-2.65h2.16c.403.85.65 1.764.73 2.7l-2.5-.05zm1-4H13.6c-.324-.91-.793-1.76-1.39-2.52 1.244.56 2.325 1.426 3.14 2.52h.04zm-9.6-2.52c-.597.76-1.066 1.61-1.39 2.52H2.65c.815-1.094 1.896-1.96 3.14-2.52zm-3.15 12H4.4c.324.91.793 1.76 1.39 2.52-1.248-.567-2.33-1.445-3.14-2.55l-.01.03zm9.56 2.52c.597-.76 1.066-1.61 1.39-2.52h1.76c-.82 1.08-1.9 1.933-3.14 2.48l-.01.04z'; |
|
break; |
|
|
|
case 'admin-site': |
|
path = 'M9 0C4.03 0 0 4.03 0 9s4.03 9 9 9 9-4.03 9-9-4.03-9-9-9zm3.46 11.95c0 1.47-.8 3.3-4.06 4.7.3-4.17-2.52-3.69-3.2-5 .126-1.1.804-2.063 1.8-2.55-1.552-.266-3-.96-4.18-2 .05.47.28.904.64 1.21-.782-.295-1.458-.817-1.94-1.5.977-3.225 3.883-5.482 7.25-5.63-.84 1.38-1.5 4.13 0 5.57C7.23 7 6.26 5 5.41 5.79c-1.13 1.06.33 2.51 3.42 3.08 3.29.59 3.66 1.58 3.63 3.08zm1.34-4c-.32-1.11.62-2.23 1.69-3.14 1.356 1.955 1.67 4.45.84 6.68-.77-1.89-2.17-2.32-2.53-3.57v.03z'; |
|
break; |
|
|
|
case 'admin-tools': |
|
path = 'M16.68 9.77c-1.34 1.34-3.3 1.67-4.95.99l-5.41 6.52c-.99.99-2.59.99-3.58 0s-.99-2.59 0-3.57l6.52-5.42c-.68-1.65-.35-3.61.99-4.95 1.28-1.28 3.12-1.62 4.72-1.06l-2.89 2.89 2.82 2.82 2.86-2.87c.53 1.58.18 3.39-1.08 4.65zM3.81 16.21c.4.39 1.04.39 1.43 0 .4-.4.4-1.04 0-1.43-.39-.4-1.03-.4-1.43 0-.39.39-.39 1.03 0 1.43z'; |
|
break; |
|
|
|
case 'admin-users': |
|
path = 'M10 9.25c-2.27 0-2.73-3.44-2.73-3.44C7 4.02 7.82 2 9.97 2c2.16 0 2.98 2.02 2.71 3.81 0 0-.41 3.44-2.68 3.44zm0 2.57L12.72 10c2.39 0 4.52 2.33 4.52 4.53v2.49s-3.65 1.13-7.24 1.13c-3.65 0-7.24-1.13-7.24-1.13v-2.49c0-2.25 1.94-4.48 4.47-4.48z'; |
|
break; |
|
|
|
case 'album': |
|
path = 'M0 18h10v-.26c1.52.4 3.17.35 4.76-.24 4.14-1.52 6.27-6.12 4.75-10.26-1.43-3.89-5.58-6-9.51-4.98V2H0v16zM9 3v14H1V3h8zm5.45 8.22c-.68 1.35-2.32 1.9-3.67 1.23-.31-.15-.57-.35-.78-.59V8.13c.8-.86 2.11-1.13 3.22-.58 1.35.68 1.9 2.32 1.23 3.67zm-2.75-.82c.22.16.53.12.7-.1.16-.22.12-.53-.1-.7s-.53-.12-.7.1c-.16.21-.12.53.1.7zm3.01 3.67c-1.17.78-2.56.99-3.83.69-.27-.06-.44-.34-.37-.61s.34-.43.62-.36l.17.04c.96.17 1.98-.01 2.86-.59.47-.32.86-.72 1.14-1.18.15-.23.45-.3.69-.16.23.15.3.46.16.69-.36.57-.84 1.08-1.44 1.48zm1.05 1.57c-1.48.99-3.21 1.32-4.84 1.06-.28-.05-.47-.32-.41-.6.05-.27.32-.45.61-.39l.22.04c1.31.15 2.68-.14 3.87-.94.71-.47 1.27-1.07 1.7-1.74.14-.24.45-.31.68-.16.24.14.31.45.16.69-.49.79-1.16 1.49-1.99 2.04z'; |
|
break; |
|
|
|
case 'align-center': |
|
path = 'M3 5h14V3H3v2zm12 8V7H5v6h10zM3 17h14v-2H3v2z'; |
|
break; |
|
|
|
case 'align-full-width': |
|
path = 'M17 13V3H3v10h14zM5 17h10v-2H5v2z'; |
|
break; |
|
|
|
case 'align-left': |
|
path = 'M3 5h14V3H3v2zm9 8V7H3v6h9zm2-4h3V7h-3v2zm0 4h3v-2h-3v2zM3 17h14v-2H3v2z'; |
|
break; |
|
|
|
case 'align-none': |
|
path = 'M3 5h14V3H3v2zm10 8V7H3v6h10zM3 17h14v-2H3v2z'; |
|
break; |
|
|
|
case 'align-pull-left': |
|
path = 'M9 16V4H3v12h6zm2-7h6V7h-6v2zm0 4h6v-2h-6v2z'; |
|
break; |
|
|
|
case 'align-pull-right': |
|
path = 'M17 16V4h-6v12h6zM9 7H3v2h6V7zm0 4H3v2h6v-2z'; |
|
break; |
|
|
|
case 'align-right': |
|
path = 'M3 5h14V3H3v2zm0 4h3V7H3v2zm14 4V7H8v6h9zM3 13h3v-2H3v2zm0 4h14v-2H3v2z'; |
|
break; |
|
|
|
case 'align-wide': |
|
path = 'M5 5h10V3H5v2zm12 8V7H3v6h14zM5 17h10v-2H5v2z'; |
|
break; |
|
|
|
case 'analytics': |
|
path = 'M18 18V2H2v16h16zM16 5H4V4h12v1zM7 7v3h3c0 1.66-1.34 3-3 3s-3-1.34-3-3 1.34-3 3-3zm1 2V7c1.1 0 2 .9 2 2H8zm8-1h-4V7h4v1zm0 3h-4V9h4v2zm0 2h-4v-1h4v1zm0 3H4v-1h12v1z'; |
|
break; |
|
|
|
case 'archive': |
|
path = 'M19 4v2H1V4h18zM2 7h16v10H2V7zm11 3V9H7v1h6z'; |
|
break; |
|
|
|
case 'arrow-down-alt': |
|
path = 'M9 2h2v12l4-4 2 1-7 7-7-7 2-1 4 4V2z'; |
|
break; |
|
|
|
case 'arrow-down-alt2': |
|
path = 'M5 6l5 5 5-5 2 1-7 7-7-7z'; |
|
break; |
|
|
|
case 'arrow-down': |
|
path = 'M15 8l-4.03 6L7 8h8z'; |
|
break; |
|
|
|
case 'arrow-left-alt': |
|
path = 'M18 9v2H6l4 4-1 2-7-7 7-7 1 2-4 4h12z'; |
|
break; |
|
|
|
case 'arrow-left-alt2': |
|
path = 'M14 5l-5 5 5 5-1 2-7-7 7-7z'; |
|
break; |
|
|
|
case 'arrow-left': |
|
path = 'M13 14L7 9.97 13 6v8z'; |
|
break; |
|
|
|
case 'arrow-right-alt': |
|
path = 'M2 11V9h12l-4-4 1-2 7 7-7 7-1-2 4-4H2z'; |
|
break; |
|
|
|
case 'arrow-right-alt2': |
|
path = 'M6 15l5-5-5-5 1-2 7 7-7 7z'; |
|
break; |
|
|
|
case 'arrow-right': |
|
path = 'M8 6l6 4.03L8 14V6z'; |
|
break; |
|
|
|
case 'arrow-up-alt': |
|
path = 'M11 18H9V6l-4 4-2-1 7-7 7 7-2 1-4-4v12z'; |
|
break; |
|
|
|
case 'arrow-up-alt2': |
|
path = 'M15 14l-5-5-5 5-2-1 7-7 7 7z'; |
|
break; |
|
|
|
case 'arrow-up': |
|
path = 'M7 13l4.03-6L15 13H7z'; |
|
break; |
|
|
|
case 'art': |
|
path = 'M8.55 3.06c1.01.34-1.95 2.01-.1 3.13 1.04.63 3.31-2.22 4.45-2.86.97-.54 2.67-.65 3.53 1.23 1.09 2.38.14 8.57-3.79 11.06-3.97 2.5-8.97 1.23-10.7-2.66-2.01-4.53 3.12-11.09 6.61-9.9zm1.21 6.45c.73 1.64 4.7-.5 3.79-2.8-.59-1.49-4.48 1.25-3.79 2.8z'; |
|
break; |
|
|
|
case 'awards': |
|
path = 'M4.46 5.16L5 7.46l-.54 2.29 2.01 1.24L7.7 13l2.3-.54 2.3.54 1.23-2.01 2.01-1.24L15 7.46l.54-2.3-2-1.24-1.24-2.01-2.3.55-2.29-.54-1.25 2zm5.55 6.34C7.79 11.5 6 9.71 6 7.49c0-2.2 1.79-3.99 4.01-3.99 2.2 0 3.99 1.79 3.99 3.99 0 2.22-1.79 4.01-3.99 4.01zm-.02-1C8.33 10.5 7 9.16 7 7.5c0-1.65 1.33-3 2.99-3S13 5.85 13 7.5c0 1.66-1.35 3-3.01 3zm3.84 1.1l-1.28 2.24-2.08-.47L13 19.2l1.4-2.2h2.5zm-7.7.07l1.25 2.25 2.13-.51L7 19.2 5.6 17H3.1z'; |
|
break; |
|
|
|
case 'backup': |
|
path = 'M13.65 2.88c3.93 2.01 5.48 6.84 3.47 10.77s-6.83 5.48-10.77 3.47c-1.87-.96-3.2-2.56-3.86-4.4l1.64-1.03c.45 1.57 1.52 2.95 3.08 3.76 3.01 1.54 6.69.35 8.23-2.66 1.55-3.01.36-6.69-2.65-8.24C9.78 3.01 6.1 4.2 4.56 7.21l1.88.97-4.95 3.08-.39-5.82 1.78.91C4.9 2.4 9.75.89 13.65 2.88zm-4.36 7.83C9.11 10.53 9 10.28 9 10c0-.07.03-.12.04-.19h-.01L10 5l.97 4.81L14 13l-4.5-2.12.02-.02c-.08-.04-.16-.09-.23-.15z'; |
|
break; |
|
|
|
case 'block-default': |
|
path = 'M15 6V4h-3v2H8V4H5v2H4c-.6 0-1 .4-1 1v8h14V7c0-.6-.4-1-1-1h-1z'; |
|
break; |
|
|
|
case 'book-alt': |
|
path = 'M5 17h13v2H5c-1.66 0-3-1.34-3-3V4c0-1.66 1.34-3 3-3h13v14H5c-.55 0-1 .45-1 1s.45 1 1 1zm2-3.5v-11c0-.28-.22-.5-.5-.5s-.5.22-.5.5v11c0 .28.22.5.5.5s.5-.22.5-.5z'; |
|
break; |
|
|
|
case 'book': |
|
path = 'M16 3h2v16H5c-1.66 0-3-1.34-3-3V4c0-1.66 1.34-3 3-3h9v14H5c-.55 0-1 .45-1 1s.45 1 1 1h11V3z'; |
|
break; |
|
|
|
case 'buddicons-activity': |
|
path = 'M8 1v7h2V6c0-1.52 1.45-3 3-3v.86c.55-.52 1.26-.86 2-.86v3h1c1.1 0 2 .9 2 2s-.9 2-2 2h-1v6c0 .55-.45 1-1 1s-1-.45-1-1v-2.18c-.31.11-.65.18-1 .18v2c0 .55-.45 1-1 1s-1-.45-1-1v-2H8v2c0 .55-.45 1-1 1s-1-.45-1-1v-2c-.35 0-.69-.07-1-.18V16c0 .55-.45 1-1 1s-1-.45-1-1v-4H2v-1c0-1.66 1.34-3 3-3h2V1h1zm5 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1z'; |
|
break; |
|
|
|
case 'buddicons-bbpress-logo': |
|
path = 'M8.5 12.6c.3-1.3 0-2.3-1.1-2.3-.8 0-1.6.6-1.8 1.5l-.3 1.7c-.3 1 .3 1.5 1 1.5 1.2 0 1.9-1.1 2.2-2.4zm-4-6.4C3.7 7.3 3.3 8.6 3.3 10c0 1 .2 1.9.6 2.8l1-4.6c.3-1.7.4-2-.4-2zm9.3 6.4c.3-1.3 0-2.3-1.1-2.3-.8 0-1.6.6-1.8 1.5l-.4 1.7c-.2 1.1.4 1.6 1.1 1.6 1.1-.1 1.9-1.2 2.2-2.5zM10 3.3c-2 0-3.9.9-5.1 2.3.6-.1 1.4-.2 1.8-.3.2 0 .2.1.2.2 0 .2-1 4.8-1 4.8.5-.3 1.2-.7 1.8-.7.9 0 1.5.4 1.9.9l.5-2.4c.4-1.6.4-1.9-.4-1.9-.4 0-.4-.5 0-.6.6-.1 1.8-.2 2.3-.3.2 0 .2.1.2.2l-1 4.8c.5-.4 1.2-.7 1.9-.7 1.7 0 2.5 1.3 2.1 3-.3 1.7-2 3-3.8 3-1.3 0-2.1-.7-2.3-1.4-.7.8-1.7 1.3-2.8 1.4 1.1.7 2.4 1.1 3.7 1.1 3.7 0 6.7-3 6.7-6.7s-3-6.7-6.7-6.7zM10 2c-4.4 0-8 3.6-8 8s3.6 8 8 8 8-3.6 8-8-3.6-8-8-8zm0 15.5c-2.1 0-4-.8-5.3-2.2-.3-.4-.7-.8-1-1.2-.7-1.2-1.2-2.6-1.2-4.1 0-4.1 3.4-7.5 7.5-7.5s7.5 3.4 7.5 7.5-3.4 7.5-7.5 7.5z'; |
|
break; |
|
|
|
case 'buddicons-buddypress-logo': |
|
path = 'M10 0c5.52 0 10 4.48 10 10s-4.48 10-10 10S0 15.52 0 10 4.48 0 10 0zm0 .5C4.75.5.5 4.75.5 10s4.25 9.5 9.5 9.5 9.5-4.25 9.5-9.5S15.25.5 10 .5zm0 1c4.7 0 8.5 3.8 8.5 8.5s-3.8 8.5-8.5 8.5-8.5-3.8-8.5-8.5S5.3 1.5 10 1.5zm1.8 1.71c-.57 0-1.1.17-1.55.45 1.56.37 2.73 1.77 2.73 3.45 0 .69-.21 1.33-.55 1.87 1.31-.29 2.29-1.45 2.29-2.85 0-1.61-1.31-2.92-2.92-2.92zm-2.38 1c-1.61 0-2.92 1.31-2.92 2.93 0 1.61 1.31 2.92 2.92 2.92 1.62 0 2.93-1.31 2.93-2.92 0-1.62-1.31-2.93-2.93-2.93zm4.25 5.01l-.51.59c2.34.69 2.45 3.61 2.45 3.61h1.28c0-4.71-3.22-4.2-3.22-4.2zm-2.1.8l-2.12 2.09-2.12-2.09C3.12 10.24 3.89 15 3.89 15h11.08c.47-4.98-3.4-4.98-3.4-4.98z'; |
|
break; |
|
|
|
case 'buddicons-community': |
|
path = 'M9 3c0-.67-.47-1.43-1-2-.5.5-1 1.38-1 2 0 .48.45 1 1 1s1-.47 1-1zm4 0c0-.67-.47-1.43-1-2-.5.5-1 1.38-1 2 0 .48.45 1 1 1s1-.47 1-1zM9 9V5.5c0-.55-.45-1-1-1-.57 0-1 .49-1 1V9c0 .55.45 1 1 1 .57 0 1-.49 1-1zm4 0V5.5c0-.55-.45-1-1-1-.57 0-1 .49-1 1V9c0 .55.45 1 1 1 .57 0 1-.49 1-1zm4 1c0-1.48-1.41-2.77-3.5-3.46V9c0 .83-.67 1.5-1.5 1.5s-1.5-.67-1.5-1.5V6.01c-.17 0-.33-.01-.5-.01s-.33.01-.5.01V9c0 .83-.67 1.5-1.5 1.5S6.5 9.83 6.5 9V6.54C4.41 7.23 3 8.52 3 10c0 1.41.95 2.65 3.21 3.37 1.11.35 2.39 1.12 3.79 1.12s2.69-.78 3.79-1.13C16.04 12.65 17 11.41 17 10zm-7 5.43c1.43 0 2.74-.79 3.88-1.11 1.9-.53 2.49-1.34 3.12-2.32v3c0 2.21-3.13 4-7 4s-7-1.79-7-4v-3c.64.99 1.32 1.8 3.15 2.33 1.13.33 2.44 1.1 3.85 1.1z'; |
|
break; |
|
|
|
case 'buddicons-forums': |
|
path = 'M13.5 7h-7C5.67 7 5 6.33 5 5.5S5.67 4 6.5 4h1.59C8.04 3.84 8 3.68 8 3.5 8 2.67 8.67 2 9.5 2h1c.83 0 1.5.67 1.5 1.5 0 .18-.04.34-.09.5h1.59c.83 0 1.5.67 1.5 1.5S14.33 7 13.5 7zM4 8h12c.55 0 1 .45 1 1s-.45 1-1 1H4c-.55 0-1-.45-1-1s.45-1 1-1zm1 3h10c.55 0 1 .45 1 1s-.45 1-1 1H5c-.55 0-1-.45-1-1s.45-1 1-1zm2 3h6c.55 0 1 .45 1 1s-.45 1-1 1h-1.09c.05.16.09.32.09.5 0 .83-.67 1.5-1.5 1.5h-1c-.83 0-1.5-.67-1.5-1.5 0-.18.04-.34.09-.5H7c-.55 0-1-.45-1-1s.45-1 1-1z'; |
|
break; |
|
|
|
case 'buddicons-friends': |
|
path = 'M8.75 5.77C8.75 4.39 7 2 7 2S5.25 4.39 5.25 5.77 5.9 7.5 7 7.5s1.75-.35 1.75-1.73zm6 0C14.75 4.39 13 2 13 2s-1.75 2.39-1.75 3.77S11.9 7.5 13 7.5s1.75-.35 1.75-1.73zM9 17V9c0-.55-.45-1-1-1H6c-.55 0-1 .45-1 1v8c0 .55.45 1 1 1h2c.55 0 1-.45 1-1zm6 0V9c0-.55-.45-1-1-1h-2c-.55 0-1 .45-1 1v8c0 .55.45 1 1 1h2c.55 0 1-.45 1-1zm-9-6l2-1v2l-2 1v-2zm6 0l2-1v2l-2 1v-2zm-6 3l2-1v2l-2 1v-2zm6 0l2-1v2l-2 1v-2z'; |
|
break; |
|
|
|
case 'buddicons-groups': |
|
path = 'M15.45 6.25c1.83.94 1.98 3.18.7 4.98-.8 1.12-2.33 1.88-3.46 1.78L10.05 18H9l-2.65-4.99c-1.13.16-2.73-.63-3.55-1.79-1.28-1.8-1.13-4.04.71-4.97.48-.24.96-.33 1.43-.31-.01.4.01.8.07 1.21.26 1.69 1.41 3.53 2.86 4.37-.19.55-.49.99-.88 1.25L9 16.58v-5.66C7.64 10.55 6.26 8.76 6 7c-.4-2.65 1-5 3.5-5s3.9 2.35 3.5 5c-.26 1.76-1.64 3.55-3 3.92v5.77l2.07-3.84c-.44-.23-.77-.71-.99-1.3 1.48-.83 2.65-2.69 2.91-4.4.06-.41.08-.82.07-1.22.46-.01.92.08 1.39.32z'; |
|
break; |
|
|
|
case 'buddicons-pm': |
|
path = 'M10 2c3 0 8 5 8 5v11H2V7s5-5 8-5zm7 14.72l-3.73-2.92L17 11l-.43-.37-2.26 1.3.24-4.31-8.77-.52-.46 4.54-1.99-.95L3 11l3.73 2.8-3.44 2.85.4.43L10 13l6.53 4.15z'; |
|
break; |
|
|
|
case 'buddicons-replies': |
|
path = 'M17.54 10.29c1.17 1.17 1.17 3.08 0 4.25-1.18 1.17-3.08 1.17-4.25 0l-.34-.52c0 3.66-2 4.38-2.95 4.98-.82-.6-2.95-1.28-2.95-4.98l-.34.52c-1.17 1.17-3.07 1.17-4.25 0-1.17-1.17-1.17-3.08 0-4.25 0 0 1.02-.67 2.1-1.3C3.71 7.84 3.2 6.42 3.2 4.88c0-.34.03-.67.08-1C3.53 5.66 4.47 7.22 5.8 8.3c.67-.35 1.85-.83 2.37-.92H8c-1.1 0-2-.9-2-2s.9-2 2-2v-.5c0-.28.22-.5.5-.5s.5.22.5.5v.5h2v-.5c0-.28.22-.5.5-.5s.5.22.5.5v.5c1.1 0 2 .9 2 2s-.9 2-2 2h-.17c.51.09 1.78.61 2.38.92 1.33-1.08 2.27-2.64 2.52-4.42.05.33.08.66.08 1 0 1.54-.51 2.96-1.36 4.11 1.08.63 2.09 1.3 2.09 1.3zM8.5 6.38c.5 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm3-2c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm-2.3 5.73c-.12.11-.19.26-.19.43.02.25.23.46.49.46h1c.26 0 .47-.21.49-.46 0-.15-.07-.29-.19-.43-.08-.06-.18-.11-.3-.11h-1c-.12 0-.22.05-.3.11zM12 12.5c0-.12-.06-.28-.19-.38-.09-.07-.19-.12-.31-.12h-3c-.12 0-.22.05-.31.12-.11.1-.19.25-.19.38 0 .28.22.5.5.5h3c.28 0 .5-.22.5-.5zM8.5 15h3c.28 0 .5-.22.5-.5s-.22-.5-.5-.5h-3c-.28 0-.5.22-.5.5s.22.5.5.5zm1 2h1c.28 0 .5-.22.5-.5s-.22-.5-.5-.5h-1c-.28 0-.5.22-.5.5s.22.5.5.5z'; |
|
break; |
|
|
|
case 'buddicons-topics': |
|
path = 'M10.44 1.66c-.59-.58-1.54-.58-2.12 0L2.66 7.32c-.58.58-.58 1.53 0 2.12.6.6 1.56.56 2.12 0l5.66-5.66c.58-.58.59-1.53 0-2.12zm2.83 2.83c-.59-.59-1.54-.59-2.12 0l-5.66 5.66c-.59.58-.59 1.53 0 2.12.6.6 1.56.55 2.12 0l5.66-5.66c.58-.58.58-1.53 0-2.12zm1.06 6.72l4.18 4.18c.59.58.59 1.53 0 2.12s-1.54.59-2.12 0l-4.18-4.18-1.77 1.77c-.59.58-1.54.58-2.12 0-.59-.59-.59-1.54 0-2.13l5.66-5.65c.58-.59 1.53-.59 2.12 0 .58.58.58 1.53 0 2.12zM5 15c0-1.59-1.66-4-1.66-4S2 13.78 2 15s.6 2 1.34 2h.32C4.4 17 5 16.59 5 15z'; |
|
break; |
|
|
|
case 'buddicons-tracking': |
|
path = 'M10.98 6.78L15.5 15c-1 2-3.5 3-5.5 3s-4.5-1-5.5-3L9 6.82c-.75-1.23-2.28-1.98-4.29-2.03l2.46-2.92c1.68 1.19 2.46 2.32 2.97 3.31.56-.87 1.2-1.68 2.7-2.12l1.83 2.86c-1.42-.34-2.64.08-3.69.86zM8.17 10.4l-.93 1.69c.49.11 1 .16 1.54.16 1.35 0 2.58-.36 3.55-.95l-1.01-1.82c-.87.53-1.96.86-3.15.92zm.86 5.38c1.99 0 3.73-.74 4.74-1.86l-.98-1.76c-1 1.12-2.74 1.87-4.74 1.87-.62 0-1.21-.08-1.76-.21l-.63 1.15c.94.5 2.1.81 3.37.81z'; |
|
break; |
|
|
|
case 'building': |
|
path = 'M3 20h14V0H3v20zM7 3H5V1h2v2zm4 0H9V1h2v2zm4 0h-2V1h2v2zM7 6H5V4h2v2zm4 0H9V4h2v2zm4 0h-2V4h2v2zM7 9H5V7h2v2zm4 0H9V7h2v2zm4 0h-2V7h2v2zm-8 3H5v-2h2v2zm4 0H9v-2h2v2zm4 0h-2v-2h2v2zm-4 7H5v-6h6v6zm4-4h-2v-2h2v2zm0 3h-2v-2h2v2z'; |
|
break; |
|
|
|
case 'businessman': |
|
path = 'M7.3 6l-.03-.19c-.04-.37-.05-.73-.03-1.08.02-.36.1-.71.25-1.04.14-.32.31-.61.52-.86s.49-.46.83-.6c.34-.15.72-.23 1.13-.23.69 0 1.26.2 1.71.59s.76.87.91 1.44.18 1.16.09 1.78l-.03.19c-.01.09-.05.25-.11.48-.05.24-.12.47-.2.69-.08.21-.19.45-.34.72-.14.27-.3.49-.47.69-.18.19-.4.34-.67.48-.27.13-.55.19-.86.19s-.59-.06-.87-.19c-.26-.13-.49-.29-.67-.5-.18-.2-.34-.42-.49-.66-.15-.25-.26-.49-.34-.73-.09-.25-.16-.47-.21-.67-.06-.21-.1-.37-.12-.5zm9.2 6.24c.41.7.5 1.41.5 2.14v2.49c0 .03-.12.08-.29.13-.18.04-.42.13-.97.27-.55.12-1.1.24-1.65.34s-1.19.19-1.95.27c-.75.08-1.46.12-2.13.12-.68 0-1.39-.04-2.14-.12-.75-.07-1.4-.17-1.98-.27-.58-.11-1.08-.23-1.56-.34-.49-.11-.8-.21-1.06-.29L3 16.87v-2.49c0-.75.07-1.46.46-2.15s.81-1.25 1.5-1.68C5.66 10.12 7.19 10 8 10l1.67 1.67L9 13v3l1.02 1.08L11 16v-3l-.68-1.33L11.97 10c.77 0 2.2.07 2.9.52.71.45 1.21 1.02 1.63 1.72z'; |
|
break; |
|
|
|
case 'button': |
|
path = 'M17 5H3c-1.1 0-2 .9-2 2v6c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm1 7c0 .6-.4 1-1 1H3c-.6 0-1-.4-1-1V7c0-.6.4-1 1-1h14c.6 0 1 .4 1 1v5z'; |
|
break; |
|
|
|
case 'calendar-alt': |
|
path = 'M15 4h3v15H2V4h3V3c0-.41.15-.76.44-1.06.29-.29.65-.44 1.06-.44s.77.15 1.06.44c.29.3.44.65.44 1.06v1h4V3c0-.41.15-.76.44-1.06.29-.29.65-.44 1.06-.44s.77.15 1.06.44c.29.3.44.65.44 1.06v1zM6 3v2.5c0 .14.05.26.15.36.09.09.21.14.35.14s.26-.05.35-.14c.1-.1.15-.22.15-.36V3c0-.14-.05-.26-.15-.35-.09-.1-.21-.15-.35-.15s-.26.05-.35.15c-.1.09-.15.21-.15.35zm7 0v2.5c0 .14.05.26.14.36.1.09.22.14.36.14s.26-.05.36-.14c.09-.1.14-.22.14-.36V3c0-.14-.05-.26-.14-.35-.1-.1-.22-.15-.36-.15s-.26.05-.36.15c-.09.09-.14.21-.14.35zm4 15V8H3v10h14zM7 9v2H5V9h2zm2 0h2v2H9V9zm4 2V9h2v2h-2zm-6 1v2H5v-2h2zm2 0h2v2H9v-2zm4 2v-2h2v2h-2zm-6 1v2H5v-2h2zm4 2H9v-2h2v2zm4 0h-2v-2h2v2z'; |
|
break; |
|
|
|
case 'calendar': |
|
path = 'M15 4h3v14H2V4h3V3c0-.83.67-1.5 1.5-1.5S8 2.17 8 3v1h4V3c0-.83.67-1.5 1.5-1.5S15 2.17 15 3v1zM6 3v2.5c0 .28.22.5.5.5s.5-.22.5-.5V3c0-.28-.22-.5-.5-.5S6 2.72 6 3zm7 0v2.5c0 .28.22.5.5.5s.5-.22.5-.5V3c0-.28-.22-.5-.5-.5s-.5.22-.5.5zm4 14V8H3v9h14zM7 16V9H5v7h2zm4 0V9H9v7h2zm4 0V9h-2v7h2z'; |
|
break; |
|
|
|
case 'camera': |
|
path = 'M6 5V3H3v2h3zm12 10V4H9L7 6H2v9h16zm-7-8c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3z'; |
|
break; |
|
|
|
case 'carrot': |
|
path = 'M2 18.43c1.51 1.36 11.64-4.67 13.14-7.21.72-1.22-.13-3.01-1.52-4.44C15.2 5.73 16.59 9 17.91 8.31c.6-.32.99-1.31.7-1.92-.52-1.08-2.25-1.08-3.42-1.21.83-.2 2.82-1.05 2.86-2.25.04-.92-1.13-1.97-2.05-1.86-1.21.14-1.65 1.88-2.06 3-.05-.71-.2-2.27-.98-2.95-1.04-.91-2.29-.05-2.32 1.05-.04 1.33 2.82 2.07 1.92 3.67C11.04 4.67 9.25 4.03 8.1 4.7c-.49.31-1.05.91-1.63 1.69.89.94 2.12 2.07 3.09 2.72.2.14.26.42.11.62-.14.21-.42.26-.62.12-.99-.67-2.2-1.78-3.1-2.71-.45.67-.91 1.43-1.34 2.23.85.86 1.93 1.83 2.79 2.41.2.14.25.42.11.62-.14.21-.42.26-.63.12-.85-.58-1.86-1.48-2.71-2.32C2.4 13.69 1.1 17.63 2 18.43z'; |
|
break; |
|
|
|
case 'cart': |
|
path = 'M6 13h9c.55 0 1 .45 1 1s-.45 1-1 1H5c-.55 0-1-.45-1-1V4H2c-.55 0-1-.45-1-1s.45-1 1-1h3c.55 0 1 .45 1 1v2h13l-4 7H6v1zm-.5 3c.83 0 1.5.67 1.5 1.5S6.33 19 5.5 19 4 18.33 4 17.5 4.67 16 5.5 16zm9 0c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5-1.5-.67-1.5-1.5.67-1.5 1.5-1.5z'; |
|
break; |
|
|
|
case 'category': |
|
path = 'M5 7h13v10H2V4h7l2 2H4v9h1V7z'; |
|
break; |
|
|
|
case 'chart-area': |
|
path = 'M18 18l.01-12.28c.59-.35.99-.99.99-1.72 0-1.1-.9-2-2-2s-2 .9-2 2c0 .8.47 1.48 1.14 1.8l-4.13 6.58c-.33-.24-.73-.38-1.16-.38-.84 0-1.55.51-1.85 1.24l-2.14-1.53c.09-.22.14-.46.14-.71 0-1.11-.89-2-2-2-1.1 0-2 .89-2 2 0 .73.4 1.36.98 1.71L1 18h17zM17 3c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zM5 10c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm5.85 3c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1z'; |
|
break; |
|
|
|
case 'chart-bar': |
|
path = 'M18 18V2h-4v16h4zm-6 0V7H8v11h4zm-6 0v-8H2v8h4z'; |
|
break; |
|
|
|
case 'chart-line': |
|
path = 'M18 3.5c0 .62-.38 1.16-.92 1.38v13.11H1.99l4.22-6.73c-.13-.23-.21-.48-.21-.76C6 9.67 6.67 9 7.5 9S9 9.67 9 10.5c0 .13-.02.25-.05.37l1.44.63c.27-.3.67-.5 1.11-.5.18 0 .35.04.51.09l3.58-6.41c-.36-.27-.59-.7-.59-1.18 0-.83.67-1.5 1.5-1.5.19 0 .36.04.53.1l.05-.09v.11c.54.22.92.76.92 1.38zm-1.92 13.49V5.85l-3.29 5.89c.13.23.21.48.21.76 0 .83-.67 1.5-1.5 1.5s-1.5-.67-1.5-1.5l.01-.07-1.63-.72c-.25.18-.55.29-.88.29-.18 0-.35-.04-.51-.1l-3.2 5.09h12.29z'; |
|
break; |
|
|
|
case 'chart-pie': |
|
path = 'M10 10V3c3.87 0 7 3.13 7 7h-7zM9 4v7h7c0 3.87-3.13 7-7 7s-7-3.13-7-7 3.13-7 7-7z'; |
|
break; |
|
|
|
case 'clipboard': |
|
path = 'M11.9.39l1.4 1.4c1.61.19 3.5-.74 4.61.37s.18 3 .37 4.61l1.4 1.4c.39.39.39 1.02 0 1.41l-9.19 9.2c-.4.39-1.03.39-1.42 0L1.29 11c-.39-.39-.39-1.02 0-1.42l9.2-9.19c.39-.39 1.02-.39 1.41 0zm.58 2.25l-.58.58 4.95 4.95.58-.58c-.19-.6-.2-1.22-.15-1.82.02-.31.05-.62.09-.92.12-1 .18-1.63-.17-1.98s-.98-.29-1.98-.17c-.3.04-.61.07-.92.09-.6.05-1.22.04-1.82-.15zm4.02.93c.39.39.39 1.03 0 1.42s-1.03.39-1.42 0-.39-1.03 0-1.42 1.03-.39 1.42 0zm-6.72.36l-.71.7L15.44 11l.7-.71zM8.36 5.34l-.7.71 6.36 6.36.71-.7zM6.95 6.76l-.71.7 6.37 6.37.7-.71zM5.54 8.17l-.71.71 6.36 6.36.71-.71zM4.12 9.58l-.71.71 6.37 6.37.71-.71z'; |
|
break; |
|
|
|
case 'clock': |
|
path = 'M10 2c4.42 0 8 3.58 8 8s-3.58 8-8 8-8-3.58-8-8 3.58-8 8-8zm0 14c3.31 0 6-2.69 6-6s-2.69-6-6-6-6 2.69-6 6 2.69 6 6 6zm-.71-5.29c.07.05.14.1.23.15l-.02.02L14 13l-3.03-3.19L10 5l-.97 4.81h.01c0 .02-.01.05-.02.09S9 9.97 9 10c0 .28.1.52.29.71z'; |
|
break; |
|
|
|
case 'cloud-saved': |
|
path = 'M14.8 9c.1-.3.2-.6.2-1 0-2.2-1.8-4-4-4-1.5 0-2.9.9-3.5 2.2-.3-.1-.7-.2-1-.2C5.1 6 4 7.1 4 8.5c0 .2 0 .4.1.5-1.8.3-3.1 1.7-3.1 3.5C1 14.4 2.6 16 4.5 16h10c1.9 0 3.5-1.6 3.5-3.5 0-1.8-1.4-3.3-3.2-3.5zm-6.3 5.9l-3.2-3.2 1.4-1.4 1.8 1.8 3.8-3.8 1.4 1.4-5.2 5.2z'; |
|
break; |
|
|
|
case 'cloud-upload': |
|
path = 'M14.8 9c.1-.3.2-.6.2-1 0-2.2-1.8-4-4-4-1.5 0-2.9.9-3.5 2.2-.3-.1-.7-.2-1-.2C5.1 6 4 7.1 4 8.5c0 .2 0 .4.1.5-1.8.3-3.1 1.7-3.1 3.5C1 14.4 2.6 16 4.5 16H8v-3H5l4.5-4.5L14 13h-3v3h3.5c1.9 0 3.5-1.6 3.5-3.5 0-1.8-1.4-3.3-3.2-3.5z'; |
|
break; |
|
|
|
case 'cloud': |
|
path = 'M14.9 9c1.8.2 3.1 1.7 3.1 3.5 0 1.9-1.6 3.5-3.5 3.5h-10C2.6 16 1 14.4 1 12.5 1 10.7 2.3 9.3 4.1 9 4 8.9 4 8.7 4 8.5 4 7.1 5.1 6 6.5 6c.3 0 .7.1.9.2C8.1 4.9 9.4 4 11 4c2.2 0 4 1.8 4 4 0 .4-.1.7-.1 1z'; |
|
break; |
|
|
|
case 'columns': |
|
path = 'M3 15h6V5H3v10zm8 0h6V5h-6v10z'; |
|
break; |
|
|
|
case 'controls-back': |
|
path = 'M2 10l10-6v3.6L18 4v12l-6-3.6V16z'; |
|
break; |
|
|
|
case 'controls-forward': |
|
path = 'M18 10L8 16v-3.6L2 16V4l6 3.6V4z'; |
|
break; |
|
|
|
case 'controls-pause': |
|
path = 'M5 16V4h3v12H5zm7-12h3v12h-3V4z'; |
|
break; |
|
|
|
case 'controls-play': |
|
path = 'M5 4l10 6-10 6V4z'; |
|
break; |
|
|
|
case 'controls-repeat': |
|
path = 'M5 7v3l-2 1.5V5h11V3l4 3.01L14 9V7H5zm10 6v-3l2-1.5V15H6v2l-4-3.01L6 11v2h9z'; |
|
break; |
|
|
|
case 'controls-skipback': |
|
path = 'M11.98 7.63l6-3.6v12l-6-3.6v3.6l-8-4.8v4.8h-2v-12h2v4.8l8-4.8v3.6z'; |
|
break; |
|
|
|
case 'controls-skipforward': |
|
path = 'M8 12.4L2 16V4l6 3.6V4l8 4.8V4h2v12h-2v-4.8L8 16v-3.6z'; |
|
break; |
|
|
|
case 'controls-volumeoff': |
|
path = 'M2 7h4l5-4v14l-5-4H2V7z'; |
|
break; |
|
|
|
case 'controls-volumeon': |
|
path = 'M2 7h4l5-4v14l-5-4H2V7zm12.69-2.46C14.82 4.59 18 5.92 18 10s-3.18 5.41-3.31 5.46c-.06.03-.13.04-.19.04-.2 0-.39-.12-.46-.31-.11-.26.02-.55.27-.65.11-.05 2.69-1.15 2.69-4.54 0-3.41-2.66-4.53-2.69-4.54-.25-.1-.38-.39-.27-.65.1-.25.39-.38.65-.27zM16 10c0 2.57-2.23 3.43-2.32 3.47-.06.02-.12.03-.18.03-.2 0-.39-.12-.47-.32-.1-.26.04-.55.29-.65.07-.02 1.68-.67 1.68-2.53s-1.61-2.51-1.68-2.53c-.25-.1-.38-.39-.29-.65.1-.25.39-.39.65-.29.09.04 2.32.9 2.32 3.47z'; |
|
break; |
|
|
|
case 'cover-image': |
|
path = 'M2.2 1h15.5c.7 0 1.3.6 1.3 1.2v11.5c0 .7-.6 1.2-1.2 1.2H2.2c-.6.1-1.2-.5-1.2-1.1V2.2C1 1.6 1.6 1 2.2 1zM17 13V3H3v10h14zm-4-4s0-5 3-5v7c0 .6-.4 1-1 1H5c-.6 0-1-.4-1-1V7c2 0 3 4 3 4s1-4 3-4 3 2 3 2zM4 17h12v2H4z'; |
|
break; |
|
|
|
case 'dashboard': |
|
path = 'M3.76 16h12.48c1.1-1.37 1.76-3.11 1.76-5 0-4.42-3.58-8-8-8s-8 3.58-8 8c0 1.89.66 3.63 1.76 5zM10 4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zM6 6c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm8 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm-5.37 5.55L12 7v6c0 1.1-.9 2-2 2s-2-.9-2-2c0-.57.24-1.08.63-1.45zM4 10c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm12 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm-5 3c0-.55-.45-1-1-1s-1 .45-1 1 .45 1 1 1 1-.45 1-1z'; |
|
break; |
|
|
|
case 'desktop': |
|
path = 'M3 2h14c.55 0 1 .45 1 1v10c0 .55-.45 1-1 1h-5v2h2c.55 0 1 .45 1 1v1H5v-1c0-.55.45-1 1-1h2v-2H3c-.55 0-1-.45-1-1V3c0-.55.45-1 1-1zm13 9V4H4v7h12zM5 5h9L5 9V5z'; |
|
break; |
|
|
|
case 'dismiss': |
|
path = 'M10 2c4.42 0 8 3.58 8 8s-3.58 8-8 8-8-3.58-8-8 3.58-8 8-8zm5 11l-3-3 3-3-2-2-3 3-3-3-2 2 3 3-3 3 2 2 3-3 3 3z'; |
|
break; |
|
|
|
case 'download': |
|
path = 'M14.01 4v6h2V2H4v8h2.01V4h8zm-2 2v6h3l-5 6-5-6h3V6h4z'; |
|
break; |
|
|
|
case 'edit': |
|
path = 'M13.89 3.39l2.71 2.72c.46.46.42 1.24.03 1.64l-8.01 8.02-5.56 1.16 1.16-5.58s7.6-7.63 7.99-8.03c.39-.39 1.22-.39 1.68.07zm-2.73 2.79l-5.59 5.61 1.11 1.11 5.54-5.65zm-2.97 8.23l5.58-5.6-1.07-1.08-5.59 5.6z'; |
|
break; |
|
|
|
case 'editor-aligncenter': |
|
path = 'M14 5V3H6v2h8zm3 4V7H3v2h14zm-3 4v-2H6v2h8zm3 4v-2H3v2h14z'; |
|
break; |
|
|
|
case 'editor-alignleft': |
|
path = 'M12 5V3H3v2h9zm5 4V7H3v2h14zm-5 4v-2H3v2h9zm5 4v-2H3v2h14z'; |
|
break; |
|
|
|
case 'editor-alignright': |
|
path = 'M17 5V3H8v2h9zm0 4V7H3v2h14zm0 4v-2H8v2h9zm0 4v-2H3v2h14z'; |
|
break; |
|
|
|
case 'editor-bold': |
|
path = 'M6 4v13h4.54c1.37 0 2.46-.33 3.26-1 .8-.66 1.2-1.58 1.2-2.77 0-.84-.17-1.51-.51-2.01s-.9-.85-1.67-1.03v-.09c.57-.1 1.02-.4 1.36-.9s.51-1.13.51-1.91c0-1.14-.39-1.98-1.17-2.5C12.75 4.26 11.5 4 9.78 4H6zm2.57 5.15V6.26h1.36c.73 0 1.27.11 1.61.32.34.22.51.58.51 1.07 0 .54-.16.92-.47 1.15s-.82.35-1.51.35h-1.5zm0 2.19h1.6c1.44 0 2.16.53 2.16 1.61 0 .6-.17 1.05-.51 1.34s-.86.43-1.57.43H8.57v-3.38z'; |
|
break; |
|
|
|
case 'editor-break': |
|
path = 'M16 4h2v9H7v3l-5-4 5-4v3h9V4z'; |
|
break; |
|
|
|
case 'editor-code': |
|
path = 'M9 6l-4 4 4 4-1 2-6-6 6-6zm2 8l4-4-4-4 1-2 6 6-6 6z'; |
|
break; |
|
|
|
case 'editor-contract': |
|
path = 'M15.75 6.75L18 3v14l-2.25-3.75L17 12h-4v4l1.25-1.25L18 17H2l3.75-2.25L7 16v-4H3l1.25 1.25L2 17V3l2.25 3.75L3 8h4V4L5.75 5.25 2 3h16l-3.75 2.25L13 4v4h4z'; |
|
break; |
|
|
|
case 'editor-customchar': |
|
path = 'M10 5.4c1.27 0 2.24.36 2.91 1.08.66.71 1 1.76 1 3.13 0 1.28-.23 2.37-.69 3.27-.47.89-1.27 1.52-2.22 2.12v2h6v-2h-3.69c.92-.64 1.62-1.34 2.12-2.34.49-1.01.74-2.13.74-3.35 0-1.78-.55-3.19-1.65-4.22S11.92 3.54 10 3.54s-3.43.53-4.52 1.57c-1.1 1.04-1.65 2.44-1.65 4.2 0 1.21.24 2.31.73 3.33.48 1.01 1.19 1.71 2.1 2.36H3v2h6v-2c-.98-.64-1.8-1.28-2.24-2.17-.45-.89-.67-1.96-.67-3.22 0-1.37.33-2.41 1-3.13C7.75 5.76 8.72 5.4 10 5.4z'; |
|
break; |
|
|
|
case 'editor-expand': |
|
path = 'M7 8h6v4H7zm-5 5v4h4l-1.2-1.2L7 12l-3.8 2.2M14 17h4v-4l-1.2 1.2L13 12l2.2 3.8M14 3l1.3 1.3L13 8l3.8-2.2L18 7V3M6 3H2v4l1.2-1.2L7 8 4.7 4.3'; |
|
break; |
|
|
|
case 'editor-help': |
|
path = 'M17 10c0-3.87-3.14-7-7-7-3.87 0-7 3.13-7 7s3.13 7 7 7c3.86 0 7-3.13 7-7zm-6.3 1.48H9.14v-.43c0-.38.08-.7.24-.98s.46-.57.88-.89c.41-.29.68-.53.81-.71.14-.18.2-.39.2-.62 0-.25-.09-.44-.28-.58-.19-.13-.45-.19-.79-.19-.58 0-1.25.19-2 .57l-.64-1.28c.87-.49 1.8-.74 2.77-.74.81 0 1.45.2 1.92.58.48.39.71.91.71 1.55 0 .43-.09.8-.29 1.11-.19.32-.57.67-1.11 1.06-.38.28-.61.49-.71.63-.1.15-.15.34-.15.57v.35zm-1.47 2.74c-.18-.17-.27-.42-.27-.73 0-.33.08-.58.26-.75s.43-.25.77-.25c.32 0 .57.09.75.26s.27.42.27.74c0 .3-.09.55-.27.72-.18.18-.43.27-.75.27-.33 0-.58-.09-.76-.26z'; |
|
break; |
|
|
|
case 'editor-indent': |
|
path = 'M3 5V3h9v2H3zm10-1V3h4v1h-4zm0 3h2V5l4 3.5-4 3.5v-2h-2V7zM3 8V6h9v2H3zm2 3V9h7v2H5zm-2 3v-2h9v2H3zm10 0v-1h4v1h-4zm-4 3v-2h3v2H9z'; |
|
break; |
|
|
|
case 'editor-insertmore': |
|
path = 'M17 7V3H3v4h14zM6 11V9H3v2h3zm6 0V9H8v2h4zm5 0V9h-3v2h3zm0 6v-4H3v4h14z'; |
|
break; |
|
|
|
case 'editor-italic': |
|
path = 'M14.78 6h-2.13l-2.8 9h2.12l-.62 2H4.6l.62-2h2.14l2.8-9H8.03l.62-2h6.75z'; |
|
break; |
|
|
|
case 'editor-justify': |
|
path = 'M2 3h16v2H2V3zm0 4h16v2H2V7zm0 4h16v2H2v-2zm0 4h16v2H2v-2z'; |
|
break; |
|
|
|
case 'editor-kitchensink': |
|
path = 'M19 2v6H1V2h18zm-1 5V3H2v4h16zM5 4v2H3V4h2zm3 0v2H6V4h2zm3 0v2H9V4h2zm3 0v2h-2V4h2zm3 0v2h-2V4h2zm2 5v9H1V9h18zm-1 8v-7H2v7h16zM5 11v2H3v-2h2zm3 0v2H6v-2h2zm3 0v2H9v-2h2zm6 0v2h-5v-2h5zm-6 3v2H3v-2h8zm3 0v2h-2v-2h2zm3 0v2h-2v-2h2z'; |
|
break; |
|
|
|
case 'editor-ltr': |
|
path = 'M5.52 2h7.43c.55 0 1 .45 1 1s-.45 1-1 1h-1v13c0 .55-.45 1-1 1s-1-.45-1-1V5c0-.55-.45-1-1-1s-1 .45-1 1v12c0 .55-.45 1-1 1s-1-.45-1-1v-5.96h-.43C3.02 11.04 1 9.02 1 6.52S3.02 2 5.52 2zM14 14l5-4-5-4v8z'; |
|
break; |
|
|
|
case 'editor-ol-rtl': |
|
path = 'M15.025 8.75a1.048 1.048 0 0 1 .45-.1.507.507 0 0 1 .35.11.455.455 0 0 1 .13.36.803.803 0 0 1-.06.3 1.448 1.448 0 0 1-.19.33c-.09.11-.29.32-.58.62l-.99 1v.58h2.76v-.7h-1.72v-.04l.51-.48a7.276 7.276 0 0 0 .7-.71 1.75 1.75 0 0 0 .3-.49 1.254 1.254 0 0 0 .1-.51.968.968 0 0 0-.16-.56 1.007 1.007 0 0 0-.44-.37 1.512 1.512 0 0 0-.65-.14 1.98 1.98 0 0 0-.51.06 1.9 1.9 0 0 0-.42.15 3.67 3.67 0 0 0-.48.35l.45.54a2.505 2.505 0 0 1 .45-.3zM16.695 15.29a1.29 1.29 0 0 0-.74-.3v-.02a1.203 1.203 0 0 0 .65-.37.973.973 0 0 0 .23-.65.81.81 0 0 0-.37-.71 1.72 1.72 0 0 0-1-.26 2.185 2.185 0 0 0-1.33.4l.4.6a1.79 1.79 0 0 1 .46-.23 1.18 1.18 0 0 1 .41-.07c.38 0 .58.15.58.46a.447.447 0 0 1-.22.43 1.543 1.543 0 0 1-.7.12h-.31v.66h.31a1.764 1.764 0 0 1 .75.12.433.433 0 0 1 .23.41.55.55 0 0 1-.2.47 1.084 1.084 0 0 1-.63.15 2.24 2.24 0 0 1-.57-.08 2.671 2.671 0 0 1-.52-.2v.74a2.923 2.923 0 0 0 1.18.22 1.948 1.948 0 0 0 1.22-.33 1.077 1.077 0 0 0 .43-.92.836.836 0 0 0-.26-.64zM15.005 4.17c.06-.05.16-.14.3-.28l-.02.42V7h.84V3h-.69l-1.29 1.03.4.51zM4.02 5h9v1h-9zM4.02 10h9v1h-9zM4.02 15h9v1h-9z'; |
|
break; |
|
|
|
case 'editor-ol': |
|
path = 'M6 7V3h-.69L4.02 4.03l.4.51.46-.37c.06-.05.16-.14.3-.28l-.02.42V7H6zm2-2h9v1H8V5zm-1.23 6.95v-.7H5.05v-.04l.51-.48c.33-.31.57-.54.7-.71.14-.17.24-.33.3-.49.07-.16.1-.33.1-.51 0-.21-.05-.4-.16-.56-.1-.16-.25-.28-.44-.37s-.41-.14-.65-.14c-.19 0-.36.02-.51.06-.15.03-.29.09-.42.15-.12.07-.29.19-.48.35l.45.54c.16-.13.31-.23.45-.3.15-.07.3-.1.45-.1.14 0 .26.03.35.11s.13.2.13.36c0 .1-.02.2-.06.3s-.1.21-.19.33c-.09.11-.29.32-.58.62l-.99 1v.58h2.76zM8 10h9v1H8v-1zm-1.29 3.95c0-.3-.12-.54-.37-.71-.24-.17-.58-.26-1-.26-.52 0-.96.13-1.33.4l.4.6c.17-.11.32-.19.46-.23.14-.05.27-.07.41-.07.38 0 .58.15.58.46 0 .2-.07.35-.22.43s-.38.12-.7.12h-.31v.66h.31c.34 0 .59.04.75.12.15.08.23.22.23.41 0 .22-.07.37-.2.47-.14.1-.35.15-.63.15-.19 0-.38-.03-.57-.08s-.36-.12-.52-.2v.74c.34.15.74.22 1.18.22.53 0 .94-.11 1.22-.33.29-.22.43-.52.43-.92 0-.27-.09-.48-.26-.64s-.42-.26-.74-.3v-.02c.27-.06.49-.19.65-.37.15-.18.23-.39.23-.65zM8 15h9v1H8v-1z'; |
|
break; |
|
|
|
case 'editor-outdent': |
|
path = 'M7 4V3H3v1h4zm10 1V3H8v2h9zM7 7H5V5L1 8.5 5 12v-2h2V7zm10 1V6H8v2h9zm-2 3V9H8v2h7zm2 3v-2H8v2h9zM7 14v-1H3v1h4zm4 3v-2H8v2h3z'; |
|
break; |
|
|
|
case 'editor-paragraph': |
|
path = 'M15 2H7.54c-.83 0-1.59.2-2.28.6-.7.41-1.25.96-1.65 1.65C3.2 4.94 3 5.7 3 6.52s.2 1.58.61 2.27c.4.69.95 1.24 1.65 1.64.69.41 1.45.61 2.28.61h.43V17c0 .27.1.51.29.71.2.19.44.29.71.29.28 0 .51-.1.71-.29.2-.2.3-.44.3-.71V5c0-.27.09-.51.29-.71.2-.19.44-.29.71-.29s.51.1.71.29c.19.2.29.44.29.71v12c0 .27.1.51.3.71.2.19.43.29.71.29.27 0 .51-.1.71-.29.19-.2.29-.44.29-.71V4H15c.27 0 .5-.1.7-.3.2-.19.3-.43.3-.7s-.1-.51-.3-.71C15.5 2.1 15.27 2 15 2z'; |
|
break; |
|
|
|
case 'editor-paste-text': |
|
path = 'M12.38 2L15 5v1H5V5l2.64-3h4.74zM10 5c.55 0 1-.44 1-1 0-.55-.45-1-1-1s-1 .45-1 1c0 .56.45 1 1 1zm5.45-1H17c.55 0 1 .45 1 1v12c0 .56-.45 1-1 1H3c-.55 0-1-.44-1-1V5c0-.55.45-1 1-1h1.55L4 4.63V7h12V4.63zM14 11V9H6v2h3v5h2v-5h3z'; |
|
break; |
|
|
|
case 'editor-paste-word': |
|
path = 'M12.38 2L15 5v1H5V5l2.64-3h4.74zM10 5c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm8 12V5c0-.55-.45-1-1-1h-1.54l.54.63V7H4V4.62L4.55 4H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h14c.55 0 1-.45 1-1zm-3-8l-2 7h-2l-1-5-1 5H6.92L5 9h2l1 5 1-5h2l1 5 1-5h2z'; |
|
break; |
|
|
|
case 'editor-quote': |
|
path = 'M9.49 13.22c0-.74-.2-1.38-.61-1.9-.62-.78-1.83-.88-2.53-.72-.29-1.65 1.11-3.75 2.92-4.65L7.88 4c-2.73 1.3-5.42 4.28-4.96 8.05C3.21 14.43 4.59 16 6.54 16c.85 0 1.56-.25 2.12-.75s.83-1.18.83-2.03zm8.05 0c0-.74-.2-1.38-.61-1.9-.63-.78-1.83-.88-2.53-.72-.29-1.65 1.11-3.75 2.92-4.65L15.93 4c-2.73 1.3-5.41 4.28-4.95 8.05.29 2.38 1.66 3.95 3.61 3.95.85 0 1.56-.25 2.12-.75s.83-1.18.83-2.03z'; |
|
break; |
|
|
|
case 'editor-removeformatting': |
|
path = 'M14.29 4.59l1.1 1.11c.41.4.61.94.61 1.47v2.12c0 .53-.2 1.07-.61 1.47l-6.63 6.63c-.4.41-.94.61-1.47.61s-1.07-.2-1.47-.61l-1.11-1.1-1.1-1.11c-.41-.4-.61-.94-.61-1.47v-2.12c0-.54.2-1.07.61-1.48l6.63-6.62c.4-.41.94-.61 1.47-.61s1.06.2 1.47.61zm-6.21 9.7l6.42-6.42c.39-.39.39-1.03 0-1.43L12.36 4.3c-.19-.19-.45-.29-.72-.29s-.52.1-.71.29l-6.42 6.42c-.39.4-.39 1.04 0 1.43l2.14 2.14c.38.38 1.04.38 1.43 0z'; |
|
break; |
|
|
|
case 'editor-rtl': |
|
path = 'M5.52 2h7.43c.55 0 1 .45 1 1s-.45 1-1 1h-1v13c0 .55-.45 1-1 1s-1-.45-1-1V5c0-.55-.45-1-1-1s-1 .45-1 1v12c0 .55-.45 1-1 1s-1-.45-1-1v-5.96h-.43C3.02 11.04 1 9.02 1 6.52S3.02 2 5.52 2zM19 6l-5 4 5 4V6z'; |
|
break; |
|
|
|
case 'editor-spellcheck': |
|
path = 'M15.84 2.76c.25 0 .49.04.71.11.23.07.44.16.64.25l.35-.81c-.52-.26-1.08-.39-1.69-.39-.58 0-1.09.13-1.52.37-.43.25-.76.61-.99 1.08C13.11 3.83 13 4.38 13 5c0 .99.23 1.75.7 2.28s1.15.79 2.02.79c.6 0 1.13-.09 1.6-.26v-.84c-.26.08-.51.14-.74.19-.24.05-.49.08-.74.08-.59 0-1.04-.19-1.34-.57-.32-.37-.47-.93-.47-1.66 0-.7.16-1.25.48-1.65.33-.4.77-.6 1.33-.6zM6.5 8h1.04L5.3 2H4.24L2 8h1.03l.58-1.66H5.9zM8 2v6h2.17c.67 0 1.19-.15 1.57-.46.38-.3.56-.72.56-1.26 0-.4-.1-.72-.3-.95-.19-.24-.5-.39-.93-.47v-.04c.35-.06.6-.21.78-.44.18-.24.28-.53.28-.88 0-.52-.19-.9-.56-1.14-.36-.24-.96-.36-1.79-.36H8zm.98 2.48V2.82h.85c.44 0 .77.06.97.19.21.12.31.33.31.61 0 .31-.1.53-.29.66-.18.13-.48.2-.89.2h-.95zM5.64 5.5H3.9l.54-1.56c.14-.4.25-.76.32-1.1l.15.52c.07.23.13.4.17.51zm3.34-.23h.99c.44 0 .76.08.98.23.21.15.32.38.32.69 0 .34-.11.59-.32.75s-.52.24-.93.24H8.98V5.27zM4 13l5 5 9-8-1-1-8 6-4-3z'; |
|
break; |
|
|
|
case 'editor-strikethrough': |
|
path = 'M15.82 12.25c.26 0 .5-.02.74-.07.23-.05.48-.12.73-.2v.84c-.46.17-.99.26-1.58.26-.88 0-1.54-.26-2.01-.79-.39-.44-.62-1.04-.68-1.79h-.94c.12.21.18.48.18.79 0 .54-.18.95-.55 1.26-.38.3-.9.45-1.56.45H8v-2.5H6.59l.93 2.5H6.49l-.59-1.67H3.62L3.04 13H2l.93-2.5H2v-1h1.31l.93-2.49H5.3l.92 2.49H8V7h1.77c1 0 1.41.17 1.77.41.37.24.55.62.55 1.13 0 .35-.09.64-.27.87l-.08.09h1.29c.05-.4.15-.77.31-1.1.23-.46.55-.82.98-1.06.43-.25.93-.37 1.51-.37.61 0 1.17.12 1.69.38l-.35.81c-.2-.1-.42-.18-.64-.25s-.46-.11-.71-.11c-.55 0-.99.2-1.31.59-.23.29-.38.66-.44 1.11H17v1h-2.95c.06.5.2.9.44 1.19.3.37.75.56 1.33.56zM4.44 8.96l-.18.54H5.3l-.22-.61c-.04-.11-.09-.28-.17-.51-.07-.24-.12-.41-.14-.51-.08.33-.18.69-.33 1.09zm4.53-1.09V9.5h1.19c.28-.02.49-.09.64-.18.19-.13.28-.35.28-.66 0-.28-.1-.48-.3-.61-.2-.12-.53-.18-.97-.18h-.84zm-3.33 2.64v-.01H3.91v.01h1.73zm5.28.01l-.03-.02H8.97v1.68h1.04c.4 0 .71-.08.92-.23.21-.16.31-.4.31-.74 0-.31-.11-.54-.32-.69z'; |
|
break; |
|
|
|
case 'editor-table': |
|
path = 'M18 17V3H2v14h16zM16 7H4V5h12v2zm-7 4H4V9h5v2zm7 0h-5V9h5v2zm-7 4H4v-2h5v2zm7 0h-5v-2h5v2z'; |
|
break; |
|
|
|
case 'editor-textcolor': |
|
path = 'M13.23 15h1.9L11 4H9L5 15h1.88l1.07-3h4.18zm-1.53-4.54H8.51L10 5.6z'; |
|
break; |
|
|
|
case 'editor-ul': |
|
path = 'M5.5 7C4.67 7 4 6.33 4 5.5 4 4.68 4.67 4 5.5 4 6.32 4 7 4.68 7 5.5 7 6.33 6.32 7 5.5 7zM8 5h9v1H8V5zm-2.5 7c-.83 0-1.5-.67-1.5-1.5C4 9.68 4.67 9 5.5 9c.82 0 1.5.68 1.5 1.5 0 .83-.68 1.5-1.5 1.5zM8 10h9v1H8v-1zm-2.5 7c-.83 0-1.5-.67-1.5-1.5 0-.82.67-1.5 1.5-1.5.82 0 1.5.68 1.5 1.5 0 .83-.68 1.5-1.5 1.5zM8 15h9v1H8v-1z'; |
|
break; |
|
|
|
case 'editor-underline': |
|
path = 'M14 5h-2v5.71c0 1.99-1.12 2.98-2.45 2.98-1.32 0-2.55-1-2.55-2.96V5H5v5.87c0 1.91 1 4.54 4.48 4.54 3.49 0 4.52-2.58 4.52-4.5V5zm0 13v-2H5v2h9z'; |
|
break; |
|
|
|
case 'editor-unlink': |
|
path = 'M17.74 2.26c1.68 1.69 1.68 4.41 0 6.1l-1.53 1.52c-.32.33-.69.58-1.08.77L13 10l1.69-1.64.76-.77.76-.76c.84-.84.84-2.2 0-3.04-.84-.85-2.2-.85-3.04 0l-.77.76-.76.76L10 7l-.65-2.14c.19-.38.44-.75.77-1.07l1.52-1.53c1.69-1.68 4.42-1.68 6.1 0zM2 4l8 6-6-8zm4-2l4 8-2-8H6zM2 6l8 4-8-2V6zm7.36 7.69L10 13l.74 2.35-1.38 1.39c-1.69 1.68-4.41 1.68-6.1 0-1.68-1.68-1.68-4.42 0-6.1l1.39-1.38L7 10l-.69.64-1.52 1.53c-.85.84-.85 2.2 0 3.04.84.85 2.2.85 3.04 0zM18 16l-8-6 6 8zm-4 2l-4-8 2 8h2zm4-4l-8-4 8 2v2z'; |
|
break; |
|
|
|
case 'editor-video': |
|
path = 'M16 2h-3v1H7V2H4v15h3v-1h6v1h3V2zM6 3v1H5V3h1zm9 0v1h-1V3h1zm-2 1v5H7V4h6zM6 5v1H5V5h1zm9 0v1h-1V5h1zM6 7v1H5V7h1zm9 0v1h-1V7h1zM6 9v1H5V9h1zm9 0v1h-1V9h1zm-2 1v5H7v-5h6zm-7 1v1H5v-1h1zm9 0v1h-1v-1h1zm-9 2v1H5v-1h1zm9 0v1h-1v-1h1zm-9 2v1H5v-1h1zm9 0v1h-1v-1h1z'; |
|
break; |
|
|
|
case 'ellipsis': |
|
path = 'M5 10c0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2 2 .9 2 2zm12-2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-7 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z'; |
|
break; |
|
|
|
case 'email-alt': |
|
path = 'M19 14.5v-9c0-.83-.67-1.5-1.5-1.5H3.49c-.83 0-1.5.67-1.5 1.5v9c0 .83.67 1.5 1.5 1.5H17.5c.83 0 1.5-.67 1.5-1.5zm-1.31-9.11c.33.33.15.67-.03.84L13.6 9.95l3.9 4.06c.12.14.2.36.06.51-.13.16-.43.15-.56.05l-4.37-3.73-2.14 1.95-2.13-1.95-4.37 3.73c-.13.1-.43.11-.56-.05-.14-.15-.06-.37.06-.51l3.9-4.06-4.06-3.72c-.18-.17-.36-.51-.03-.84s.67-.17.95.07l6.24 5.04 6.25-5.04c.28-.24.62-.4.95-.07z'; |
|
break; |
|
|
|
case 'email-alt2': |
|
path = 'M18.01 11.18V2.51c0-1.19-.9-1.81-2-1.37L4 5.91c-1.1.44-2 1.77-2 2.97v8.66c0 1.2.9 1.81 2 1.37l12.01-4.77c1.1-.44 2-1.76 2-2.96zm-1.43-7.46l-6.04 9.33-6.65-4.6c-.1-.07-.36-.32-.17-.64.21-.36.65-.21.65-.21l6.3 2.32s4.83-6.34 5.11-6.7c.13-.17.43-.34.73-.13.29.2.16.49.07.63z'; |
|
break; |
|
|
|
case 'email': |
|
path = 'M3.87 4h13.25C18.37 4 19 4.59 19 5.79v8.42c0 1.19-.63 1.79-1.88 1.79H3.87c-1.25 0-1.88-.6-1.88-1.79V5.79c0-1.2.63-1.79 1.88-1.79zm6.62 8.6l6.74-5.53c.24-.2.43-.66.13-1.07-.29-.41-.82-.42-1.17-.17l-5.7 3.86L4.8 5.83c-.35-.25-.88-.24-1.17.17-.3.41-.11.87.13 1.07z'; |
|
break; |
|
|
|
case 'embed-audio': |
|
path = 'M17 4H3c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-7 3H7v4c0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2c.4 0 .7.1 1 .3V5h4v2zm4 3.5L12.5 12l1.5 1.5V15l-3-3 3-3v1.5zm1 4.5v-1.5l1.5-1.5-1.5-1.5V9l3 3-3 3z'; |
|
break; |
|
|
|
case 'embed-generic': |
|
path = 'M17 4H3c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-3 6.5L12.5 12l1.5 1.5V15l-3-3 3-3v1.5zm1 4.5v-1.5l1.5-1.5-1.5-1.5V9l3 3-3 3z'; |
|
break; |
|
|
|
case 'embed-photo': |
|
path = 'M17 4H3c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-7 8H3V6h7v6zm4-1.5L12.5 12l1.5 1.5V15l-3-3 3-3v1.5zm1 4.5v-1.5l1.5-1.5-1.5-1.5V9l3 3-3 3zm-6-4V8.5L7.2 10 6 9.2 4 11h5zM4.6 8.6c.6 0 1-.4 1-1s-.4-1-1-1-1 .4-1 1 .4 1 1 1z'; |
|
break; |
|
|
|
case 'embed-post': |
|
path = 'M17 4H3c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zM8.6 9l-.4.3c-.4.4-.5 1.1-.2 1.6l-.8.8-1.1-1.1-1.3 1.3c-.2.2-1.6 1.3-1.8 1.1-.2-.2.9-1.6 1.1-1.8l1.3-1.3-1.1-1.1.8-.8c.5.3 1.2.3 1.6-.2l.3-.3c.5-.5.5-1.2.2-1.7L8 5l3 2.9-.8.8c-.5-.2-1.2-.2-1.6.3zm5.4 1.5L12.5 12l1.5 1.5V15l-3-3 3-3v1.5zm1 4.5v-1.5l1.5-1.5-1.5-1.5V9l3 3-3 3z'; |
|
break; |
|
|
|
case 'embed-video': |
|
path = 'M17 4H3c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-7 6.5L8 9.1V11H3V6h5v1.8l2-1.3v4zm4 0L12.5 12l1.5 1.5V15l-3-3 3-3v1.5zm1 4.5v-1.5l1.5-1.5-1.5-1.5V9l3 3-3 3z'; |
|
break; |
|
|
|
case 'excerpt-view': |
|
path = 'M19 18V2c0-.55-.45-1-1-1H2c-.55 0-1 .45-1 1v16c0 .55.45 1 1 1h16c.55 0 1-.45 1-1zM4 3c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm13 0v6H6V3h11zM4 11c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm13 0v6H6v-6h11z'; |
|
break; |
|
|
|
case 'exit': |
|
path = 'M13 3v2h2v10h-2v2h4V3h-4zm0 8V9H5.4l4.3-4.3-1.4-1.4L1.6 10l6.7 6.7 1.4-1.4L5.4 11H13z'; |
|
break; |
|
|
|
case 'external': |
|
path = 'M9 3h8v8l-2-1V6.92l-5.6 5.59-1.41-1.41L14.08 5H10zm3 12v-3l2-2v7H3V6h8L9 8H5v7h7z'; |
|
break; |
|
|
|
case 'facebook-alt': |
|
path = 'M8.46 18h2.93v-7.3h2.45l.37-2.84h-2.82V6.04c0-.82.23-1.38 1.41-1.38h1.51V2.11c-.26-.03-1.15-.11-2.19-.11-2.18 0-3.66 1.33-3.66 3.76v2.1H6v2.84h2.46V18z'; |
|
break; |
|
|
|
case 'facebook': |
|
path = 'M2.89 2h14.23c.49 0 .88.39.88.88v14.24c0 .48-.39.88-.88.88h-4.08v-6.2h2.08l.31-2.41h-2.39V7.85c0-.7.2-1.18 1.2-1.18h1.28V4.51c-.22-.03-.98-.09-1.86-.09-1.85 0-3.11 1.12-3.11 3.19v1.78H8.46v2.41h2.09V18H2.89c-.49 0-.89-.4-.89-.88V2.88c0-.49.4-.88.89-.88z'; |
|
break; |
|
|
|
case 'feedback': |
|
path = 'M2 2h16c.55 0 1 .45 1 1v14c0 .55-.45 1-1 1H2c-.55 0-1-.45-1-1V3c0-.55.45-1 1-1zm15 14V7H3v9h14zM4 8v1h3V8H4zm4 0v3h8V8H8zm-4 4v1h3v-1H4zm4 0v3h8v-3H8z'; |
|
break; |
|
|
|
case 'filter': |
|
path = 'M3 4.5v-2s3.34-1 7-1 7 1 7 1v2l-5 7.03v6.97s-1.22-.09-2.25-.59S8 16.5 8 16.5v-4.97z'; |
|
break; |
|
|
|
case 'flag': |
|
path = 'M5 18V3H3v15h2zm1-6V4c3-1 7 1 11 0v8c-3 1.27-8-1-11 0z'; |
|
break; |
|
|
|
case 'format-aside': |
|
path = 'M1 1h18v12l-6 6H1V1zm3 3v1h12V4H4zm0 4v1h12V8H4zm6 5v-1H4v1h6zm2 4l5-5h-5v5z'; |
|
break; |
|
|
|
case 'format-audio': |
|
path = 'M6.99 3.08l11.02-2c.55-.08.99.45.99 1V14.5c0 1.94-1.57 3.5-3.5 3.5S12 16.44 12 14.5c0-1.93 1.57-3.5 3.5-3.5.54 0 1.04.14 1.5.35V5.08l-9 2V16c-.24 1.7-1.74 3-3.5 3C2.57 19 1 17.44 1 15.5 1 13.57 2.57 12 4.5 12c.54 0 1.04.14 1.5.35V4.08c0-.55.44-.91.99-1z'; |
|
break; |
|
|
|
case 'format-chat': |
|
path = 'M11 6h-.82C9.07 6 8 7.2 8 8.16V10l-3 3v-3H3c-1.1 0-2-.9-2-2V3c0-1.1.9-2 2-2h6c1.1 0 2 .9 2 2v3zm0 1h6c1.1 0 2 .9 2 2v5c0 1.1-.9 2-2 2h-2v3l-3-3h-1c-1.1 0-2-.9-2-2V9c0-1.1.9-2 2-2z'; |
|
break; |
|
|
|
case 'format-gallery': |
|
path = 'M16 4h1.96c.57 0 1.04.47 1.04 1.04v12.92c0 .57-.47 1.04-1.04 1.04H5.04C4.47 19 4 18.53 4 17.96V16H2.04C1.47 16 1 15.53 1 14.96V2.04C1 1.47 1.47 1 2.04 1h12.92c.57 0 1.04.47 1.04 1.04V4zM3 14h11V3H3v11zm5-8.5C8 4.67 7.33 4 6.5 4S5 4.67 5 5.5 5.67 7 6.5 7 8 6.33 8 5.5zm2 4.5s1-5 3-5v8H4V7c2 0 2 3 2 3s.33-2 2-2 2 2 2 2zm7 7V6h-1v8.96c0 .57-.47 1.04-1.04 1.04H6v1h11z'; |
|
break; |
|
|
|
case 'format-image': |
|
path = 'M2.25 1h15.5c.69 0 1.25.56 1.25 1.25v15.5c0 .69-.56 1.25-1.25 1.25H2.25C1.56 19 1 18.44 1 17.75V2.25C1 1.56 1.56 1 2.25 1zM17 17V3H3v14h14zM10 6c0-1.1-.9-2-2-2s-2 .9-2 2 .9 2 2 2 2-.9 2-2zm3 5s0-6 3-6v10c0 .55-.45 1-1 1H5c-.55 0-1-.45-1-1V8c2 0 3 4 3 4s1-3 3-3 3 2 3 2z'; |
|
break; |
|
|
|
case 'format-quote': |
|
path = 'M8.54 12.74c0-.87-.24-1.61-.72-2.22-.73-.92-2.14-1.03-2.96-.85-.34-1.93 1.3-4.39 3.42-5.45L6.65 1.94C3.45 3.46.31 6.96.85 11.37 1.19 14.16 2.8 16 5.08 16c1 0 1.83-.29 2.48-.88.66-.59.98-1.38.98-2.38zm9.43 0c0-.87-.24-1.61-.72-2.22-.73-.92-2.14-1.03-2.96-.85-.34-1.93 1.3-4.39 3.42-5.45l-1.63-2.28c-3.2 1.52-6.34 5.02-5.8 9.43.34 2.79 1.95 4.63 4.23 4.63 1 0 1.83-.29 2.48-.88.66-.59.98-1.38.98-2.38z'; |
|
break; |
|
|
|
case 'format-status': |
|
path = 'M10 1c7 0 9 2.91 9 6.5S17 14 10 14s-9-2.91-9-6.5S3 1 10 1zM5.5 9C6.33 9 7 8.33 7 7.5S6.33 6 5.5 6 4 6.67 4 7.5 4.67 9 5.5 9zM10 9c.83 0 1.5-.67 1.5-1.5S10.83 6 10 6s-1.5.67-1.5 1.5S9.17 9 10 9zm4.5 0c.83 0 1.5-.67 1.5-1.5S15.33 6 14.5 6 13 6.67 13 7.5 13.67 9 14.5 9zM6 14.5c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5-1.5-.67-1.5-1.5.67-1.5 1.5-1.5zm-3 2c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1z'; |
|
break; |
|
|
|
case 'format-video': |
|
path = 'M2 1h16c.55 0 1 .45 1 1v16l-18-.02V2c0-.55.45-1 1-1zm4 1L4 5h1l2-3H6zm4 0H9L7 5h1zm3 0h-1l-2 3h1zm3 0h-1l-2 3h1zm1 14V6H3v10h14zM8 7l6 4-6 4V7z'; |
|
break; |
|
|
|
case 'forms': |
|
path = 'M2 2h7v7H2V2zm9 0v7h7V2h-7zM5.5 4.5L7 3H4zM12 8V3h5v5h-5zM4.5 5.5L3 4v3zM8 4L6.5 5.5 8 7V4zM5.5 6.5L4 8h3zM9 18v-7H2v7h7zm9 0h-7v-7h7v7zM8 12v5H3v-5h5zm6.5 1.5L16 12h-3zM12 16l1.5-1.5L12 13v3zm3.5-1.5L17 16v-3zm-1 1L13 17h3z'; |
|
break; |
|
|
|
case 'googleplus': |
|
path = 'M6.73 10h5.4c.05.29.09.57.09.95 0 3.27-2.19 5.6-5.49 5.6-3.17 0-5.73-2.57-5.73-5.73 0-3.17 2.56-5.73 5.73-5.73 1.54 0 2.84.57 3.83 1.5l-1.55 1.5c-.43-.41-1.17-.89-2.28-.89-1.96 0-3.55 1.62-3.55 3.62 0 1.99 1.59 3.61 3.55 3.61 2.26 0 3.11-1.62 3.24-2.47H6.73V10zM19 10v1.64h-1.64v1.63h-1.63v-1.63h-1.64V10h1.64V8.36h1.63V10H19z'; |
|
break; |
|
|
|
case 'grid-view': |
|
path = 'M2 1h16c.55 0 1 .45 1 1v16c0 .55-.45 1-1 1H2c-.55 0-1-.45-1-1V2c0-.55.45-1 1-1zm7.01 7.99v-6H3v6h6.01zm8 0v-6h-6v6h6zm-8 8.01v-6H3v6h6.01zm8 0v-6h-6v6h6z'; |
|
break; |
|
|
|
case 'groups': |
|
path = 'M8.03 4.46c-.29 1.28.55 3.46 1.97 3.46 1.41 0 2.25-2.18 1.96-3.46-.22-.98-1.08-1.63-1.96-1.63-.89 0-1.74.65-1.97 1.63zm-4.13.9c-.25 1.08.47 2.93 1.67 2.93s1.92-1.85 1.67-2.93c-.19-.83-.92-1.39-1.67-1.39s-1.48.56-1.67 1.39zm8.86 0c-.25 1.08.47 2.93 1.66 2.93 1.2 0 1.92-1.85 1.67-2.93-.19-.83-.92-1.39-1.67-1.39-.74 0-1.47.56-1.66 1.39zm-.59 11.43l1.25-4.3C14.2 10 12.71 8.47 10 8.47c-2.72 0-4.21 1.53-3.44 4.02l1.26 4.3C8.05 17.51 9 18 10 18c.98 0 1.94-.49 2.17-1.21zm-6.1-7.63c-.49.67-.96 1.83-.42 3.59l1.12 3.79c-.34.2-.77.31-1.2.31-.85 0-1.65-.41-1.85-1.03l-1.07-3.65c-.65-2.11.61-3.4 2.92-3.4.27 0 .54.02.79.06-.1.1-.2.22-.29.33zm8.35-.39c2.31 0 3.58 1.29 2.92 3.4l-1.07 3.65c-.2.62-1 1.03-1.85 1.03-.43 0-.86-.11-1.2-.31l1.11-3.77c.55-1.78.08-2.94-.42-3.61-.08-.11-.18-.23-.28-.33.25-.04.51-.06.79-.06z'; |
|
break; |
|
|
|
case 'hammer': |
|
path = 'M17.7 6.32l1.41 1.42-3.47 3.41-1.42-1.42.84-.82c-.32-.76-.81-1.57-1.51-2.31l-4.61 6.59-5.26 4.7c-.39.39-1.02.39-1.42 0l-1.2-1.21c-.39-.39-.39-1.02 0-1.41l10.97-9.92c-1.37-.86-3.21-1.46-5.67-1.48 2.7-.82 4.95-.93 6.58-.3 1.7.66 2.82 2.2 3.91 3.58z'; |
|
break; |
|
|
|
case 'heading': |
|
path = 'M12.5 4v5.2h-5V4H5v13h2.5v-5.2h5V17H15V4'; |
|
break; |
|
|
|
case 'heart': |
|
path = 'M10 17.12c3.33-1.4 5.74-3.79 7.04-6.21 1.28-2.41 1.46-4.81.32-6.25-1.03-1.29-2.37-1.78-3.73-1.74s-2.68.63-3.63 1.46c-.95-.83-2.27-1.42-3.63-1.46s-2.7.45-3.73 1.74c-1.14 1.44-.96 3.84.34 6.25 1.28 2.42 3.69 4.81 7.02 6.21z'; |
|
break; |
|
|
|
case 'hidden': |
|
path = 'M17.2 3.3l.16.17c.39.39.39 1.02 0 1.41L4.55 17.7c-.39.39-1.03.39-1.41 0l-.17-.17c-.39-.39-.39-1.02 0-1.41l1.59-1.6c-1.57-1-2.76-2.3-3.56-3.93.81-1.65 2.03-2.98 3.64-3.99S8.04 5.09 10 5.09c1.2 0 2.33.21 3.4.6l2.38-2.39c.39-.39 1.03-.39 1.42 0zm-7.09 4.01c-.23.25-.34.54-.34.88 0 .31.12.58.31.81l1.8-1.79c-.13-.12-.28-.21-.45-.26-.11-.01-.28-.03-.49-.04-.33.03-.6.16-.83.4zM2.4 10.59c.69 1.23 1.71 2.25 3.05 3.05l1.28-1.28c-.51-.69-.77-1.47-.77-2.36 0-1.06.36-1.98 1.09-2.76-1.04.27-1.96.7-2.76 1.26-.8.58-1.43 1.27-1.89 2.09zm13.22-2.13l.96-.96c1.02.86 1.83 1.89 2.42 3.09-.81 1.65-2.03 2.98-3.64 3.99s-3.4 1.51-5.36 1.51c-.63 0-1.24-.07-1.83-.18l1.07-1.07c.25.02.5.05.76.05 1.63 0 3.13-.4 4.5-1.21s2.4-1.84 3.1-3.09c-.46-.82-1.09-1.51-1.89-2.09-.03-.01-.06-.03-.09-.04zm-5.58 5.58l4-4c-.01 1.1-.41 2.04-1.18 2.81-.78.78-1.72 1.18-2.82 1.19z'; |
|
break; |
|
|
|
case 'html': |
|
path = 'M4 16v-2H2v2H1v-5h1v2h2v-2h1v5H4zM7 16v-4H5.6v-1h3.7v1H8v4H7zM10 16v-5h1l1.4 3.4h.1L14 11h1v5h-1v-3.1h-.1l-1.1 2.5h-.6l-1.1-2.5H11V16h-1zM19 16h-3v-5h1v4h2v1zM9.4 4.2L7.1 6.5l2.3 2.3-.6 1.2-3.5-3.5L8.8 3l.6 1.2zm1.2 4.6l2.3-2.3-2.3-2.3.6-1.2 3.5 3.5-3.5 3.5-.6-1.2z'; |
|
break; |
|
|
|
case 'id-alt': |
|
path = 'M18 18H2V2h16v16zM8.05 7.53c.13-.07.24-.15.33-.24.09-.1.17-.21.24-.34.07-.14.13-.26.17-.37s.07-.22.1-.34L8.95 6c0-.04.01-.07.01-.09.05-.32.03-.61-.04-.9-.08-.28-.23-.52-.46-.72C8.23 4.1 7.95 4 7.6 4c-.2 0-.39.04-.56.11-.17.08-.31.18-.41.3-.11.13-.2.27-.27.44-.07.16-.11.33-.12.51s0 .36.01.55l.02.09c.01.06.03.15.06.25s.06.21.1.33.1.25.17.37c.08.12.16.23.25.33s.2.19.34.25c.13.06.28.09.43.09s.3-.03.43-.09zM16 5V4h-5v1h5zm0 2V6h-5v1h5zM7.62 8.83l-1.38-.88c-.41 0-.79.11-1.14.32-.35.22-.62.5-.81.85-.19.34-.29.7-.29 1.07v1.25l.2.05c.13.04.31.09.55.14.24.06.51.12.8.17.29.06.62.1 1 .14.37.04.73.06 1.07.06s.69-.02 1.07-.06.7-.09.98-.14c.27-.05.54-.1.82-.17.27-.06.45-.11.54-.13.09-.03.16-.05.21-.06v-1.25c0-.36-.1-.72-.31-1.07s-.49-.64-.84-.86-.72-.33-1.11-.33zM16 9V8h-3v1h3zm0 2v-1h-3v1h3zm0 3v-1H4v1h12zm0 2v-1H4v1h12z'; |
|
break; |
|
|
|
case 'id': |
|
path = 'M18 16H2V4h16v12zM7.05 8.53c.13-.07.24-.15.33-.24.09-.1.17-.21.24-.34.07-.14.13-.26.17-.37s.07-.22.1-.34L7.95 7c0-.04.01-.07.01-.09.05-.32.03-.61-.04-.9-.08-.28-.23-.52-.46-.72C7.23 5.1 6.95 5 6.6 5c-.2 0-.39.04-.56.11-.17.08-.31.18-.41.3-.11.13-.2.27-.27.44-.07.16-.11.33-.12.51s0 .36.01.55l.02.09c.01.06.03.15.06.25s.06.21.1.33.1.25.17.37c.08.12.16.23.25.33s.2.19.34.25c.13.06.28.09.43.09s.3-.03.43-.09zM17 9V5h-5v4h5zm-10.38.83l-1.38-.88c-.41 0-.79.11-1.14.32-.35.22-.62.5-.81.85-.19.34-.29.7-.29 1.07v1.25l.2.05c.13.04.31.09.55.14.24.06.51.12.8.17.29.06.62.1 1 .14.37.04.73.06 1.07.06s.69-.02 1.07-.06.7-.09.98-.14c.27-.05.54-.1.82-.17.27-.06.45-.11.54-.13.09-.03.16-.05.21-.06v-1.25c0-.36-.1-.72-.31-1.07s-.49-.64-.84-.86-.72-.33-1.11-.33zM17 11v-1h-5v1h5zm0 2v-1h-5v1h5zm0 2v-1H3v1h14z'; |
|
break; |
|
|
|
case 'image-crop': |
|
path = 'M19 12v3h-4v4h-3v-4H4V7H0V4h4V0h3v4h7l3-3 1 1-3 3v7h4zm-8-5H7v4zm-3 5h4V8z'; |
|
break; |
|
|
|
case 'image-filter': |
|
path = 'M14 5.87c0-2.2-1.79-4-4-4s-4 1.8-4 4c0 2.21 1.79 4 4 4s4-1.79 4-4zM3.24 10.66c-1.92 1.1-2.57 3.55-1.47 5.46 1.11 1.92 3.55 2.57 5.47 1.47 1.91-1.11 2.57-3.55 1.46-5.47-1.1-1.91-3.55-2.56-5.46-1.46zm9.52 6.93c1.92 1.1 4.36.45 5.47-1.46 1.1-1.92.45-4.36-1.47-5.47-1.91-1.1-4.36-.45-5.46 1.46-1.11 1.92-.45 4.36 1.46 5.47z'; |
|
break; |
|
|
|
case 'image-flip-horizontal': |
|
path = 'M19 3v14h-8v3H9v-3H1V3h8V0h2v3h8zm-8.5 14V3h-1v14h1zM7 6.5L3 10l4 3.5v-7zM17 10l-4-3.5v7z'; |
|
break; |
|
|
|
case 'image-flip-vertical': |
|
path = 'M20 9v2h-3v8H3v-8H0V9h3V1h14v8h3zM6.5 7h7L10 3zM17 9.5H3v1h14v-1zM13.5 13h-7l3.5 4z'; |
|
break; |
|
|
|
case 'image-rotate-left': |
|
path = 'M7 5H5.05c0-1.74.85-2.9 2.95-2.9V0C4.85 0 2.96 2.11 2.96 5H1.18L3.8 8.39zm13-4v14h-5v5H1V10h9V1h10zm-2 2h-6v7h3v3h3V3zm-5 9H3v6h10v-6z'; |
|
break; |
|
|
|
case 'image-rotate-right': |
|
path = 'M15.95 5H14l3.2 3.39L19.82 5h-1.78c0-2.89-1.89-5-5.04-5v2.1c2.1 0 2.95 1.16 2.95 2.9zM1 1h10v9h9v10H6v-5H1V1zm2 2v10h3v-3h3V3H3zm5 9v6h10v-6H8z'; |
|
break; |
|
|
|
case 'image-rotate': |
|
path = 'M10.25 1.02c5.1 0 8.75 4.04 8.75 9s-3.65 9-8.75 9c-3.2 0-6.02-1.59-7.68-3.99l2.59-1.52c1.1 1.5 2.86 2.51 4.84 2.51 3.3 0 6-2.79 6-6s-2.7-6-6-6c-1.97 0-3.72 1-4.82 2.49L7 8.02l-6 2v-7L2.89 4.6c1.69-2.17 4.36-3.58 7.36-3.58z'; |
|
break; |
|
|
|
case 'images-alt': |
|
path = 'M4 15v-3H2V2h12v3h2v3h2v10H6v-3H4zm7-12c-1.1 0-2 .9-2 2h4c0-1.1-.89-2-2-2zm-7 8V6H3v5h1zm7-3h4c0-1.1-.89-2-2-2-1.1 0-2 .9-2 2zm-5 6V9H5v5h1zm9-1c1.1 0 2-.89 2-2 0-1.1-.9-2-2-2s-2 .9-2 2c0 1.11.9 2 2 2zm2 4v-2c-5 0-5-3-10-3v5h10z'; |
|
break; |
|
|
|
case 'images-alt2': |
|
path = 'M5 3h14v11h-2v2h-2v2H1V7h2V5h2V3zm13 10V4H6v9h12zm-3-4c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm1 6v-1H5V6H4v9h12zM7 6l10 6H7V6zm7 11v-1H3V8H2v9h12z'; |
|
break; |
|
|
|
case 'index-card': |
|
path = 'M1 3.17V18h18V4H8v-.83c0-.32-.12-.6-.35-.83S7.14 2 6.82 2H2.18c-.33 0-.6.11-.83.34-.24.23-.35.51-.35.83zM10 6v2H3V6h7zm7 0v10h-5V6h5zm-7 4v2H3v-2h7zm0 4v2H3v-2h7z'; |
|
break; |
|
|
|
case 'info-outline': |
|
path = 'M9 15h2V9H9v6zm1-10c-.5 0-1 .5-1 1s.5 1 1 1 1-.5 1-1-.5-1-1-1zm0-4c-5 0-9 4-9 9s4 9 9 9 9-4 9-9-4-9-9-9zm0 16c-3.9 0-7-3.1-7-7s3.1-7 7-7 7 3.1 7 7-3.1 7-7 7z'; |
|
break; |
|
|
|
case 'info': |
|
path = 'M10 2c4.42 0 8 3.58 8 8s-3.58 8-8 8-8-3.58-8-8 3.58-8 8-8zm1 4c0-.55-.45-1-1-1s-1 .45-1 1 .45 1 1 1 1-.45 1-1zm0 9V9H9v6h2z'; |
|
break; |
|
|
|
case 'insert-after': |
|
path = 'M9 12h2v-2h2V8h-2V6H9v2H7v2h2v2zm1 4c3.9 0 7-3.1 7-7s-3.1-7-7-7-7 3.1-7 7 3.1 7 7 7zm0-12c2.8 0 5 2.2 5 5s-2.2 5-5 5-5-2.2-5-5 2.2-5 5-5zM3 19h14v-2H3v2z'; |
|
break; |
|
|
|
case 'insert-before': |
|
path = 'M11 8H9v2H7v2h2v2h2v-2h2v-2h-2V8zm-1-4c-3.9 0-7 3.1-7 7s3.1 7 7 7 7-3.1 7-7-3.1-7-7-7zm0 12c-2.8 0-5-2.2-5-5s2.2-5 5-5 5 2.2 5 5-2.2 5-5 5zM3 1v2h14V1H3z'; |
|
break; |
|
|
|
case 'insert': |
|
path = 'M10 1c-5 0-9 4-9 9s4 9 9 9 9-4 9-9-4-9-9-9zm0 16c-3.9 0-7-3.1-7-7s3.1-7 7-7 7 3.1 7 7-3.1 7-7 7zm1-11H9v3H6v2h3v3h2v-3h3V9h-3V6z'; |
|
break; |
|
|
|
case 'instagram': |
|
path = 'M12.67 10A2.67 2.67 0 1 0 10 12.67 2.68 2.68 0 0 0 12.67 10zm1.43 0A4.1 4.1 0 1 1 10 5.9a4.09 4.09 0 0 1 4.1 4.1zm1.13-4.27a1 1 0 1 1-1-1 1 1 0 0 1 1 1zM10 3.44c-1.17 0-3.67-.1-4.72.32a2.67 2.67 0 0 0-1.52 1.52c-.42 1-.32 3.55-.32 4.72s-.1 3.67.32 4.72a2.74 2.74 0 0 0 1.52 1.52c1 .42 3.55.32 4.72.32s3.67.1 4.72-.32a2.83 2.83 0 0 0 1.52-1.52c.42-1.05.32-3.55.32-4.72s.1-3.67-.32-4.72a2.74 2.74 0 0 0-1.52-1.52c-1.05-.42-3.55-.32-4.72-.32zM18 10c0 1.1 0 2.2-.05 3.3a4.84 4.84 0 0 1-1.29 3.36A4.8 4.8 0 0 1 13.3 18H6.7a4.84 4.84 0 0 1-3.36-1.29 4.84 4.84 0 0 1-1.29-3.41C2 12.2 2 11.1 2 10V6.7a4.84 4.84 0 0 1 1.34-3.36A4.8 4.8 0 0 1 6.7 2.05C7.8 2 8.9 2 10 2h3.3a4.84 4.84 0 0 1 3.36 1.29A4.8 4.8 0 0 1 18 6.7V10z'; |
|
break; |
|
|
|
case 'keyboard-hide': |
|
path = 'M18,0 L2,0 C0.9,0 0.01,0.9 0.01,2 L0,12 C0,13.1 0.9,14 2,14 L18,14 C19.1,14 20,13.1 20,12 L20,2 C20,0.9 19.1,0 18,0 Z M18,12 L2,12 L2,2 L18,2 L18,12 Z M9,3 L11,3 L11,5 L9,5 L9,3 Z M9,6 L11,6 L11,8 L9,8 L9,6 Z M6,3 L8,3 L8,5 L6,5 L6,3 Z M6,6 L8,6 L8,8 L6,8 L6,6 Z M3,6 L5,6 L5,8 L3,8 L3,6 Z M3,3 L5,3 L5,5 L3,5 L3,3 Z M6,9 L14,9 L14,11 L6,11 L6,9 Z M12,6 L14,6 L14,8 L12,8 L12,6 Z M12,3 L14,3 L14,5 L12,5 L12,3 Z M15,6 L17,6 L17,8 L15,8 L15,6 Z M15,3 L17,3 L17,5 L15,5 L15,3 Z M10,20 L14,16 L6,16 L10,20 Z'; |
|
break; |
|
|
|
case 'laptop': |
|
path = 'M3 3h14c.6 0 1 .4 1 1v10c0 .6-.4 1-1 1H3c-.6 0-1-.4-1-1V4c0-.6.4-1 1-1zm13 2H4v8h12V5zm-3 1H5v4zm6 11v-1H1v1c0 .6.5 1 1.1 1h15.8c.6 0 1.1-.4 1.1-1z'; |
|
break; |
|
|
|
case 'layout': |
|
path = 'M2 2h5v11H2V2zm6 0h5v5H8V2zm6 0h4v16h-4V2zM8 8h5v5H8V8zm-6 6h11v4H2v-4z'; |
|
break; |
|
|
|
case 'leftright': |
|
path = 'M3 10.03L9 6v8zM11 6l6 4.03L11 14V6z'; |
|
break; |
|
|
|
case 'lightbulb': |
|
path = 'M10 1c3.11 0 5.63 2.52 5.63 5.62 0 1.84-2.03 4.58-2.03 4.58-.33.44-.6 1.25-.6 1.8v1c0 .55-.45 1-1 1H8c-.55 0-1-.45-1-1v-1c0-.55-.27-1.36-.6-1.8 0 0-2.02-2.74-2.02-4.58C4.38 3.52 6.89 1 10 1zM7 16.87V16h6v.87c0 .62-.13 1.13-.75 1.13H12c0 .62-.4 1-1.02 1h-2c-.61 0-.98-.38-.98-1h-.25c-.62 0-.75-.51-.75-1.13z'; |
|
break; |
|
|
|
case 'list-view': |
|
path = 'M2 19h16c.55 0 1-.45 1-1V2c0-.55-.45-1-1-1H2c-.55 0-1 .45-1 1v16c0 .55.45 1 1 1zM4 3c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm13 0v2H6V3h11zM4 7c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm13 0v2H6V7h11zM4 11c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm13 0v2H6v-2h11zM4 15c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm13 0v2H6v-2h11z'; |
|
break; |
|
|
|
case 'location-alt': |
|
path = 'M13 13.14l1.17-5.94c.79-.43 1.33-1.25 1.33-2.2 0-1.38-1.12-2.5-2.5-2.5S10.5 3.62 10.5 5c0 .95.54 1.77 1.33 2.2zm0-9.64c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5-1.5-.67-1.5-1.5.67-1.5 1.5-1.5zm1.72 4.8L18 6.97v9L13.12 18 7 15.97l-5 2v-9l5-2 4.27 1.41 1.73 7.3z'; |
|
break; |
|
|
|
case 'location': |
|
path = 'M10 2C6.69 2 4 4.69 4 8c0 2.02 1.17 3.71 2.53 4.89.43.37 1.18.96 1.85 1.83.74.97 1.41 2.01 1.62 2.71.21-.7.88-1.74 1.62-2.71.67-.87 1.42-1.46 1.85-1.83C14.83 11.71 16 10.02 16 8c0-3.31-2.69-6-6-6zm0 2.56c1.9 0 3.44 1.54 3.44 3.44S11.9 11.44 10 11.44 6.56 9.9 6.56 8 8.1 4.56 10 4.56z'; |
|
break; |
|
|
|
case 'lock': |
|
path = 'M14 9h1c.55 0 1 .45 1 1v7c0 .55-.45 1-1 1H5c-.55 0-1-.45-1-1v-7c0-.55.45-1 1-1h1V6c0-2.21 1.79-4 4-4s4 1.79 4 4v3zm-2 0V6c0-1.1-.9-2-2-2s-2 .9-2 2v3h4zm-1 7l-.36-2.15c.51-.24.86-.75.86-1.35 0-.83-.67-1.5-1.5-1.5s-1.5.67-1.5 1.5c0 .6.35 1.11.86 1.35L9 16h2z'; |
|
break; |
|
|
|
case 'marker': |
|
path = 'M10 2c4.42 0 8 3.58 8 8s-3.58 8-8 8-8-3.58-8-8 3.58-8 8-8zm0 13c2.76 0 5-2.24 5-5s-2.24-5-5-5-5 2.24-5 5 2.24 5 5 5z'; |
|
break; |
|
|
|
case 'media-archive': |
|
path = 'M12 2l4 4v12H4V2h8zm0 4h3l-3-3v3zM8 3.5v2l1.8-1zM11 5L9.2 6 11 7V5zM8 6.5v2l1.8-1zM11 8L9.2 9l1.8 1V8zM8 9.5v2l1.8-1zm3 1.5l-1.8 1 1.8 1v-2zm-1.5 6c.83 0 1.62-.72 1.5-1.63-.05-.38-.49-1.61-.49-1.61l-1.99-1.1s-.45 1.95-.52 2.71c-.07.77.67 1.63 1.5 1.63zm0-2.39c.42 0 .76.34.76.76 0 .43-.34.77-.76.77s-.76-.34-.76-.77c0-.42.34-.76.76-.76z'; |
|
break; |
|
|
|
case 'media-audio': |
|
path = 'M12 2l4 4v12H4V2h8zm0 4h3l-3-3v3zm1 7.26V8.09c0-.11-.04-.21-.12-.29-.07-.08-.16-.11-.27-.1 0 0-3.97.71-4.25.78C8.07 8.54 8 8.8 8 9v3.37c-.2-.09-.42-.07-.6-.07-.38 0-.7.13-.96.39-.26.27-.4.58-.4.96 0 .37.14.69.4.95.26.27.58.4.96.4.34 0 .7-.04.96-.26.26-.23.64-.65.64-1.12V10.3l3-.6V12c-.67-.2-1.17.04-1.44.31-.26.26-.39.58-.39.95 0 .38.13.69.39.96.27.26.71.39 1.08.39.38 0 .7-.13.96-.39.26-.27.4-.58.4-.96z'; |
|
break; |
|
|
|
case 'media-code': |
|
path = 'M12 2l4 4v12H4V2h8zM9 13l-2-2 2-2-1-1-3 3 3 3zm3 1l3-3-3-3-1 1 2 2-2 2z'; |
|
break; |
|
|
|
case 'media-default': |
|
path = 'M12 2l4 4v12H4V2h8zm0 4h3l-3-3v3z'; |
|
break; |
|
|
|
case 'media-document': |
|
path = 'M12 2l4 4v12H4V2h8zM5 3v1h6V3H5zm7 3h3l-3-3v3zM5 5v1h6V5H5zm10 3V7H5v1h10zM5 9v1h4V9H5zm10 3V9h-5v3h5zM5 11v1h4v-1H5zm10 3v-1H5v1h10zm-3 2v-1H5v1h7z'; |
|
break; |
|
|
|
case 'media-interactive': |
|
path = 'M12 2l4 4v12H4V2h8zm0 4h3l-3-3v3zm2 8V8H6v6h3l-1 2h1l1-2 1 2h1l-1-2h3zm-6-3c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm5-2v2h-3V9h3zm0 3v1H7v-1h6z'; |
|
break; |
|
|
|
case 'media-spreadsheet': |
|
path = 'M12 2l4 4v12H4V2h8zm-1 4V3H5v3h6zM8 8V7H5v1h3zm3 0V7H9v1h2zm4 0V7h-3v1h3zm-7 2V9H5v1h3zm3 0V9H9v1h2zm4 0V9h-3v1h3zm-7 2v-1H5v1h3zm3 0v-1H9v1h2zm4 0v-1h-3v1h3zm-7 2v-1H5v1h3zm3 0v-1H9v1h2zm4 0v-1h-3v1h3zm-7 2v-1H5v1h3zm3 0v-1H9v1h2z'; |
|
break; |
|
|
|
case 'media-text': |
|
path = 'M12 2l4 4v12H4V2h8zM5 3v1h6V3H5zm7 3h3l-3-3v3zM5 5v1h6V5H5zm10 3V7H5v1h10zm0 2V9H5v1h10zm0 2v-1H5v1h10zm-4 2v-1H5v1h6z'; |
|
break; |
|
|
|
case 'media-video': |
|
path = 'M12 2l4 4v12H4V2h8zm0 4h3l-3-3v3zm-1 8v-3c0-.27-.1-.51-.29-.71-.2-.19-.44-.29-.71-.29H7c-.27 0-.51.1-.71.29-.19.2-.29.44-.29.71v3c0 .27.1.51.29.71.2.19.44.29.71.29h3c.27 0 .51-.1.71-.29.19-.2.29-.44.29-.71zm3 1v-5l-2 2v1z'; |
|
break; |
|
|
|
case 'megaphone': |
|
path = 'M18.15 5.94c.46 1.62.38 3.22-.02 4.48-.42 1.28-1.26 2.18-2.3 2.48-.16.06-.26.06-.4.06-.06.02-.12.02-.18.02-.06.02-.14.02-.22.02h-6.8l2.22 5.5c.02.14-.06.26-.14.34-.08.1-.24.16-.34.16H6.95c-.1 0-.26-.06-.34-.16-.08-.08-.16-.2-.14-.34l-1-5.5H4.25l-.02-.02c-.5.06-1.08-.18-1.54-.62s-.88-1.08-1.06-1.88c-.24-.8-.2-1.56-.02-2.2.18-.62.58-1.08 1.06-1.3l.02-.02 9-5.4c.1-.06.18-.1.24-.16.06-.04.14-.08.24-.12.16-.08.28-.12.5-.18 1.04-.3 2.24.1 3.22.98s1.84 2.24 2.26 3.86zm-2.58 5.98h-.02c.4-.1.74-.34 1.04-.7.58-.7.86-1.76.86-3.04 0-.64-.1-1.3-.28-1.98-.34-1.36-1.02-2.5-1.78-3.24s-1.68-1.1-2.46-.88c-.82.22-1.4.96-1.7 2-.32 1.04-.28 2.36.06 3.72.38 1.36 1 2.5 1.8 3.24.78.74 1.62 1.1 2.48.88zm-2.54-7.08c.22-.04.42-.02.62.04.38.16.76.48 1.02 1s.42 1.2.42 1.78c0 .3-.04.56-.12.8-.18.48-.44.84-.86.94-.34.1-.8-.06-1.14-.4s-.64-.86-.78-1.5c-.18-.62-.12-1.24.02-1.72s.48-.84.82-.94z'; |
|
break; |
|
|
|
case 'menu-alt': |
|
path = 'M3 4h14v2H3V4zm0 5h14v2H3V9zm0 5h14v2H3v-2z'; |
|
break; |
|
|
|
case 'menu': |
|
path = 'M17 7V5H3v2h14zm0 4V9H3v2h14zm0 4v-2H3v2h14z'; |
|
break; |
|
|
|
case 'microphone': |
|
path = 'M12 9V3c0-1.1-.89-2-2-2-1.12 0-2 .94-2 2v6c0 1.1.9 2 2 2 1.13 0 2-.94 2-2zm4 0c0 2.97-2.16 5.43-5 5.91V17h2c.56 0 1 .45 1 1s-.44 1-1 1H7c-.55 0-1-.45-1-1s.45-1 1-1h2v-2.09C6.17 14.43 4 11.97 4 9c0-.55.45-1 1-1 .56 0 1 .45 1 1 0 2.21 1.8 4 4 4 2.21 0 4-1.79 4-4 0-.55.45-1 1-1 .56 0 1 .45 1 1z'; |
|
break; |
|
|
|
case 'migrate': |
|
path = 'M4 6h6V4H2v12.01h8V14H4V6zm2 2h6V5l6 5-6 5v-3H6V8z'; |
|
break; |
|
|
|
case 'minus': |
|
path = 'M4 9h12v2H4V9z'; |
|
break; |
|
|
|
case 'money': |
|
path = 'M0 3h20v12h-.75c0-1.79-1.46-3.25-3.25-3.25-1.31 0-2.42.79-2.94 1.91-.25-.1-.52-.16-.81-.16-.98 0-1.8.63-2.11 1.5H0V3zm8.37 3.11c-.06.15-.1.31-.11.47s-.01.33.01.5l.02.08c.01.06.02.14.05.23.02.1.06.2.1.31.03.11.09.22.15.33.07.12.15.22.23.31s.18.17.31.23c.12.06.25.09.4.09.14 0 .27-.03.39-.09s.22-.14.3-.22c.09-.09.16-.2.22-.32.07-.12.12-.23.16-.33s.07-.2.09-.31c.03-.11.04-.18.05-.22s.01-.07.01-.09c.05-.29.03-.56-.04-.82s-.21-.48-.41-.66c-.21-.18-.47-.27-.79-.27-.19 0-.36.03-.52.1-.15.07-.28.16-.38.28-.09.11-.17.25-.24.4zm4.48 6.04v-1.14c0-.33-.1-.66-.29-.98s-.45-.59-.77-.79c-.32-.21-.66-.31-1.02-.31l-1.24.84-1.28-.82c-.37 0-.72.1-1.04.3-.31.2-.56.46-.74.77-.18.32-.27.65-.27.99v1.14l.18.05c.12.04.29.08.51.14.23.05.47.1.74.15.26.05.57.09.91.13.34.03.67.05.99.05.3 0 .63-.02.98-.05.34-.04.64-.08.89-.13.25-.04.5-.1.76-.16l.5-.12c.08-.02.14-.04.19-.06zm3.15.1c1.52 0 2.75 1.23 2.75 2.75s-1.23 2.75-2.75 2.75c-.73 0-1.38-.3-1.87-.77.23-.35.37-.78.37-1.23 0-.77-.39-1.46-.99-1.86.43-.96 1.37-1.64 2.49-1.64zm-5.5 3.5c0-.96.79-1.75 1.75-1.75s1.75.79 1.75 1.75-.79 1.75-1.75 1.75-1.75-.79-1.75-1.75z'; |
|
break; |
|
|
|
case 'move': |
|
path = 'M19 10l-4 4v-3h-4v4h3l-4 4-4-4h3v-4H5v3l-4-4 4-4v3h4V5H6l4-4 4 4h-3v4h4V6z'; |
|
break; |
|
|
|
case 'nametag': |
|
path = 'M12 5V2c0-.55-.45-1-1-1H9c-.55 0-1 .45-1 1v3c0 .55.45 1 1 1h2c.55 0 1-.45 1-1zm-2-3c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm8 13V7c0-1.1-.9-2-2-2h-3v.33C13 6.25 12.25 7 11.33 7H8.67C7.75 7 7 6.25 7 5.33V5H4c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2zm-1-6v6H3V9h14zm-8 2c0-.55-.22-1-.5-1s-.5.45-.5 1 .22 1 .5 1 .5-.45.5-1zm3 0c0-.55-.22-1-.5-1s-.5.45-.5 1 .22 1 .5 1 .5-.45.5-1zm-5.96 1.21c.92.48 2.34.79 3.96.79s3.04-.31 3.96-.79c-.21 1-1.89 1.79-3.96 1.79s-3.75-.79-3.96-1.79z'; |
|
break; |
|
|
|
case 'networking': |
|
path = 'M18 13h1c.55 0 1 .45 1 1.01v2.98c0 .56-.45 1.01-1 1.01h-4c-.55 0-1-.45-1-1.01v-2.98c0-.56.45-1.01 1-1.01h1v-2h-5v2h1c.55 0 1 .45 1 1.01v2.98c0 .56-.45 1.01-1 1.01H8c-.55 0-1-.45-1-1.01v-2.98c0-.56.45-1.01 1-1.01h1v-2H4v2h1c.55 0 1 .45 1 1.01v2.98C6 17.55 5.55 18 5 18H1c-.55 0-1-.45-1-1.01v-2.98C0 13.45.45 13 1 13h1v-2c0-1.1.9-2 2-2h5V7H8c-.55 0-1-.45-1-1.01V3.01C7 2.45 7.45 2 8 2h4c.55 0 1 .45 1 1.01v2.98C13 6.55 12.55 7 12 7h-1v2h5c1.1 0 2 .9 2 2v2z'; |
|
break; |
|
|
|
case 'no-alt': |
|
path = 'M14.95 6.46L11.41 10l3.54 3.54-1.41 1.41L10 11.42l-3.53 3.53-1.42-1.42L8.58 10 5.05 6.47l1.42-1.42L10 8.58l3.54-3.53z'; |
|
break; |
|
|
|
case 'no': |
|
path = 'M12.12 10l3.53 3.53-2.12 2.12L10 12.12l-3.54 3.54-2.12-2.12L7.88 10 4.34 6.46l2.12-2.12L10 7.88l3.54-3.53 2.12 2.12z'; |
|
break; |
|
|
|
case 'palmtree': |
|
path = 'M8.58 2.39c.32 0 .59.05.81.14 1.25.55 1.69 2.24 1.7 3.97.59-.82 2.15-2.29 3.41-2.29s2.94.73 3.53 3.55c-1.13-.65-2.42-.94-3.65-.94-1.26 0-2.45.32-3.29.89.4-.11.86-.16 1.33-.16 1.39 0 2.9.45 3.4 1.31.68 1.16.47 3.38-.76 4.14-.14-2.1-1.69-4.12-3.47-4.12-.44 0-.88.12-1.33.38C8 10.62 7 14.56 7 19H2c0-5.53 4.21-9.65 7.68-10.79-.56-.09-1.17-.15-1.82-.15C6.1 8.06 4.05 8.5 2 10c.76-2.96 2.78-4.1 4.69-4.1 1.25 0 2.45.5 3.2 1.29-.66-2.24-2.49-2.86-4.08-2.86-.8 0-1.55.16-2.05.35.91-1.29 3.31-2.29 4.82-2.29zM13 11.5c0-.83-.67-1.5-1.5-1.5s-1.5.67-1.5 1.5.67 1.5 1.5 1.5 1.5-.67 1.5-1.5z'; |
|
break; |
|
|
|
case 'paperclip': |
|
path = 'M17.05 2.7c1.93 1.94 1.93 5.13 0 7.07L10 16.84c-1.88 1.89-4.91 1.93-6.86.15-.06-.05-.13-.09-.19-.15-1.93-1.94-1.93-5.12 0-7.07l4.94-4.95c.91-.92 2.28-1.1 3.39-.58.3.15.59.33.83.58 1.17 1.17 1.17 3.07 0 4.24l-4.93 4.95c-.39.39-1.02.39-1.41 0s-.39-1.02 0-1.41l4.93-4.95c.39-.39.39-1.02 0-1.41-.38-.39-1.02-.39-1.4 0l-4.94 4.95c-.91.92-1.1 2.29-.57 3.4.14.3.32.59.57.84s.54.43.84.57c1.11.53 2.47.35 3.39-.57l7.05-7.07c1.16-1.17 1.16-3.08 0-4.25-.56-.55-1.28-.83-2-.86-.08.01-.16.01-.24 0-.22-.03-.43-.11-.6-.27-.39-.4-.38-1.05.02-1.45.16-.16.36-.24.56-.28.14-.02.27-.01.4.02 1.19.06 2.36.52 3.27 1.43z'; |
|
break; |
|
|
|
case 'performance': |
|
path = 'M3.76 17.01h12.48C17.34 15.63 18 13.9 18 12c0-4.41-3.58-8-8-8s-8 3.59-8 8c0 1.9.66 3.63 1.76 5.01zM9 6c0-.55.45-1 1-1s1 .45 1 1c0 .56-.45 1-1 1s-1-.44-1-1zM4 8c0-.55.45-1 1-1s1 .45 1 1c0 .56-.45 1-1 1s-1-.44-1-1zm4.52 3.4c.84-.83 6.51-3.5 6.51-3.5s-2.66 5.68-3.49 6.51c-.84.84-2.18.84-3.02 0-.83-.83-.83-2.18 0-3.01zM3 13c0-.55.45-1 1-1s1 .45 1 1c0 .56-.45 1-1 1s-1-.44-1-1zm6 0c0-.55.45-1 1-1s1 .45 1 1c0 .56-.45 1-1 1s-1-.44-1-1zm6 0c0-.55.45-1 1-1s1 .45 1 1c0 .56-.45 1-1 1s-1-.44-1-1z'; |
|
break; |
|
|
|
case 'phone': |
|
path = 'M12.06 6l-.21-.2c-.52-.54-.43-.79.08-1.3l2.72-2.75c.81-.82.96-1.21 1.73-.48l.21.2zm.53.45l4.4-4.4c.7.94 2.34 3.47 1.53 5.34-.73 1.67-1.09 1.75-2 3-1.85 2.11-4.18 4.37-6 6.07-1.26.91-1.31 1.33-3 2-1.8.71-4.4-.89-5.38-1.56l4.4-4.4 1.18 1.62c.34.46 1.2-.06 1.8-.66 1.04-1.05 3.18-3.18 4-4.07.59-.59 1.12-1.45.66-1.8zM1.57 16.5l-.21-.21c-.68-.74-.29-.9.52-1.7l2.74-2.72c.51-.49.75-.6 1.27-.11l.2.21z'; |
|
break; |
|
|
|
case 'playlist-audio': |
|
path = 'M17 3V1H2v2h15zm0 4V5H2v2h15zm-7 4V9H2v2h8zm7.45-1.96l-6 1.12c-.16.02-.19.03-.29.13-.11.09-.16.22-.16.37v4.59c-.29-.13-.66-.14-.93-.14-.54 0-1 .19-1.38.57s-.56.84-.56 1.38c0 .53.18.99.56 1.37s.84.57 1.38.57c.49 0 .92-.16 1.29-.48s.59-.71.65-1.19v-4.95L17 11.27v3.48c-.29-.13-.56-.19-.83-.19-.54 0-1.11.19-1.49.57-.38.37-.57.83-.57 1.37s.19.99.57 1.37.84.57 1.38.57c.53 0 .99-.19 1.37-.57s.57-.83.57-1.37V9.6c0-.16-.05-.3-.16-.41-.11-.12-.24-.17-.39-.15zM8 15v-2H2v2h6zm-2 4v-2H2v2h4z'; |
|
break; |
|
|
|
case 'playlist-video': |
|
path = 'M17 3V1H2v2h15zm0 4V5H2v2h15zM6 11V9H2v2h4zm2-2h9c.55 0 1 .45 1 1v8c0 .55-.45 1-1 1H8c-.55 0-1-.45-1-1v-8c0-.55.45-1 1-1zm3 7l3.33-2L11 12v4zm-5-1v-2H2v2h4zm0 4v-2H2v2h4z'; |
|
break; |
|
|
|
case 'plus-alt': |
|
path = 'M15.8 4.2c3.2 3.21 3.2 8.39 0 11.6-3.21 3.2-8.39 3.2-11.6 0C1 12.59 1 7.41 4.2 4.2 7.41 1 12.59 1 15.8 4.2zm-4.3 11.3v-4h4v-3h-4v-4h-3v4h-4v3h4v4h3z'; |
|
break; |
|
|
|
case 'plus-light': |
|
path = 'M17 9v2h-6v6H9v-6H3V9h6V3h2v6h6z'; |
|
break; |
|
|
|
case 'plus': |
|
path = 'M17 7v3h-5v5H9v-5H4V7h5V2h3v5h5z'; |
|
break; |
|
|
|
case 'portfolio': |
|
path = 'M4 5H.78c-.37 0-.74.32-.69.84l1.56 9.99S3.5 8.47 3.86 6.7c.11-.53.61-.7.98-.7H10s-.7-2.08-.77-2.31C9.11 3.25 8.89 3 8.45 3H5.14c-.36 0-.7.23-.8.64C4.25 4.04 4 5 4 5zm4.88 0h-4s.42-1 .87-1h2.13c.48 0 1 1 1 1zM2.67 16.25c-.31.47-.76.75-1.26.75h15.73c.54 0 .92-.31 1.03-.83.44-2.19 1.68-8.44 1.68-8.44.07-.5-.3-.73-.62-.73H16V5.53c0-.16-.26-.53-.66-.53h-3.76c-.52 0-.87.58-.87.58L10 7H5.59c-.32 0-.63.19-.69.5 0 0-1.59 6.7-1.72 7.33-.07.37-.22.99-.51 1.42zM15.38 7H11s.58-1 1.13-1h2.29c.71 0 .96 1 .96 1z'; |
|
break; |
|
|
|
case 'post-status': |
|
path = 'M14 6c0 1.86-1.28 3.41-3 3.86V16c0 1-2 2-2 2V9.86c-1.72-.45-3-2-3-3.86 0-2.21 1.79-4 4-4s4 1.79 4 4zM8 5c0 .55.45 1 1 1s1-.45 1-1-.45-1-1-1-1 .45-1 1z'; |
|
break; |
|
|
|
case 'pressthis': |
|
path = 'M14.76 1C16.55 1 18 2.46 18 4.25c0 1.78-1.45 3.24-3.24 3.24-.23 0-.47-.03-.7-.08L13 8.47V19H2V4h9.54c.13-2 1.52-3 3.22-3zm0 5.49C16 6.49 17 5.48 17 4.25 17 3.01 16 2 14.76 2s-2.24 1.01-2.24 2.25c0 .37.1.72.27 1.03L9.57 8.5c-.28.28-1.77 2.22-1.5 2.49.02.03.06.04.1.04.49 0 2.14-1.28 2.39-1.53l3.24-3.24c.29.14.61.23.96.23z'; |
|
break; |
|
|
|
case 'products': |
|
path = 'M17 8h1v11H2V8h1V6c0-2.76 2.24-5 5-5 .71 0 1.39.15 2 .42.61-.27 1.29-.42 2-.42 2.76 0 5 2.24 5 5v2zM5 6v2h2V6c0-1.13.39-2.16 1.02-3H8C6.35 3 5 4.35 5 6zm10 2V6c0-1.65-1.35-3-3-3h-.02c.63.84 1.02 1.87 1.02 3v2h2zm-5-4.22C9.39 4.33 9 5.12 9 6v2h2V6c0-.88-.39-1.67-1-2.22z'; |
|
break; |
|
|
|
case 'randomize': |
|
path = 'M18 6.01L14 9V7h-4l-5 8H2v-2h2l5-8h5V3zM2 5h3l1.15 2.17-1.12 1.8L4 7H2V5zm16 9.01L14 17v-2H9l-1.15-2.17 1.12-1.8L10 13h4v-2z'; |
|
break; |
|
|
|
case 'redo': |
|
path = 'M8 5h5V2l6 4-6 4V7H8c-2.2 0-4 1.8-4 4s1.8 4 4 4h5v2H8c-3.3 0-6-2.7-6-6s2.7-6 6-6z'; |
|
break; |
|
|
|
case 'rest-api': |
|
path = 'M3 4h2v12H3z'; |
|
break; |
|
|
|
case 'rss': |
|
path = 'M14.92 18H18C18 9.32 10.82 2.25 2 2.25v3.02c7.12 0 12.92 5.71 12.92 12.73zm-5.44 0h3.08C12.56 12.27 7.82 7.6 2 7.6v3.02c2 0 3.87.77 5.29 2.16C8.7 14.17 9.48 16.03 9.48 18zm-5.35-.02c1.17 0 2.13-.93 2.13-2.09 0-1.15-.96-2.09-2.13-2.09-1.18 0-2.13.94-2.13 2.09 0 1.16.95 2.09 2.13 2.09z'; |
|
break; |
|
|
|
case 'saved': |
|
path = 'M15.3 5.3l-6.8 6.8-2.8-2.8-1.4 1.4 4.2 4.2 8.2-8.2'; |
|
break; |
|
|
|
case 'schedule': |
|
path = 'M2 2h16v4H2V2zm0 10V8h4v4H2zm6-2V8h4v2H8zm6 3V8h4v5h-4zm-6 5v-6h4v6H8zm-6 0v-4h4v4H2zm12 0v-3h4v3h-4z'; |
|
break; |
|
|
|
case 'screenoptions': |
|
path = 'M9 9V3H3v6h6zm8 0V3h-6v6h6zm-8 8v-6H3v6h6zm8 0v-6h-6v6h6z'; |
|
break; |
|
|
|
case 'search': |
|
path = 'M12.14 4.18c1.87 1.87 2.11 4.75.72 6.89.12.1.22.21.36.31.2.16.47.36.81.59.34.24.56.39.66.47.42.31.73.57.94.78.32.32.6.65.84 1 .25.35.44.69.59 1.04.14.35.21.68.18 1-.02.32-.14.59-.36.81s-.49.34-.81.36c-.31.02-.65-.04-.99-.19-.35-.14-.7-.34-1.04-.59-.35-.24-.68-.52-1-.84-.21-.21-.47-.52-.77-.93-.1-.13-.25-.35-.47-.66-.22-.32-.4-.57-.56-.78-.16-.2-.29-.35-.44-.5-2.07 1.09-4.69.76-6.44-.98-2.14-2.15-2.14-5.64 0-7.78 2.15-2.15 5.63-2.15 7.78 0zm-1.41 6.36c1.36-1.37 1.36-3.58 0-4.95-1.37-1.37-3.59-1.37-4.95 0-1.37 1.37-1.37 3.58 0 4.95 1.36 1.37 3.58 1.37 4.95 0z'; |
|
break; |
|
|
|
case 'share-alt': |
|
path = 'M16.22 5.8c.47.69.29 1.62-.4 2.08-.69.47-1.62.29-2.08-.4-.16-.24-.35-.46-.55-.67-.21-.2-.43-.39-.67-.55s-.5-.3-.77-.41c-.27-.12-.55-.21-.84-.26-.59-.13-1.23-.13-1.82-.01-.29.06-.57.15-.84.27-.27.11-.53.25-.77.41s-.46.35-.66.55c-.21.21-.4.43-.56.67s-.3.5-.41.76c-.01.02-.01.03-.01.04-.1.24-.17.48-.23.72H1V6h2.66c.04-.07.07-.13.12-.2.27-.4.57-.77.91-1.11s.72-.65 1.11-.91c.4-.27.83-.51 1.28-.7s.93-.34 1.41-.43c.99-.21 2.03-.21 3.02 0 .48.09.96.24 1.41.43s.88.43 1.28.7c.39.26.77.57 1.11.91s.64.71.91 1.11zM12.5 10c0-1.38-1.12-2.5-2.5-2.5S7.5 8.62 7.5 10s1.12 2.5 2.5 2.5 2.5-1.12 2.5-2.5zm-8.72 4.2c-.47-.69-.29-1.62.4-2.09.69-.46 1.62-.28 2.08.41.16.24.35.46.55.67.21.2.43.39.67.55s.5.3.77.41c.27.12.55.2.84.26.59.13 1.23.12 1.82 0 .29-.06.57-.14.84-.26.27-.11.53-.25.77-.41s.46-.35.66-.55c.21-.21.4-.44.56-.67.16-.25.3-.5.41-.76.01-.02.01-.03.01-.04.1-.24.17-.48.23-.72H19v3h-2.66c-.04.06-.07.13-.12.2-.27.4-.57.77-.91 1.11s-.72.65-1.11.91c-.4.27-.83.51-1.28.7s-.93.33-1.41.43c-.99.21-2.03.21-3.02 0-.48-.1-.96-.24-1.41-.43s-.88-.43-1.28-.7c-.39-.26-.77-.57-1.11-.91s-.64-.71-.91-1.11z'; |
|
break; |
|
|
|
case 'share-alt2': |
|
path = 'M18 8l-5 4V9.01c-2.58.06-4.88.45-7 2.99.29-3.57 2.66-5.66 7-5.94V3zM4 14h11v-2l2-1.6V16H2V5h9.43c-1.83.32-3.31 1-4.41 2H4v7z'; |
|
break; |
|
|
|
case 'share': |
|
path = 'M14.5 12c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3c0-.24.03-.46.09-.69l-4.38-2.3c-.55.61-1.33.99-2.21.99-1.66 0-3-1.34-3-3s1.34-3 3-3c.88 0 1.66.39 2.21.99l4.38-2.3c-.06-.23-.09-.45-.09-.69 0-1.66 1.34-3 3-3s3 1.34 3 3-1.34 3-3 3c-.88 0-1.66-.39-2.21-.99l-4.38 2.3c.06.23.09.45.09.69s-.03.46-.09.69l4.38 2.3c.55-.61 1.33-.99 2.21-.99z'; |
|
break; |
|
|
|
case 'shield-alt': |
|
path = 'M10 2s3 2 7 2c0 11-7 14-7 14S3 15 3 4c4 0 7-2 7-2z'; |
|
break; |
|
|
|
case 'shield': |
|
path = 'M10 2s3 2 7 2c0 11-7 14-7 14S3 15 3 4c4 0 7-2 7-2zm0 8h5s1-1 1-5c0 0-5-1-6-2v7H5c1 4 5 7 5 7v-7z'; |
|
break; |
|
|
|
case 'shortcode': |
|
path = 'M6 14H4V6h2V4H2v12h4M7.1 17h2.1l3.7-14h-2.1M14 4v2h2v8h-2v2h4V4'; |
|
break; |
|
|
|
case 'slides': |
|
path = 'M5 14V6h10v8H5zm-3-1V7h2v6H2zm4-6v6h8V7H6zm10 0h2v6h-2V7zm-3 2V8H7v1h6zm0 3v-2H7v2h6z'; |
|
break; |
|
|
|
case 'smartphone': |
|
path = 'M6 2h8c.55 0 1 .45 1 1v14c0 .55-.45 1-1 1H6c-.55 0-1-.45-1-1V3c0-.55.45-1 1-1zm7 12V4H7v10h6zM8 5h4l-4 5V5z'; |
|
break; |
|
|
|
case 'smiley': |
|
path = 'M7 5.2c1.1 0 2 .89 2 2 0 .37-.11.71-.28 1C8.72 8.2 8 8 7 8s-1.72.2-1.72.2c-.17-.29-.28-.63-.28-1 0-1.11.9-2 2-2zm6 0c1.11 0 2 .89 2 2 0 .37-.11.71-.28 1 0 0-.72-.2-1.72-.2s-1.72.2-1.72.2c-.17-.29-.28-.63-.28-1 0-1.11.89-2 2-2zm-3 13.7c3.72 0 7.03-2.36 8.23-5.88l-1.32-.46C15.9 15.52 13.12 17.5 10 17.5s-5.9-1.98-6.91-4.94l-1.32.46c1.2 3.52 4.51 5.88 8.23 5.88z'; |
|
break; |
|
|
|
case 'sort': |
|
path = 'M11 7H1l5 7zm-2 7h10l-5-7z'; |
|
break; |
|
|
|
case 'sos': |
|
path = 'M18 10c0-4.42-3.58-8-8-8s-8 3.58-8 8 3.58 8 8 8 8-3.58 8-8zM7.23 3.57L8.72 7.3c-.62.29-1.13.8-1.42 1.42L3.57 7.23c.71-1.64 2.02-2.95 3.66-3.66zm9.2 3.66L12.7 8.72c-.29-.62-.8-1.13-1.42-1.42l1.49-3.73c1.64.71 2.95 2.02 3.66 3.66zM10 12c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm-6.43.77l3.73-1.49c.29.62.8 1.13 1.42 1.42l-1.49 3.73c-1.64-.71-2.95-2.02-3.66-3.66zm9.2 3.66l-1.49-3.73c.62-.29 1.13-.8 1.42-1.42l3.73 1.49c-.71 1.64-2.02 2.95-3.66 3.66z'; |
|
break; |
|
|
|
case 'star-empty': |
|
path = 'M10 1L7 7l-6 .75 4.13 4.62L4 19l6-3 6 3-1.12-6.63L19 7.75 13 7zm0 2.24l2.34 4.69 4.65.58-3.18 3.56.87 5.15L10 14.88l-4.68 2.34.87-5.15-3.18-3.56 4.65-.58z'; |
|
break; |
|
|
|
case 'star-filled': |
|
path = 'M10 1l3 6 6 .75-4.12 4.62L16 19l-6-3-6 3 1.13-6.63L1 7.75 7 7z'; |
|
break; |
|
|
|
case 'star-half': |
|
path = 'M10 1L7 7l-6 .75 4.13 4.62L4 19l6-3 6 3-1.12-6.63L19 7.75 13 7zm0 2.24l2.34 4.69 4.65.58-3.18 3.56.87 5.15L10 14.88V3.24z'; |
|
break; |
|
|
|
case 'sticky': |
|
path = 'M5 3.61V1.04l8.99-.01-.01 2.58c-1.22.26-2.16 1.35-2.16 2.67v.5c.01 1.31.93 2.4 2.17 2.66l-.01 2.58h-3.41l-.01 2.57c0 .6-.47 4.41-1.06 4.41-.6 0-1.08-3.81-1.08-4.41v-2.56L5 12.02l.01-2.58c1.23-.25 2.15-1.35 2.15-2.66v-.5c0-1.31-.92-2.41-2.16-2.67z'; |
|
break; |
|
|
|
case 'store': |
|
path = 'M1 10c.41.29.96.43 1.5.43.55 0 1.09-.14 1.5-.43.62-.46 1-1.17 1-2 0 .83.37 1.54 1 2 .41.29.96.43 1.5.43.55 0 1.09-.14 1.5-.43.62-.46 1-1.17 1-2 0 .83.37 1.54 1 2 .41.29.96.43 1.51.43.54 0 1.08-.14 1.49-.43.62-.46 1-1.17 1-2 0 .83.37 1.54 1 2 .41.29.96.43 1.5.43.55 0 1.09-.14 1.5-.43.63-.46 1-1.17 1-2V7l-3-7H4L0 7v1c0 .83.37 1.54 1 2zm2 8.99h5v-5h4v5h5v-7c-.37-.05-.72-.22-1-.43-.63-.45-1-.73-1-1.56 0 .83-.38 1.11-1 1.56-.41.3-.95.43-1.49.44-.55 0-1.1-.14-1.51-.44-.63-.45-1-.73-1-1.56 0 .83-.38 1.11-1 1.56-.41.3-.95.43-1.5.44-.54 0-1.09-.14-1.5-.44-.63-.45-1-.73-1-1.57 0 .84-.38 1.12-1 1.57-.29.21-.63.38-1 .44v6.99z'; |
|
break; |
|
|
|
case 'table-col-after': |
|
path = 'M14.08 12.864V9.216h3.648V7.424H14.08V3.776h-1.728v3.648H8.64v1.792h3.712v3.648zM0 17.92V0h20.48v17.92H0zM6.4 1.28H1.28v3.84H6.4V1.28zm0 5.12H1.28v3.84H6.4V6.4zm0 5.12H1.28v3.84H6.4v-3.84zM19.2 1.28H7.68v14.08H19.2V1.28z'; |
|
break; |
|
|
|
case 'table-col-before': |
|
path = 'M6.4 3.776v3.648H2.752v1.792H6.4v3.648h1.728V9.216h3.712V7.424H8.128V3.776zM0 17.92V0h20.48v17.92H0zM12.8 1.28H1.28v14.08H12.8V1.28zm6.4 0h-5.12v3.84h5.12V1.28zm0 5.12h-5.12v3.84h5.12V6.4zm0 5.12h-5.12v3.84h5.12v-3.84z'; |
|
break; |
|
|
|
case 'table-col-delete': |
|
path = 'M6.4 9.98L7.68 8.7v-.256L6.4 7.164V9.98zm6.4-1.532l1.28-1.28V9.92L12.8 8.64v-.192zm7.68 9.472V0H0v17.92h20.48zm-1.28-2.56h-5.12v-1.024l-.256.256-1.024-1.024v1.792H7.68v-1.792l-1.024 1.024-.256-.256v1.024H1.28V1.28H6.4v2.368l.704-.704.576.576V1.216h5.12V3.52l.96-.96.32.32V1.216h5.12V15.36zm-5.76-2.112l-3.136-3.136-3.264 3.264-1.536-1.536 3.264-3.264L5.632 5.44l1.536-1.536 3.136 3.136 3.2-3.2 1.536 1.536-3.2 3.2 3.136 3.136-1.536 1.536z'; |
|
break; |
|
|
|
case 'table-row-after': |
|
path = 'M13.824 10.176h-2.88v-2.88H9.536v2.88h-2.88v1.344h2.88v2.88h1.408v-2.88h2.88zM0 17.92V0h20.48v17.92H0zM6.4 1.28H1.28v3.84H6.4V1.28zm6.4 0H7.68v3.84h5.12V1.28zm6.4 0h-5.12v3.84h5.12V1.28zm0 5.056H1.28v9.024H19.2V6.336z'; |
|
break; |
|
|
|
case 'table-row-before': |
|
path = 'M6.656 6.464h2.88v2.88h1.408v-2.88h2.88V5.12h-2.88V2.24H9.536v2.88h-2.88zM0 17.92V0h20.48v17.92H0zm7.68-2.56h5.12v-3.84H7.68v3.84zm-6.4 0H6.4v-3.84H1.28v3.84zM19.2 1.28H1.28v9.024H19.2V1.28zm0 10.24h-5.12v3.84h5.12v-3.84z'; |
|
break; |
|
|
|
case 'table-row-delete': |
|
path = 'M17.728 11.456L14.592 8.32l3.2-3.2-1.536-1.536-3.2 3.2L9.92 3.648 8.384 5.12l3.2 3.2-3.264 3.264 1.536 1.536 3.264-3.264 3.136 3.136 1.472-1.536zM0 17.92V0h20.48v17.92H0zm19.2-6.4h-.448l-1.28-1.28H19.2V6.4h-1.792l1.28-1.28h.512V1.28H1.28v3.84h6.208l1.28 1.28H1.28v3.84h7.424l-1.28 1.28H1.28v3.84H19.2v-3.84z'; |
|
break; |
|
|
|
case 'tablet': |
|
path = 'M4 2h12c.55 0 1 .45 1 1v14c0 .55-.45 1-1 1H4c-.55 0-1-.45-1-1V3c0-.55.45-1 1-1zm11 14V4H5v12h10zM6 5h6l-6 5V5z'; |
|
break; |
|
|
|
case 'tag': |
|
path = 'M11 2h7v7L8 19l-7-7zm3 6c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2z'; |
|
break; |
|
|
|
case 'tagcloud': |
|
path = 'M11 3v4H1V3h10zm8 0v4h-7V3h7zM7 8v3H1V8h6zm12 0v3H8V8h11zM9 12v2H1v-2h8zm10 0v2h-9v-2h9zM6 15v1H1v-1h5zm5 0v1H7v-1h4zm3 0v1h-2v-1h2zm5 0v1h-4v-1h4z'; |
|
break; |
|
|
|
case 'testimonial': |
|
path = 'M4 3h12c.55 0 1.02.2 1.41.59S18 4.45 18 5v7c0 .55-.2 1.02-.59 1.41S16.55 14 16 14h-1l-5 5v-5H4c-.55 0-1.02-.2-1.41-.59S2 12.55 2 12V5c0-.55.2-1.02.59-1.41S3.45 3 4 3zm11 2H4v1h11V5zm1 3H4v1h12V8zm-3 3H4v1h9v-1z'; |
|
break; |
|
|
|
case 'text': |
|
path = 'M18 3v2H2V3h16zm-6 4v2H2V7h10zm6 0v2h-4V7h4zM8 11v2H2v-2h6zm10 0v2h-8v-2h8zm-4 4v2H2v-2h12z'; |
|
break; |
|
|
|
case 'thumbs-down': |
|
path = 'M7.28 18c-.15.02-.26-.02-.41-.07-.56-.19-.83-.79-.66-1.35.17-.55 1-3.04 1-3.58 0-.53-.75-1-1.35-1h-3c-.6 0-1-.4-1-1s2-7 2-7c.17-.39.55-1 1-1H14v9h-2.14c-.41.41-3.3 4.71-3.58 5.27-.21.41-.6.68-1 .73zM18 12h-2V3h2v9z'; |
|
break; |
|
|
|
case 'thumbs-up': |
|
path = 'M12.72 2c.15-.02.26.02.41.07.56.19.83.79.66 1.35-.17.55-1 3.04-1 3.58 0 .53.75 1 1.35 1h3c.6 0 1 .4 1 1s-2 7-2 7c-.17.39-.55 1-1 1H6V8h2.14c.41-.41 3.3-4.71 3.58-5.27.21-.41.6-.68 1-.73zM2 8h2v9H2V8z'; |
|
break; |
|
|
|
case 'tickets-alt': |
|
path = 'M20 6.38L18.99 9.2v-.01c-.52-.19-1.03-.16-1.53.08s-.85.62-1.04 1.14-.16 1.03.07 1.53c.24.5.62.84 1.15 1.03v.01l-1.01 2.82-15.06-5.38.99-2.79c.52.19 1.03.16 1.53-.08.5-.23.84-.61 1.03-1.13s.16-1.03-.08-1.53c-.23-.49-.61-.83-1.13-1.02L4.93 1zm-4.97 5.69l1.37-3.76c.12-.31.1-.65-.04-.95s-.39-.53-.7-.65L8.14 3.98c-.64-.23-1.37.12-1.6.74L5.17 8.48c-.24.65.1 1.37.74 1.6l7.52 2.74c.14.05.28.08.43.08.52 0 1-.33 1.17-.83zM7.97 4.45l7.51 2.73c.19.07.34.21.43.39.08.18.09.38.02.57l-1.37 3.76c-.13.38-.58.59-.96.45L6.09 9.61c-.39-.14-.59-.57-.45-.96l1.37-3.76c.1-.29.39-.49.7-.49.09 0 .17.02.26.05zm6.82 12.14c.35.27.75.41 1.2.41H16v3H0v-2.96c.55 0 1.03-.2 1.41-.59.39-.38.59-.86.59-1.41s-.2-1.02-.59-1.41-.86-.59-1.41-.59V10h1.05l-.28.8 2.87 1.02c-.51.16-.89.62-.89 1.18v4c0 .69.56 1.25 1.25 1.25h8c.69 0 1.25-.56 1.25-1.25v-1.75l.83.3c.12.43.36.78.71 1.04zM3.25 17v-4c0-.41.34-.75.75-.75h.83l7.92 2.83V17c0 .41-.34.75-.75.75H4c-.41 0-.75-.34-.75-.75z'; |
|
break; |
|
|
|
case 'tickets': |
|
path = 'M20 5.38L18.99 8.2v-.01c-1.04-.37-2.19.18-2.57 1.22-.37 1.04.17 2.19 1.22 2.56v.01l-1.01 2.82L1.57 9.42l.99-2.79c1.04.38 2.19-.17 2.56-1.21s-.17-2.18-1.21-2.55L4.93 0zm-5.45 3.37c.74-2.08-.34-4.37-2.42-5.12-2.08-.74-4.37.35-5.11 2.42-.74 2.08.34 4.38 2.42 5.12 2.07.74 4.37-.35 5.11-2.42zm-2.56-4.74c.89.32 1.57.94 1.97 1.71-.01-.01-.02-.01-.04-.02-.33-.12-.67.09-.78.4-.1.28-.03.57.05.91.04.27.09.62-.06 1.04-.1.29-.33.58-.65 1l-.74 1.01.08-4.08.4.11c.19.04.26-.24.08-.29 0 0-.57-.15-.92-.28-.34-.12-.88-.36-.88-.36-.18-.08-.3.19-.12.27 0 0 .16.08.34.16l.01 1.63L9.2 9.18l.08-4.11c.2.06.4.11.4.11.19.04.26-.23.07-.29 0 0-.56-.15-.91-.28-.07-.02-.14-.05-.22-.08.93-.7 2.19-.94 3.37-.52zM7.4 6.19c.17-.49.44-.92.78-1.27l.04 5c-.94-.95-1.3-2.39-.82-3.73zm4.04 4.75l2.1-2.63c.37-.41.57-.77.69-1.12.05-.12.08-.24.11-.35.09.57.04 1.18-.17 1.77-.45 1.25-1.51 2.1-2.73 2.33zm-.7-3.22l.02 3.22c0 .02 0 .04.01.06-.4 0-.8-.07-1.2-.21-.33-.12-.63-.28-.9-.48zm1.24 6.08l2.1.75c.24.84 1 1.45 1.91 1.45H16v3H0v-2.96c1.1 0 2-.89 2-2 0-1.1-.9-2-2-2V9h1.05l-.28.8 4.28 1.52C4.4 12.03 4 12.97 4 14c0 2.21 1.79 4 4 4s4-1.79 4-4c0-.07-.02-.13-.02-.2zm-6.53-2.33l1.48.53c-.14.04-.15.27.03.28 0 0 .18.02.37.03l.56 1.54-.78 2.36-1.31-3.9c.21-.01.41-.03.41-.03.19-.02.17-.31-.02-.3 0 0-.59.05-.96.05-.07 0-.15 0-.23-.01.13-.2.28-.38.45-.55zM4.4 14c0-.52.12-1.02.32-1.46l1.71 4.7C5.23 16.65 4.4 15.42 4.4 14zm4.19-1.41l1.72.62c.07.17.12.37.12.61 0 .31-.12.66-.28 1.16l-.35 1.2zM11.6 14c0 1.33-.72 2.49-1.79 3.11l1.1-3.18c.06-.17.1-.31.14-.46l.52.19c.02.11.03.22.03.34zm-4.62 3.45l1.08-3.14 1.11 3.03c.01.02.01.04.02.05-.37.13-.77.21-1.19.21-.35 0-.69-.06-1.02-.15z'; |
|
break; |
|
|
|
case 'tide': |
|
path = 'M17 7.2V3H3v7.1c2.6-.5 4.5-1.5 6.4-2.6.2-.2.4-.3.6-.5v3c-1.9 1.1-4 2.2-7 2.8V17h14V9.9c-2.6.5-4.4 1.5-6.2 2.6-.3.1-.5.3-.8.4V10c2-1.1 4-2.2 7-2.8z'; |
|
break; |
|
|
|
case 'translation': |
|
path = 'M11 7H9.49c-.63 0-1.25.3-1.59.7L7 5H4.13l-2.39 7h1.69l.74-2H7v4H2c-1.1 0-2-.9-2-2V5c0-1.1.9-2 2-2h7c1.1 0 2 .9 2 2v2zM6.51 9H4.49l1-2.93zM10 8h7c1.1 0 2 .9 2 2v7c0 1.1-.9 2-2 2h-7c-1.1 0-2-.9-2-2v-7c0-1.1.9-2 2-2zm7.25 5v-1.08h-3.17V9.75h-1.16v2.17H9.75V13h1.28c.11.85.56 1.85 1.28 2.62-.87.36-1.89.62-2.31.62-.01.02.22.97.2 1.46.84 0 2.21-.5 3.28-1.15 1.09.65 2.48 1.15 3.34 1.15-.02-.49.2-1.44.2-1.46-.43 0-1.49-.27-2.38-.63.7-.77 1.14-1.77 1.25-2.61h1.36zm-3.81 1.93c-.5-.46-.85-1.13-1.01-1.93h2.09c-.17.8-.51 1.47-1 1.93l-.04.03s-.03-.02-.04-.03z'; |
|
break; |
|
|
|
case 'trash': |
|
path = 'M12 4h3c.6 0 1 .4 1 1v1H3V5c0-.6.5-1 1-1h3c.2-1.1 1.3-2 2.5-2s2.3.9 2.5 2zM8 4h3c-.2-.6-.9-1-1.5-1S8.2 3.4 8 4zM4 7h11l-.9 10.1c0 .5-.5.9-1 .9H5.9c-.5 0-.9-.4-1-.9L4 7z'; |
|
break; |
|
|
|
case 'twitter': |
|
path = 'M18.94 4.46c-.49.73-1.11 1.38-1.83 1.9.01.15.01.31.01.47 0 4.85-3.69 10.44-10.43 10.44-2.07 0-4-.61-5.63-1.65.29.03.58.05.88.05 1.72 0 3.3-.59 4.55-1.57-1.6-.03-2.95-1.09-3.42-2.55.22.04.45.07.69.07.33 0 .66-.05.96-.13-1.67-.34-2.94-1.82-2.94-3.6v-.04c.5.27 1.06.44 1.66.46-.98-.66-1.63-1.78-1.63-3.06 0-.67.18-1.3.5-1.84 1.81 2.22 4.51 3.68 7.56 3.83-.06-.27-.1-.55-.1-.84 0-2.02 1.65-3.66 3.67-3.66 1.06 0 2.01.44 2.68 1.16.83-.17 1.62-.47 2.33-.89-.28.85-.86 1.57-1.62 2.02.75-.08 1.45-.28 2.11-.57z'; |
|
break; |
|
|
|
case 'undo': |
|
path = 'M12 5H7V2L1 6l6 4V7h5c2.2 0 4 1.8 4 4s-1.8 4-4 4H7v2h5c3.3 0 6-2.7 6-6s-2.7-6-6-6z'; |
|
break; |
|
|
|
case 'universal-access-alt': |
|
path = 'M19 10c0-4.97-4.03-9-9-9s-9 4.03-9 9 4.03 9 9 9 9-4.03 9-9zm-9-7.4c.83 0 1.5.67 1.5 1.5s-.67 1.51-1.5 1.51c-.82 0-1.5-.68-1.5-1.51s.68-1.5 1.5-1.5zM3.4 7.36c0-.65 6.6-.76 6.6-.76s6.6.11 6.6.76-4.47 1.4-4.47 1.4 1.69 8.14 1.06 8.38c-.62.24-3.19-5.19-3.19-5.19s-2.56 5.43-3.18 5.19c-.63-.24 1.06-8.38 1.06-8.38S3.4 8.01 3.4 7.36z'; |
|
break; |
|
|
|
case 'universal-access': |
|
path = 'M10 2.6c.83 0 1.5.67 1.5 1.5s-.67 1.51-1.5 1.51c-.82 0-1.5-.68-1.5-1.51s.68-1.5 1.5-1.5zM3.4 7.36c0-.65 6.6-.76 6.6-.76s6.6.11 6.6.76-4.47 1.4-4.47 1.4 1.69 8.14 1.06 8.38c-.62.24-3.19-5.19-3.19-5.19s-2.56 5.43-3.18 5.19c-.63-.24 1.06-8.38 1.06-8.38S3.4 8.01 3.4 7.36z'; |
|
break; |
|
|
|
case 'unlock': |
|
path = 'M12 9V6c0-1.1-.9-2-2-2s-2 .9-2 2H6c0-2.21 1.79-4 4-4s4 1.79 4 4v3h1c.55 0 1 .45 1 1v7c0 .55-.45 1-1 1H5c-.55 0-1-.45-1-1v-7c0-.55.45-1 1-1h7zm-1 7l-.36-2.15c.51-.24.86-.75.86-1.35 0-.83-.67-1.5-1.5-1.5s-1.5.67-1.5 1.5c0 .6.35 1.11.86 1.35L9 16h2z'; |
|
break; |
|
|
|
case 'update': |
|
path = 'M10.2 3.28c3.53 0 6.43 2.61 6.92 6h2.08l-3.5 4-3.5-4h2.32c-.45-1.97-2.21-3.45-4.32-3.45-1.45 0-2.73.71-3.54 1.78L4.95 5.66C6.23 4.2 8.11 3.28 10.2 3.28zm-.4 13.44c-3.52 0-6.43-2.61-6.92-6H.8l3.5-4c1.17 1.33 2.33 2.67 3.5 4H5.48c.45 1.97 2.21 3.45 4.32 3.45 1.45 0 2.73-.71 3.54-1.78l1.71 1.95c-1.28 1.46-3.15 2.38-5.25 2.38z'; |
|
break; |
|
|
|
case 'upload': |
|
path = 'M8 14V8H5l5-6 5 6h-3v6H8zm-2 2v-6H4v8h12.01v-8H14v6H6z'; |
|
break; |
|
|
|
case 'vault': |
|
path = 'M18 17V3c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v14c0 .55.45 1 1 1h14c.55 0 1-.45 1-1zm-1 0H3V3h14v14zM4.75 4h10.5c.41 0 .75.34.75.75V6h-1v3h1v2h-1v3h1v1.25c0 .41-.34.75-.75.75H4.75c-.41 0-.75-.34-.75-.75V4.75c0-.41.34-.75.75-.75zM13 10c0-2.21-1.79-4-4-4s-4 1.79-4 4 1.79 4 4 4 4-1.79 4-4zM9 7l.77 1.15C10.49 8.46 11 9.17 11 10c0 1.1-.9 2-2 2s-2-.9-2-2c0-.83.51-1.54 1.23-1.85z'; |
|
break; |
|
|
|
case 'video-alt': |
|
path = 'M8 5c0-.55-.45-1-1-1H2c-.55 0-1 .45-1 1 0 .57.49 1 1 1h5c.55 0 1-.45 1-1zm6 5l4-4v10l-4-4v-2zm-1 4V8c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h8c.55 0 1-.45 1-1z'; |
|
break; |
|
|
|
case 'video-alt2': |
|
path = 'M12 13V7c0-1.1-.9-2-2-2H3c-1.1 0-2 .9-2 2v6c0 1.1.9 2 2 2h7c1.1 0 2-.9 2-2zm1-2.5l6 4.5V5l-6 4.5v1z'; |
|
break; |
|
|
|
case 'video-alt3': |
|
path = 'M19 15V5c0-1.1-.9-2-2-2H4c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h13c1.1 0 2-.9 2-2zM8 14V6l6 4z'; |
|
break; |
|
|
|
case 'visibility': |
|
path = 'M19.7 9.4C17.7 6 14 3.9 10 3.9S2.3 6 .3 9.4L0 10l.3.6c2 3.4 5.7 5.5 9.7 5.5s7.7-2.1 9.7-5.5l.3-.6-.3-.6zM10 14.1c-3.1 0-6-1.6-7.7-4.1C3.6 8 5.7 6.6 8 6.1c-.9.6-1.5 1.7-1.5 2.9 0 1.9 1.6 3.5 3.5 3.5s3.5-1.6 3.5-3.5c0-1.2-.6-2.3-1.5-2.9 2.3.5 4.4 1.9 5.7 3.9-1.7 2.5-4.6 4.1-7.7 4.1z'; |
|
break; |
|
|
|
case 'warning': |
|
path = 'M10 2c4.42 0 8 3.58 8 8s-3.58 8-8 8-8-3.58-8-8 3.58-8 8-8zm1.13 9.38l.35-6.46H8.52l.35 6.46h2.26zm-.09 3.36c.24-.23.37-.55.37-.96 0-.42-.12-.74-.36-.97s-.59-.35-1.06-.35-.82.12-1.07.35-.37.55-.37.97c0 .41.13.73.38.96.26.23.61.34 1.06.34s.8-.11 1.05-.34z'; |
|
break; |
|
|
|
case 'welcome-add-page': |
|
path = 'M17 7V4h-2V2h-3v1H3v15h11V9h1V7h2zm-1-2v1h-2v2h-1V6h-2V5h2V3h1v2h2z'; |
|
break; |
|
|
|
case 'welcome-comments': |
|
path = 'M5 2h10c1.1 0 2 .9 2 2v8c0 1.1-.9 2-2 2h-2l-5 5v-5H5c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2zm8.5 8.5L11 8l2.5-2.5-1-1L10 7 7.5 4.5l-1 1L9 8l-2.5 2.5 1 1L10 9l2.5 2.5z'; |
|
break; |
|
|
|
case 'welcome-learn-more': |
|
path = 'M10 10L2.54 7.02 3 18H1l.48-11.41L0 6l10-4 10 4zm0-5c-.55 0-1 .22-1 .5s.45.5 1 .5 1-.22 1-.5-.45-.5-1-.5zm0 6l5.57-2.23c.71.94 1.2 2.07 1.36 3.3-.3-.04-.61-.07-.93-.07-2.55 0-4.78 1.37-6 3.41C8.78 13.37 6.55 12 4 12c-.32 0-.63.03-.93.07.16-1.23.65-2.36 1.36-3.3z'; |
|
break; |
|
|
|
case 'welcome-view-site': |
|
path = 'M18 14V4c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v10c0 .55.45 1 1 1h14c.55 0 1-.45 1-1zm-8-8c2.3 0 4.4 1.14 6 3-1.6 1.86-3.7 3-6 3s-4.4-1.14-6-3c1.6-1.86 3.7-3 6-3zm2 3c0-1.1-.9-2-2-2s-2 .9-2 2 .9 2 2 2 2-.9 2-2zm2 8h3v1H3v-1h3v-1h8v1z'; |
|
break; |
|
|
|
case 'welcome-widgets-menus': |
|
path = 'M19 16V3c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v13c0 .55.45 1 1 1h15c.55 0 1-.45 1-1zM4 4h13v4H4V4zm1 1v2h3V5H5zm4 0v2h3V5H9zm4 0v2h3V5h-3zm-8.5 5c.28 0 .5.22.5.5s-.22.5-.5.5-.5-.22-.5-.5.22-.5.5-.5zM6 10h4v1H6v-1zm6 0h5v5h-5v-5zm-7.5 2c.28 0 .5.22.5.5s-.22.5-.5.5-.5-.22-.5-.5.22-.5.5-.5zM6 12h4v1H6v-1zm7 0v2h3v-2h-3zm-8.5 2c.28 0 .5.22.5.5s-.22.5-.5.5-.5-.22-.5-.5.22-.5.5-.5zM6 14h4v1H6v-1z'; |
|
break; |
|
|
|
case 'welcome-write-blog': |
|
path = 'M16.89 1.2l1.41 1.41c.39.39.39 1.02 0 1.41L14 8.33V18H3V3h10.67l1.8-1.8c.4-.39 1.03-.4 1.42 0zm-5.66 8.48l5.37-5.36-1.42-1.42-5.36 5.37-.71 2.12z'; |
|
break; |
|
|
|
case 'wordpress-alt': |
|
path = 'M20 10c0-5.51-4.49-10-10-10C4.48 0 0 4.49 0 10c0 5.52 4.48 10 10 10 5.51 0 10-4.48 10-10zM7.78 15.37L4.37 6.22c.55-.02 1.17-.08 1.17-.08.5-.06.44-1.13-.06-1.11 0 0-1.45.11-2.37.11-.18 0-.37 0-.58-.01C4.12 2.69 6.87 1.11 10 1.11c2.33 0 4.45.87 6.05 2.34-.68-.11-1.65.39-1.65 1.58 0 .74.45 1.36.9 2.1.35.61.55 1.36.55 2.46 0 1.49-1.4 5-1.4 5l-3.03-8.37c.54-.02.82-.17.82-.17.5-.05.44-1.25-.06-1.22 0 0-1.44.12-2.38.12-.87 0-2.33-.12-2.33-.12-.5-.03-.56 1.2-.06 1.22l.92.08 1.26 3.41zM17.41 10c.24-.64.74-1.87.43-4.25.7 1.29 1.05 2.71 1.05 4.25 0 3.29-1.73 6.24-4.4 7.78.97-2.59 1.94-5.2 2.92-7.78zM6.1 18.09C3.12 16.65 1.11 13.53 1.11 10c0-1.3.23-2.48.72-3.59C3.25 10.3 4.67 14.2 6.1 18.09zm4.03-6.63l2.58 6.98c-.86.29-1.76.45-2.71.45-.79 0-1.57-.11-2.29-.33.81-2.38 1.62-4.74 2.42-7.1z'; |
|
break; |
|
|
|
case 'wordpress': |
|
path = 'M20 10c0-5.52-4.48-10-10-10S0 4.48 0 10s4.48 10 10 10 10-4.48 10-10zM10 1.01c4.97 0 8.99 4.02 8.99 8.99s-4.02 8.99-8.99 8.99S1.01 14.97 1.01 10 5.03 1.01 10 1.01zM8.01 14.82L4.96 6.61c.49-.03 1.05-.08 1.05-.08.43-.05.38-1.01-.06-.99 0 0-1.29.1-2.13.1-.15 0-.33 0-.52-.01 1.44-2.17 3.9-3.6 6.7-3.6 2.09 0 3.99.79 5.41 2.09-.6-.08-1.45.35-1.45 1.42 0 .66.38 1.22.79 1.88.31.54.5 1.22.5 2.21 0 1.34-1.27 4.48-1.27 4.48l-2.71-7.5c.48-.03.75-.16.75-.16.43-.05.38-1.1-.05-1.08 0 0-1.3.11-2.14.11-.78 0-2.11-.11-2.11-.11-.43-.02-.48 1.06-.05 1.08l.84.08 1.12 3.04zm6.02 2.15L16.64 10s.67-1.69.39-3.81c.63 1.14.94 2.42.94 3.81 0 2.96-1.56 5.58-3.94 6.97zM2.68 6.77L6.5 17.25c-2.67-1.3-4.47-4.08-4.47-7.25 0-1.16.2-2.23.65-3.23zm7.45 4.53l2.29 6.25c-.75.27-1.57.42-2.42.42-.72 0-1.41-.11-2.06-.3z'; |
|
break; |
|
|
|
case 'yes-alt': |
|
path = 'M10 2c-4.42 0-8 3.58-8 8s3.58 8 8 8 8-3.58 8-8-3.58-8-8-8zm-.615 12.66h-1.34l-3.24-4.54 1.34-1.25 2.57 2.4 5.14-5.93 1.34.94-5.81 8.38z'; |
|
break; |
|
|
|
case 'yes': |
|
path = 'M14.83 4.89l1.34.94-5.81 8.38H9.02L5.78 9.67l1.34-1.25 2.57 2.4z'; |
|
break; |
|
} |
|
|
|
if (!path) { |
|
return null; |
|
} |
|
|
|
var iconClass = getIconClassName(icon, className, ariaPressed); |
|
return Object(external_this_wp_element_["createElement"])(svg_SVG, Object(esm_extends["a" /* default */])({ |
|
"aria-hidden": true, |
|
role: "img", |
|
focusable: "false", |
|
className: iconClass, |
|
xmlns: "http://www.w3.org/2000/svg", |
|
width: size, |
|
height: size, |
|
viewBox: "0 0 20 20" |
|
}, extraProps), Object(external_this_wp_element_["createElement"])(svg_Path, { |
|
d: path |
|
})); |
|
} |
|
}]); |
|
|
|
return Dashicon; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/icon/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
function Icon(_ref) { |
|
var _ref$icon = _ref.icon, |
|
icon = _ref$icon === void 0 ? null : _ref$icon, |
|
size = _ref.size, |
|
additionalProps = Object(objectWithoutProperties["a" /* default */])(_ref, ["icon", "size"]); |
|
|
|
var iconSize; |
|
|
|
if ('string' === typeof icon) { |
|
// Dashicons should be 20x20 by default |
|
iconSize = size || 20; |
|
return Object(external_this_wp_element_["createElement"])(dashicon_Dashicon, Object(esm_extends["a" /* default */])({ |
|
icon: icon, |
|
size: iconSize |
|
}, additionalProps)); |
|
} // Any other icons should be 24x24 by default |
|
|
|
|
|
iconSize = size || 24; |
|
|
|
if ('function' === typeof icon) { |
|
if (icon.prototype instanceof external_this_wp_element_["Component"]) { |
|
return Object(external_this_wp_element_["createElement"])(icon, Object(objectSpread["a" /* default */])({ |
|
size: iconSize |
|
}, additionalProps)); |
|
} |
|
|
|
return icon(Object(objectSpread["a" /* default */])({ |
|
size: iconSize |
|
}, additionalProps)); |
|
} |
|
|
|
if (icon && (icon.type === 'svg' || icon.type === svg_SVG)) { |
|
var appliedProps = Object(objectSpread["a" /* default */])({ |
|
width: iconSize, |
|
height: iconSize |
|
}, icon.props, additionalProps); |
|
|
|
return Object(external_this_wp_element_["createElement"])(svg_SVG, appliedProps); |
|
} |
|
|
|
if (Object(external_this_wp_element_["isValidElement"])(icon)) { |
|
return Object(external_this_wp_element_["cloneElement"])(icon, Object(objectSpread["a" /* default */])({ |
|
size: iconSize |
|
}, additionalProps)); |
|
} |
|
|
|
return icon; |
|
} |
|
|
|
/* harmony default export */ var build_module_icon = (Icon); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/icon-button/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
function IconButton(props, ref) { |
|
var icon = props.icon, |
|
children = props.children, |
|
label = props.label, |
|
className = props.className, |
|
tooltip = props.tooltip, |
|
shortcut = props.shortcut, |
|
labelPosition = props.labelPosition, |
|
additionalProps = Object(objectWithoutProperties["a" /* default */])(props, ["icon", "children", "label", "className", "tooltip", "shortcut", "labelPosition"]); |
|
|
|
var classes = classnames_default()('components-icon-button', className, { |
|
'has-text': children |
|
}); |
|
var tooltipText = tooltip || label; // Should show the tooltip if... |
|
|
|
var showTooltip = !additionalProps.disabled && ( // an explicit tooltip is passed or... |
|
tooltip || // there's a shortcut or... |
|
shortcut || // there's a label and... |
|
!!label && ( // the children are empty and... |
|
!children || Object(external_lodash_["isArray"])(children) && !children.length) && // the tooltip is not explicitly disabled. |
|
false !== tooltip); |
|
var element = Object(external_this_wp_element_["createElement"])(build_module_button, Object(esm_extends["a" /* default */])({ |
|
"aria-label": label |
|
}, additionalProps, { |
|
className: classes, |
|
ref: ref |
|
}), Object(external_lodash_["isString"])(icon) ? Object(external_this_wp_element_["createElement"])(build_module_icon, { |
|
icon: icon |
|
}) : icon, children); |
|
|
|
if (showTooltip) { |
|
element = Object(external_this_wp_element_["createElement"])(build_module_tooltip, { |
|
text: tooltipText, |
|
shortcut: shortcut, |
|
position: labelPosition |
|
}, element); |
|
} |
|
|
|
return element; |
|
} |
|
|
|
/* harmony default export */ var icon_button = (Object(external_this_wp_element_["forwardRef"])(IconButton)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/scroll-lock/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Creates a ScrollLock component bound to the specified document. |
|
* |
|
* This function creates a ScrollLock component for the specified document |
|
* and is exposed so we can create an isolated component for unit testing. |
|
* |
|
* @param {Object} args Keyword args. |
|
* @param {HTMLDocument} args.htmlDocument The document to lock the scroll for. |
|
* @param {string} args.className The name of the class used to lock scrolling. |
|
* @return {Component} The bound ScrollLock component. |
|
*/ |
|
|
|
function createScrollLockComponent() { |
|
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, |
|
_ref$htmlDocument = _ref.htmlDocument, |
|
htmlDocument = _ref$htmlDocument === void 0 ? document : _ref$htmlDocument, |
|
_ref$className = _ref.className, |
|
className = _ref$className === void 0 ? 'lockscroll' : _ref$className; |
|
|
|
var lockCounter = 0; |
|
/* |
|
* Setting `overflow: hidden` on html and body elements resets body scroll in iOS. |
|
* Save scroll top so we can restore it after locking scroll. |
|
* |
|
* NOTE: It would be cleaner and possibly safer to find a localized solution such |
|
* as preventing default on certain touchmove events. |
|
*/ |
|
|
|
var previousScrollTop = 0; |
|
/** |
|
* Locks and unlocks scroll depending on the boolean argument. |
|
* |
|
* @param {boolean} locked Whether or not scroll should be locked. |
|
*/ |
|
|
|
function setLocked(locked) { |
|
var scrollingElement = htmlDocument.scrollingElement || htmlDocument.body; |
|
|
|
if (locked) { |
|
previousScrollTop = scrollingElement.scrollTop; |
|
} |
|
|
|
var methodName = locked ? 'add' : 'remove'; |
|
scrollingElement.classList[methodName](className); // Adding the class to the document element seems to be necessary in iOS. |
|
|
|
htmlDocument.documentElement.classList[methodName](className); |
|
|
|
if (!locked) { |
|
scrollingElement.scrollTop = previousScrollTop; |
|
} |
|
} |
|
/** |
|
* Requests scroll lock. |
|
* |
|
* This function tracks requests for scroll lock. It locks scroll on the first |
|
* request and counts each request so `releaseLock` can unlock scroll when |
|
* all requests have been released. |
|
*/ |
|
|
|
|
|
function requestLock() { |
|
if (lockCounter === 0) { |
|
setLocked(true); |
|
} |
|
|
|
++lockCounter; |
|
} |
|
/** |
|
* Releases a request for scroll lock. |
|
* |
|
* This function tracks released requests for scroll lock. When all requests |
|
* have been released, it unlocks scroll. |
|
*/ |
|
|
|
|
|
function releaseLock() { |
|
if (lockCounter === 1) { |
|
setLocked(false); |
|
} |
|
|
|
--lockCounter; |
|
} |
|
|
|
return ( |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(ScrollLock, _Component); |
|
|
|
function ScrollLock() { |
|
Object(classCallCheck["a" /* default */])(this, ScrollLock); |
|
|
|
return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(ScrollLock).apply(this, arguments)); |
|
} |
|
|
|
Object(createClass["a" /* default */])(ScrollLock, [{ |
|
key: "componentDidMount", |
|
|
|
/** |
|
* Requests scroll lock on mount. |
|
*/ |
|
value: function componentDidMount() { |
|
requestLock(); |
|
} |
|
/** |
|
* Releases scroll lock before unmount. |
|
*/ |
|
|
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
releaseLock(); |
|
} |
|
/** |
|
* Render nothing as this component is merely a way to declare scroll lock. |
|
* |
|
* @return {null} Render nothing by returning `null`. |
|
*/ |
|
|
|
}, { |
|
key: "render", |
|
value: function render() { |
|
return null; |
|
} |
|
}]); |
|
|
|
return ScrollLock; |
|
}(external_this_wp_element_["Component"]) |
|
); |
|
} |
|
/* harmony default export */ var scroll_lock = (createScrollLockComponent()); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/isolated-event-container/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
var isolated_event_container_IsolatedEventContainer = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(IsolatedEventContainer, _Component); |
|
|
|
function IsolatedEventContainer(props) { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, IsolatedEventContainer); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(IsolatedEventContainer).call(this, props)); |
|
_this.stopEventPropagationOutsideContainer = _this.stopEventPropagationOutsideContainer.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(IsolatedEventContainer, [{ |
|
key: "stopEventPropagationOutsideContainer", |
|
value: function stopEventPropagationOutsideContainer(event) { |
|
event.stopPropagation(); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
children = _this$props.children, |
|
props = Object(objectWithoutProperties["a" /* default */])(_this$props, ["children"]); // Disable reason: this stops certain events from propagating outside of the component. |
|
// - onMouseDown is disabled as this can cause interactions with other DOM elements |
|
|
|
/* eslint-disable jsx-a11y/no-static-element-interactions */ |
|
|
|
|
|
return Object(external_this_wp_element_["createElement"])("div", Object(esm_extends["a" /* default */])({}, props, { |
|
onMouseDown: this.stopEventPropagationOutsideContainer |
|
}), children); |
|
/* eslint-enable jsx-a11y/no-static-element-interactions */ |
|
} |
|
}]); |
|
|
|
return IsolatedEventContainer; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var isolated_event_container = (isolated_event_container_IsolatedEventContainer); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/context.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
var SlotFillContext = Object(external_this_wp_element_["createContext"])({ |
|
registerSlot: function registerSlot() {}, |
|
unregisterSlot: function unregisterSlot() {}, |
|
registerFill: function registerFill() {}, |
|
unregisterFill: function unregisterFill() {}, |
|
getSlot: function getSlot() {}, |
|
getFills: function getFills() {}, |
|
subscribe: function subscribe() {} |
|
}); |
|
var context_Provider = SlotFillContext.Provider, |
|
context_Consumer = SlotFillContext.Consumer; |
|
|
|
var context_SlotFillProvider = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(SlotFillProvider, _Component); |
|
|
|
function SlotFillProvider() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, SlotFillProvider); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(SlotFillProvider).apply(this, arguments)); |
|
_this.registerSlot = _this.registerSlot.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.registerFill = _this.registerFill.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.unregisterSlot = _this.unregisterSlot.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.unregisterFill = _this.unregisterFill.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.getSlot = _this.getSlot.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.getFills = _this.getFills.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.subscribe = _this.subscribe.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.slots = {}; |
|
_this.fills = {}; |
|
_this.listeners = []; |
|
_this.contextValue = { |
|
registerSlot: _this.registerSlot, |
|
unregisterSlot: _this.unregisterSlot, |
|
registerFill: _this.registerFill, |
|
unregisterFill: _this.unregisterFill, |
|
getSlot: _this.getSlot, |
|
getFills: _this.getFills, |
|
subscribe: _this.subscribe |
|
}; |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(SlotFillProvider, [{ |
|
key: "registerSlot", |
|
value: function registerSlot(name, slot) { |
|
var previousSlot = this.slots[name]; |
|
this.slots[name] = slot; |
|
this.triggerListeners(); // Sometimes the fills are registered after the initial render of slot |
|
// But before the registerSlot call, we need to rerender the slot |
|
|
|
this.forceUpdateSlot(name); // If a new instance of a slot is being mounted while another with the |
|
// same name exists, force its update _after_ the new slot has been |
|
// assigned into the instance, such that its own rendering of children |
|
// will be empty (the new Slot will subsume all fills for this name). |
|
|
|
if (previousSlot) { |
|
previousSlot.forceUpdate(); |
|
} |
|
} |
|
}, { |
|
key: "registerFill", |
|
value: function registerFill(name, instance) { |
|
this.fills[name] = [].concat(Object(toConsumableArray["a" /* default */])(this.fills[name] || []), [instance]); |
|
this.forceUpdateSlot(name); |
|
} |
|
}, { |
|
key: "unregisterSlot", |
|
value: function unregisterSlot(name, instance) { |
|
// If a previous instance of a Slot by this name unmounts, do nothing, |
|
// as the slot and its fills should only be removed for the current |
|
// known instance. |
|
if (this.slots[name] !== instance) { |
|
return; |
|
} |
|
|
|
delete this.slots[name]; |
|
this.triggerListeners(); |
|
} |
|
}, { |
|
key: "unregisterFill", |
|
value: function unregisterFill(name, instance) { |
|
this.fills[name] = Object(external_lodash_["without"])(this.fills[name], instance); |
|
this.resetFillOccurrence(name); |
|
this.forceUpdateSlot(name); |
|
} |
|
}, { |
|
key: "getSlot", |
|
value: function getSlot(name) { |
|
return this.slots[name]; |
|
} |
|
}, { |
|
key: "getFills", |
|
value: function getFills(name, slotInstance) { |
|
// Fills should only be returned for the current instance of the slot |
|
// in which they occupy. |
|
if (this.slots[name] !== slotInstance) { |
|
return []; |
|
} |
|
|
|
return Object(external_lodash_["sortBy"])(this.fills[name], 'occurrence'); |
|
} |
|
}, { |
|
key: "resetFillOccurrence", |
|
value: function resetFillOccurrence(name) { |
|
Object(external_lodash_["forEach"])(this.fills[name], function (instance) { |
|
instance.occurrence = undefined; |
|
}); |
|
} |
|
}, { |
|
key: "forceUpdateSlot", |
|
value: function forceUpdateSlot(name) { |
|
var slot = this.getSlot(name); |
|
|
|
if (slot) { |
|
slot.forceUpdate(); |
|
} |
|
} |
|
}, { |
|
key: "triggerListeners", |
|
value: function triggerListeners() { |
|
this.listeners.forEach(function (listener) { |
|
return listener(); |
|
}); |
|
} |
|
}, { |
|
key: "subscribe", |
|
value: function subscribe(listener) { |
|
var _this2 = this; |
|
|
|
this.listeners.push(listener); |
|
return function () { |
|
_this2.listeners = Object(external_lodash_["without"])(_this2.listeners, listener); |
|
}; |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
return Object(external_this_wp_element_["createElement"])(context_Provider, { |
|
value: this.contextValue |
|
}, this.props.children); |
|
} |
|
}]); |
|
|
|
return SlotFillProvider; |
|
}(external_this_wp_element_["Component"]); |
|
/** |
|
* React hook returning the active slot given a name. |
|
* |
|
* @param {string} name Slot name. |
|
* @return {Object} Slot object. |
|
*/ |
|
|
|
|
|
var context_useSlot = function useSlot(name) { |
|
var _useContext = Object(external_this_wp_element_["useContext"])(SlotFillContext), |
|
getSlot = _useContext.getSlot, |
|
subscribe = _useContext.subscribe; |
|
|
|
var _useState = Object(external_this_wp_element_["useState"])(getSlot(name)), |
|
_useState2 = Object(slicedToArray["a" /* default */])(_useState, 2), |
|
slot = _useState2[0], |
|
setSlot = _useState2[1]; |
|
|
|
Object(external_this_wp_element_["useEffect"])(function () { |
|
setSlot(getSlot(name)); |
|
var unsubscribe = subscribe(function () { |
|
setSlot(getSlot(name)); |
|
}); |
|
return unsubscribe; |
|
}, [name]); |
|
return slot; |
|
}; |
|
/* harmony default export */ var slot_fill_context = (context_SlotFillProvider); |
|
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/slot.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
var slot_SlotComponent = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(SlotComponent, _Component); |
|
|
|
function SlotComponent() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, SlotComponent); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(SlotComponent).apply(this, arguments)); |
|
_this.bindNode = _this.bindNode.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(SlotComponent, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
var registerSlot = this.props.registerSlot; |
|
registerSlot(this.props.name, this); |
|
} |
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
var unregisterSlot = this.props.unregisterSlot; |
|
unregisterSlot(this.props.name, this); |
|
} |
|
}, { |
|
key: "componentDidUpdate", |
|
value: function componentDidUpdate(prevProps) { |
|
var _this$props = this.props, |
|
name = _this$props.name, |
|
unregisterSlot = _this$props.unregisterSlot, |
|
registerSlot = _this$props.registerSlot; |
|
|
|
if (prevProps.name !== name) { |
|
unregisterSlot(prevProps.name); |
|
registerSlot(name, this); |
|
} |
|
} |
|
}, { |
|
key: "bindNode", |
|
value: function bindNode(node) { |
|
this.node = node; |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props2 = this.props, |
|
children = _this$props2.children, |
|
name = _this$props2.name, |
|
_this$props2$bubblesV = _this$props2.bubblesVirtually, |
|
bubblesVirtually = _this$props2$bubblesV === void 0 ? false : _this$props2$bubblesV, |
|
_this$props2$fillProp = _this$props2.fillProps, |
|
fillProps = _this$props2$fillProp === void 0 ? {} : _this$props2$fillProp, |
|
getFills = _this$props2.getFills, |
|
className = _this$props2.className; |
|
|
|
if (bubblesVirtually) { |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
ref: this.bindNode, |
|
className: className |
|
}); |
|
} |
|
|
|
var fills = Object(external_lodash_["map"])(getFills(name, this), function (fill) { |
|
var fillKey = fill.occurrence; |
|
var fillChildren = Object(external_lodash_["isFunction"])(fill.children) ? fill.children(fillProps) : fill.children; |
|
return external_this_wp_element_["Children"].map(fillChildren, function (child, childIndex) { |
|
if (!child || Object(external_lodash_["isString"])(child)) { |
|
return child; |
|
} |
|
|
|
var childKey = "".concat(fillKey, "---").concat(child.key || childIndex); |
|
return Object(external_this_wp_element_["cloneElement"])(child, { |
|
key: childKey |
|
}); |
|
}); |
|
}).filter( // In some cases fills are rendered only when some conditions apply. |
|
// This ensures that we only use non-empty fills when rendering, i.e., |
|
// it allows us to render wrappers only when the fills are actually present. |
|
Object(external_lodash_["negate"])(external_this_wp_element_["isEmptyElement"])); |
|
return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_lodash_["isFunction"])(children) ? children(fills) : fills); |
|
} |
|
}]); |
|
|
|
return SlotComponent; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
var slot_Slot = function Slot(props) { |
|
return Object(external_this_wp_element_["createElement"])(context_Consumer, null, function (_ref) { |
|
var registerSlot = _ref.registerSlot, |
|
unregisterSlot = _ref.unregisterSlot, |
|
getFills = _ref.getFills; |
|
return Object(external_this_wp_element_["createElement"])(slot_SlotComponent, Object(esm_extends["a" /* default */])({}, props, { |
|
registerSlot: registerSlot, |
|
unregisterSlot: unregisterSlot, |
|
getFills: getFills |
|
})); |
|
}); |
|
}; |
|
|
|
/* harmony default export */ var slot_fill_slot = (slot_Slot); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/fill.js |
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
var occurrences = 0; |
|
|
|
function fill_FillComponent(_ref) { |
|
var name = _ref.name, |
|
children = _ref.children, |
|
registerFill = _ref.registerFill, |
|
unregisterFill = _ref.unregisterFill; |
|
var slot = context_useSlot(name); |
|
var ref = Object(external_this_wp_element_["useRef"])({ |
|
name: name, |
|
children: children |
|
}); |
|
|
|
if (!ref.current.occurrence) { |
|
ref.current.occurrence = ++occurrences; |
|
} |
|
|
|
Object(external_this_wp_element_["useLayoutEffect"])(function () { |
|
registerFill(name, ref.current); |
|
return function () { |
|
return unregisterFill(name, ref.current); |
|
}; |
|
}, []); |
|
Object(external_this_wp_element_["useLayoutEffect"])(function () { |
|
ref.current.children = children; |
|
|
|
if (slot && !slot.props.bubblesVirtually) { |
|
slot.forceUpdate(); |
|
} |
|
}, [children]); |
|
Object(external_this_wp_element_["useLayoutEffect"])(function () { |
|
if (name === ref.current.name) { |
|
// ignore initial effect |
|
return; |
|
} |
|
|
|
unregisterFill(ref.current.name, ref.current); |
|
ref.current.name = name; |
|
registerFill(name, ref.current); |
|
}, [name]); |
|
|
|
if (!slot || !slot.node || !slot.props.bubblesVirtually) { |
|
return null; |
|
} // If a function is passed as a child, provide it with the fillProps. |
|
|
|
|
|
if (Object(external_lodash_["isFunction"])(children)) { |
|
children = children(slot.props.fillProps); |
|
} |
|
|
|
return Object(external_this_wp_element_["createPortal"])(children, slot.node); |
|
} |
|
|
|
var fill_Fill = function Fill(props) { |
|
return Object(external_this_wp_element_["createElement"])(context_Consumer, null, function (_ref2) { |
|
var registerFill = _ref2.registerFill, |
|
unregisterFill = _ref2.unregisterFill; |
|
return Object(external_this_wp_element_["createElement"])(fill_FillComponent, Object(esm_extends["a" /* default */])({}, props, { |
|
registerFill: registerFill, |
|
unregisterFill: unregisterFill |
|
})); |
|
}); |
|
}; |
|
|
|
/* harmony default export */ var slot_fill_fill = (fill_Fill); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/index.js |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
function createSlotFill(name) { |
|
var FillComponent = function FillComponent(props) { |
|
return Object(external_this_wp_element_["createElement"])(slot_fill_fill, Object(esm_extends["a" /* default */])({ |
|
name: name |
|
}, props)); |
|
}; |
|
|
|
FillComponent.displayName = name + 'Fill'; |
|
|
|
var SlotComponent = function SlotComponent(props) { |
|
return Object(external_this_wp_element_["createElement"])(slot_fill_slot, Object(esm_extends["a" /* default */])({ |
|
name: name |
|
}, props)); |
|
}; |
|
|
|
SlotComponent.displayName = name + 'Slot'; |
|
return { |
|
Fill: FillComponent, |
|
Slot: SlotComponent |
|
}; |
|
} |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/popover/index.js |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var FocusManaged = with_constrained_tabbing(with_focus_return(function (_ref) { |
|
var children = _ref.children; |
|
return children; |
|
})); |
|
/** |
|
* Name of slot in which popover should fill. |
|
* |
|
* @type {string} |
|
*/ |
|
|
|
var SLOT_NAME = 'Popover'; |
|
/** |
|
* Hook used trigger an event handler once the window is resized or scrolled. |
|
* |
|
* @param {Function} handler Event handler. |
|
* @param {Object} ignoredScrollableRef scroll events inside this element are ignored. |
|
*/ |
|
|
|
function useThrottledWindowScrollOrResize(handler, ignoredScrollableRef) { |
|
// Refresh anchor rect on resize |
|
Object(external_this_wp_element_["useEffect"])(function () { |
|
var refreshHandle; |
|
|
|
var throttledRefresh = function throttledRefresh(event) { |
|
window.cancelAnimationFrame(refreshHandle); |
|
|
|
if (ignoredScrollableRef && event && event.type === 'scroll' && ignoredScrollableRef.current.contains(event.target)) { |
|
return; |
|
} |
|
|
|
refreshHandle = window.requestAnimationFrame(handler); |
|
}; |
|
|
|
window.addEventListener('resize', throttledRefresh); |
|
window.addEventListener('scroll', throttledRefresh, true); |
|
return function () { |
|
window.removeEventListener('resize', throttledRefresh); |
|
window.removeEventListener('scroll', throttledRefresh, true); |
|
}; |
|
}, []); |
|
} |
|
/** |
|
* Hook used to compute and update the anchor position properly. |
|
* |
|
* @param {Object} anchorRef reference to the popover anchor element. |
|
* @param {Object} contentRef reference to the popover content element. |
|
* @param {Object} anchorRect anchor Rect prop used to override the computed value. |
|
* @param {Function} getAnchorRect function used to override the anchor value computation algorithm. |
|
* |
|
* @return {Object} Anchor position. |
|
*/ |
|
|
|
|
|
function useAnchor(anchorRef, contentRef, anchorRect, getAnchorRect) { |
|
var _useState = Object(external_this_wp_element_["useState"])(null), |
|
_useState2 = Object(slicedToArray["a" /* default */])(_useState, 2), |
|
anchor = _useState2[0], |
|
setAnchor = _useState2[1]; |
|
|
|
var refreshAnchorRect = function refreshAnchorRect() { |
|
if (!anchorRef.current) { |
|
return; |
|
} |
|
|
|
var newAnchor; |
|
|
|
if (anchorRect) { |
|
newAnchor = anchorRect; |
|
} else if (getAnchorRect) { |
|
newAnchor = getAnchorRect(anchorRef.current); |
|
} else { |
|
var rect = anchorRef.current.parentNode.getBoundingClientRect(); // subtract padding |
|
|
|
var _window$getComputedSt = window.getComputedStyle(anchorRef.current.parentNode), |
|
paddingTop = _window$getComputedSt.paddingTop, |
|
paddingBottom = _window$getComputedSt.paddingBottom; |
|
|
|
var topPad = parseInt(paddingTop, 10); |
|
var bottomPad = parseInt(paddingBottom, 10); |
|
newAnchor = { |
|
x: rect.left, |
|
y: rect.top + topPad, |
|
width: rect.width, |
|
height: rect.height - topPad - bottomPad, |
|
left: rect.left, |
|
right: rect.right, |
|
top: rect.top + topPad, |
|
bottom: rect.bottom - bottomPad |
|
}; |
|
} |
|
|
|
var didAnchorRectChange = !external_this_wp_isShallowEqual_default()(newAnchor, anchor); |
|
|
|
if (didAnchorRectChange) { |
|
setAnchor(newAnchor); |
|
} |
|
}; |
|
|
|
Object(external_this_wp_element_["useEffect"])(refreshAnchorRect, [anchorRect, getAnchorRect]); |
|
Object(external_this_wp_element_["useEffect"])(function () { |
|
if (!anchorRect) { |
|
/* |
|
* There are sometimes we need to reposition or resize the popover that are not |
|
* handled by the resize/scroll window events (i.e. CSS changes in the layout |
|
* that changes the position of the anchor). |
|
* |
|
* For these situations, we refresh the popover every 0.5s |
|
*/ |
|
var intervalHandle = setInterval(refreshAnchorRect, 500); |
|
return function () { |
|
return clearInterval(intervalHandle); |
|
}; |
|
} |
|
}, [anchorRect]); |
|
useThrottledWindowScrollOrResize(refreshAnchorRect, contentRef); |
|
return anchor; |
|
} |
|
/** |
|
* Hook used to compute the initial size of an element. |
|
* The popover applies styling to limit the height of the element, |
|
* we only care about the initial size. |
|
* |
|
* @param {Object} ref Reference to the popover content element. |
|
* |
|
* @return {Object} Content size. |
|
*/ |
|
|
|
|
|
function useInitialContentSize(ref) { |
|
var _useState3 = Object(external_this_wp_element_["useState"])(null), |
|
_useState4 = Object(slicedToArray["a" /* default */])(_useState3, 2), |
|
contentSize = _useState4[0], |
|
setContentSize = _useState4[1]; |
|
|
|
Object(external_this_wp_element_["useEffect"])(function () { |
|
var contentRect = ref.current.getBoundingClientRect(); |
|
setContentSize({ |
|
width: contentRect.width, |
|
height: contentRect.height |
|
}); |
|
}, []); |
|
return contentSize; |
|
} |
|
/** |
|
* Hook used to compute and update the position of the popover |
|
* based on the anchor position and the content size. |
|
* |
|
* @param {Object} anchor Anchor Position. |
|
* @param {Object} contentSize Content Size. |
|
* @param {string} position Position prop. |
|
* @param {boolean} expandOnMobile Whether to show the popover full width on mobile. |
|
* @param {Object} contentRef Reference to the popover content element. |
|
* |
|
* @return {Object} Popover position. |
|
*/ |
|
|
|
|
|
function usePopoverPosition(anchor, contentSize, position, expandOnMobile, contentRef) { |
|
var _useState5 = Object(external_this_wp_element_["useState"])({ |
|
popoverLeft: null, |
|
popoverTop: null, |
|
yAxis: 'top', |
|
xAxis: 'center', |
|
contentHeight: null, |
|
contentWidth: null, |
|
isMobile: false |
|
}), |
|
_useState6 = Object(slicedToArray["a" /* default */])(_useState5, 2), |
|
popoverPosition = _useState6[0], |
|
setPopoverPosition = _useState6[1]; |
|
|
|
var refreshPopoverPosition = function refreshPopoverPosition() { |
|
if (!anchor || !contentSize) { |
|
return; |
|
} |
|
|
|
var newPopoverPosition = computePopoverPosition(anchor, contentSize, position, expandOnMobile); |
|
|
|
if (popoverPosition.yAxis !== newPopoverPosition.yAxis || popoverPosition.xAxis !== newPopoverPosition.xAxis || popoverPosition.popoverLeft !== newPopoverPosition.popoverLeft || popoverPosition.popoverTop !== newPopoverPosition.popoverTop || popoverPosition.contentHeight !== newPopoverPosition.contentHeight || popoverPosition.contentWidth !== newPopoverPosition.contentWidth || popoverPosition.isMobile !== newPopoverPosition.isMobile) { |
|
setPopoverPosition(newPopoverPosition); |
|
} |
|
}; |
|
|
|
Object(external_this_wp_element_["useEffect"])(refreshPopoverPosition, [anchor, contentSize]); |
|
useThrottledWindowScrollOrResize(refreshPopoverPosition, contentRef); |
|
return popoverPosition; |
|
} |
|
/** |
|
* Hook used to focus the first tabbable element on mount. |
|
* |
|
* @param {boolean|string} focusOnMount Focus on mount mode. |
|
* @param {Object} contentRef Reference to the popover content element. |
|
*/ |
|
|
|
|
|
function useFocusContentOnMount(focusOnMount, contentRef) { |
|
// Focus handling |
|
Object(external_this_wp_element_["useEffect"])(function () { |
|
/* |
|
* Without the setTimeout, the dom node is not being focused. Related: |
|
* https://stackoverflow.com/questions/35522220/react-ref-with-focus-doesnt-work-without-settimeout-my-example |
|
* |
|
* TODO: Treat the cause, not the symptom. |
|
*/ |
|
var focusTimeout = setTimeout(function () { |
|
if (!focusOnMount || !contentRef.current) { |
|
return; |
|
} |
|
|
|
if (focusOnMount === 'firstElement') { |
|
// Find first tabbable node within content and shift focus, falling |
|
// back to the popover panel itself. |
|
var firstTabbable = external_this_wp_dom_["focus"].tabbable.find(contentRef.current)[0]; |
|
|
|
if (firstTabbable) { |
|
firstTabbable.focus(); |
|
} else { |
|
contentRef.current.focus(); |
|
} |
|
|
|
return; |
|
} |
|
|
|
if (focusOnMount === 'container') { |
|
// Focus the popover panel itself so items in the popover are easily |
|
// accessed via keyboard navigation. |
|
contentRef.current.focus(); |
|
} |
|
}, 0); |
|
return function () { |
|
return clearTimeout(focusTimeout); |
|
}; |
|
}, []); |
|
} |
|
|
|
var popover_Popover = function Popover(_ref2) { |
|
var headerTitle = _ref2.headerTitle, |
|
onClose = _ref2.onClose, |
|
onKeyDown = _ref2.onKeyDown, |
|
children = _ref2.children, |
|
className = _ref2.className, |
|
_ref2$noArrow = _ref2.noArrow, |
|
noArrow = _ref2$noArrow === void 0 ? false : _ref2$noArrow, |
|
_ref2$position = _ref2.position, |
|
position = _ref2$position === void 0 ? 'top' : _ref2$position, |
|
range = _ref2.range, |
|
_ref2$focusOnMount = _ref2.focusOnMount, |
|
focusOnMount = _ref2$focusOnMount === void 0 ? 'firstElement' : _ref2$focusOnMount, |
|
anchorRect = _ref2.anchorRect, |
|
getAnchorRect = _ref2.getAnchorRect, |
|
expandOnMobile = _ref2.expandOnMobile, |
|
_ref2$animate = _ref2.animate, |
|
animate = _ref2$animate === void 0 ? true : _ref2$animate, |
|
onClickOutside = _ref2.onClickOutside, |
|
onFocusOutside = _ref2.onFocusOutside, |
|
contentProps = Object(objectWithoutProperties["a" /* default */])(_ref2, ["headerTitle", "onClose", "onKeyDown", "children", "className", "noArrow", "position", "range", "focusOnMount", "anchorRect", "getAnchorRect", "expandOnMobile", "animate", "onClickOutside", "onFocusOutside"]); |
|
|
|
var anchorRef = Object(external_this_wp_element_["useRef"])(null); |
|
var contentRef = Object(external_this_wp_element_["useRef"])(null); // Animation |
|
|
|
var _useState7 = Object(external_this_wp_element_["useState"])(false), |
|
_useState8 = Object(slicedToArray["a" /* default */])(_useState7, 2), |
|
isReadyToAnimate = _useState8[0], |
|
setIsReadyToAnimate = _useState8[1]; // Anchor position |
|
|
|
|
|
var anchor = useAnchor(anchorRef, contentRef, anchorRect, getAnchorRect); // Content size |
|
|
|
var contentSize = useInitialContentSize(contentRef); |
|
Object(external_this_wp_element_["useEffect"])(function () { |
|
if (contentSize) { |
|
setIsReadyToAnimate(true); |
|
} |
|
}, [contentSize]); // Compute the position |
|
|
|
var popoverPosition = usePopoverPosition(anchor, contentSize, position, expandOnMobile, contentRef); |
|
useFocusContentOnMount(focusOnMount, contentRef); // Event handlers |
|
|
|
var maybeClose = function maybeClose(event) { |
|
// Close on escape |
|
if (event.keyCode === external_this_wp_keycodes_["ESCAPE"] && onClose) { |
|
event.stopPropagation(); |
|
onClose(); |
|
} // Preserve original content prop behavior |
|
|
|
|
|
if (onKeyDown) { |
|
onKeyDown(event); |
|
} |
|
}; |
|
/** |
|
* Shims an onFocusOutside callback to be compatible with a deprecated |
|
* onClickOutside prop function, if provided. |
|
* |
|
* @param {FocusEvent} event Focus event from onFocusOutside. |
|
*/ |
|
|
|
|
|
function handleOnFocusOutside(event) { |
|
// Defer to given `onFocusOutside` if specified. Call `onClose` only if |
|
// both `onFocusOutside` and `onClickOutside` are unspecified. Doing so |
|
// assures backwards-compatibility for prior `onClickOutside` default. |
|
if (onFocusOutside) { |
|
onFocusOutside(event); |
|
return; |
|
} else if (!onClickOutside) { |
|
if (onClose) { |
|
onClose(); |
|
} |
|
|
|
return; |
|
} // Simulate MouseEvent using FocusEvent#relatedTarget as emulated click |
|
// target. MouseEvent constructor is unsupported in Internet Explorer. |
|
|
|
|
|
var clickEvent; |
|
|
|
try { |
|
clickEvent = new window.MouseEvent('click'); |
|
} catch (error) { |
|
clickEvent = document.createEvent('MouseEvent'); |
|
clickEvent.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null); |
|
} |
|
|
|
Object.defineProperty(clickEvent, 'target', { |
|
get: function get() { |
|
return event.relatedTarget; |
|
} |
|
}); |
|
external_this_wp_deprecated_default()('Popover onClickOutside prop', { |
|
alternative: 'onFocusOutside' |
|
}); |
|
onClickOutside(clickEvent); |
|
} // Compute the animation position |
|
|
|
|
|
var yAxisMapping = { |
|
top: 'bottom', |
|
bottom: 'top' |
|
}; |
|
var xAxisMapping = { |
|
left: 'right', |
|
right: 'left' |
|
}; |
|
var animateYAxis = yAxisMapping[popoverPosition.yAxis] || 'middle'; |
|
var animateXAxis = xAxisMapping[popoverPosition.xAxis] || 'center'; |
|
var classes = classnames_default()('components-popover', className, 'is-' + popoverPosition.yAxis, 'is-' + popoverPosition.xAxis, { |
|
'is-mobile': popoverPosition.isMobile, |
|
'is-without-arrow': noArrow || popoverPosition.xAxis === 'center' && popoverPosition.yAxis === 'middle' |
|
}); // Disable reason: We care to capture the _bubbled_ events from inputs |
|
// within popover as inferring close intent. |
|
|
|
var content = Object(external_this_wp_element_["createElement"])(detect_outside, { |
|
onFocusOutside: handleOnFocusOutside |
|
}, Object(external_this_wp_element_["createElement"])(build_module_animate, { |
|
type: animate && isReadyToAnimate ? 'appear' : null, |
|
options: { |
|
origin: animateYAxis + ' ' + animateXAxis |
|
} |
|
}, function (_ref3) { |
|
var animateClassName = _ref3.className; |
|
return Object(external_this_wp_element_["createElement"])(isolated_event_container, Object(esm_extends["a" /* default */])({ |
|
className: classnames_default()(classes, animateClassName), |
|
style: { |
|
top: !popoverPosition.isMobile && popoverPosition.popoverTop ? popoverPosition.popoverTop + 'px' : undefined, |
|
left: !popoverPosition.isMobile && popoverPosition.popoverLeft ? popoverPosition.popoverLeft + 'px' : undefined, |
|
visibility: contentSize ? undefined : 'hidden' |
|
} |
|
}, contentProps, { |
|
onKeyDown: maybeClose |
|
}), popoverPosition.isMobile && Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-popover__header" |
|
}, Object(external_this_wp_element_["createElement"])("span", { |
|
className: "components-popover__header-title" |
|
}, headerTitle), Object(external_this_wp_element_["createElement"])(icon_button, { |
|
className: "components-popover__close", |
|
icon: "no-alt", |
|
onClick: onClose |
|
})), Object(external_this_wp_element_["createElement"])("div", { |
|
ref: contentRef, |
|
className: "components-popover__content", |
|
style: { |
|
maxHeight: !popoverPosition.isMobile && popoverPosition.contentHeight ? popoverPosition.contentHeight + 'px' : undefined, |
|
maxWidth: !popoverPosition.isMobile && popoverPosition.contentWidth ? popoverPosition.contentWidth + 'px' : undefined |
|
}, |
|
tabIndex: "-1" |
|
}, children)); |
|
})); // Apply focus to element as long as focusOnMount is truthy; false is |
|
// the only "disabled" value. |
|
|
|
if (focusOnMount) { |
|
content = Object(external_this_wp_element_["createElement"])(FocusManaged, null, content); |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])(context_Consumer, null, function (_ref4) { |
|
var getSlot = _ref4.getSlot; |
|
|
|
// In case there is no slot context in which to render, |
|
// default to an in-place rendering. |
|
if (getSlot && getSlot(SLOT_NAME)) { |
|
content = Object(external_this_wp_element_["createElement"])(slot_fill_fill, { |
|
name: SLOT_NAME |
|
}, content); |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])("span", { |
|
ref: anchorRef |
|
}, content, popoverPosition.isMobile && expandOnMobile && Object(external_this_wp_element_["createElement"])(scroll_lock, null)); |
|
}); |
|
}; |
|
|
|
var PopoverContainer = popover_Popover; |
|
|
|
PopoverContainer.Slot = function () { |
|
return Object(external_this_wp_element_["createElement"])(slot_fill_slot, { |
|
bubblesVirtually: true, |
|
name: SLOT_NAME |
|
}); |
|
}; |
|
|
|
/* harmony default export */ var popover = (PopoverContainer); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","a11y"]} |
|
var external_this_wp_a11y_ = __webpack_require__(45); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/higher-order/with-spoken-messages/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
/** |
|
* A Higher Order Component used to be provide a unique instance ID by |
|
* component. |
|
* |
|
* @param {WPElement} WrappedComponent The wrapped component. |
|
* |
|
* @return {Component} Component with an instanceId prop. |
|
*/ |
|
|
|
/* harmony default export */ var with_spoken_messages = (Object(external_this_wp_compose_["createHigherOrderComponent"])(function (WrappedComponent) { |
|
return ( |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(_class, _Component); |
|
|
|
function _class() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, _class); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).apply(this, arguments)); |
|
_this.debouncedSpeak = Object(external_lodash_["debounce"])(_this.speak.bind(Object(assertThisInitialized["a" /* default */])(_this)), 500); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(_class, [{ |
|
key: "speak", |
|
value: function speak(message) { |
|
var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'polite'; |
|
|
|
Object(external_this_wp_a11y_["speak"])(message, type); |
|
} |
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.debouncedSpeak.cancel(); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props, { |
|
speak: this.speak, |
|
debouncedSpeak: this.debouncedSpeak |
|
})); |
|
} |
|
}]); |
|
|
|
return _class; |
|
}(external_this_wp_element_["Component"]) |
|
); |
|
}, 'withSpokenMessages')); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/autocomplete/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
/** |
|
* A raw completer option. |
|
* |
|
* @typedef {*} CompleterOption |
|
*/ |
|
|
|
/** |
|
* @callback FnGetOptions |
|
* |
|
* @return {(CompleterOption[]|Promise.<CompleterOption[]>)} The completer options or a promise for them. |
|
*/ |
|
|
|
/** |
|
* @callback FnGetOptionKeywords |
|
* @param {CompleterOption} option a completer option. |
|
* |
|
* @return {string[]} list of key words to search. |
|
*/ |
|
|
|
/** |
|
* @callback FnIsOptionDisabled |
|
* @param {CompleterOption} option a completer option. |
|
* |
|
* @return {string[]} whether or not the given option is disabled. |
|
*/ |
|
|
|
/** |
|
* @callback FnGetOptionLabel |
|
* @param {CompleterOption} option a completer option. |
|
* |
|
* @return {(string|Array.<(string|Component)>)} list of react components to render. |
|
*/ |
|
|
|
/** |
|
* @callback FnAllowContext |
|
* @param {string} before the string before the auto complete trigger and query. |
|
* @param {string} after the string after the autocomplete trigger and query. |
|
* |
|
* @return {boolean} true if the completer can handle. |
|
*/ |
|
|
|
/** |
|
* @typedef {Object} OptionCompletion |
|
* @property {'insert-at-caret'|'replace'} action the intended placement of the completion. |
|
* @property {OptionCompletionValue} value the completion value. |
|
*/ |
|
|
|
/** |
|
* A completion value. |
|
* |
|
* @typedef {(string|WPElement|Object)} OptionCompletionValue |
|
*/ |
|
|
|
/** |
|
* @callback FnGetOptionCompletion |
|
* @param {CompleterOption} value the value of the completer option. |
|
* @param {string} query the text value of the autocomplete query. |
|
* |
|
* @return {(OptionCompletion|OptionCompletionValue)} the completion for the given option. If an |
|
* OptionCompletionValue is returned, the |
|
* completion action defaults to `insert-at-caret`. |
|
*/ |
|
|
|
/** |
|
* @typedef {Object} Completer |
|
* @property {string} name a way to identify a completer, useful for selective overriding. |
|
* @property {?string} className A class to apply to the popup menu. |
|
* @property {string} triggerPrefix the prefix that will display the menu. |
|
* @property {(CompleterOption[]|FnGetOptions)} options the completer options or a function to get them. |
|
* @property {?FnGetOptionKeywords} getOptionKeywords get the keywords for a given option. |
|
* @property {?FnIsOptionDisabled} isOptionDisabled get whether or not the given option is disabled. |
|
* @property {FnGetOptionLabel} getOptionLabel get the label for a given option. |
|
* @property {?FnAllowContext} allowContext filter the context under which the autocomplete activates. |
|
* @property {FnGetOptionCompletion} getOptionCompletion get the completion associated with a given option. |
|
*/ |
|
|
|
function filterOptions(search) { |
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; |
|
var maxResults = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 10; |
|
var filtered = []; |
|
|
|
for (var i = 0; i < options.length; i++) { |
|
var option = options[i]; // Merge label into keywords |
|
|
|
var _option$keywords = option.keywords, |
|
keywords = _option$keywords === void 0 ? [] : _option$keywords; |
|
|
|
if ('string' === typeof option.label) { |
|
keywords = [].concat(Object(toConsumableArray["a" /* default */])(keywords), [option.label]); |
|
} |
|
|
|
var isMatch = keywords.some(function (keyword) { |
|
return search.test(Object(external_lodash_["deburr"])(keyword)); |
|
}); |
|
|
|
if (!isMatch) { |
|
continue; |
|
} |
|
|
|
filtered.push(option); // Abort early if max reached |
|
|
|
if (filtered.length === maxResults) { |
|
break; |
|
} |
|
} |
|
|
|
return filtered; |
|
} |
|
|
|
function getCaretRect() { |
|
var selection = window.getSelection(); |
|
var range = selection.rangeCount ? selection.getRangeAt(0) : null; |
|
|
|
if (range) { |
|
return Object(external_this_wp_dom_["getRectangleFromRange"])(range); |
|
} |
|
} |
|
|
|
var autocomplete_Autocomplete = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Autocomplete, _Component); |
|
|
|
Object(createClass["a" /* default */])(Autocomplete, null, [{ |
|
key: "getInitialState", |
|
value: function getInitialState() { |
|
return { |
|
search: /./, |
|
selectedIndex: 0, |
|
suppress: undefined, |
|
open: undefined, |
|
query: undefined, |
|
filteredOptions: [] |
|
}; |
|
} |
|
}]); |
|
|
|
function Autocomplete() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Autocomplete); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Autocomplete).apply(this, arguments)); |
|
_this.select = _this.select.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.reset = _this.reset.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.resetWhenSuppressed = _this.resetWhenSuppressed.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleKeyDown = _this.handleKeyDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.debouncedLoadOptions = Object(external_lodash_["debounce"])(_this.loadOptions, 250); |
|
_this.state = _this.constructor.getInitialState(); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(Autocomplete, [{ |
|
key: "insertCompletion", |
|
value: function insertCompletion(replacement) { |
|
var _this$state = this.state, |
|
open = _this$state.open, |
|
query = _this$state.query; |
|
var _this$props = this.props, |
|
record = _this$props.record, |
|
onChange = _this$props.onChange; |
|
var end = record.start; |
|
var start = end - open.triggerPrefix.length - query.length; |
|
var toInsert = Object(external_this_wp_richText_["create"])({ |
|
html: Object(external_this_wp_element_["renderToString"])(replacement) |
|
}); |
|
onChange(Object(external_this_wp_richText_["insert"])(record, toInsert, start, end)); |
|
} |
|
}, { |
|
key: "select", |
|
value: function select(option) { |
|
var onReplace = this.props.onReplace; |
|
var _this$state2 = this.state, |
|
open = _this$state2.open, |
|
query = _this$state2.query; |
|
|
|
var _ref = open || {}, |
|
getOptionCompletion = _ref.getOptionCompletion; |
|
|
|
if (option.isDisabled) { |
|
return; |
|
} |
|
|
|
if (getOptionCompletion) { |
|
var completion = getOptionCompletion(option.value, query); |
|
|
|
var _ref2 = undefined === completion.action || undefined === completion.value ? { |
|
action: 'insert-at-caret', |
|
value: completion |
|
} : completion, |
|
action = _ref2.action, |
|
value = _ref2.value; |
|
|
|
if ('replace' === action) { |
|
onReplace([value]); |
|
} else if ('insert-at-caret' === action) { |
|
this.insertCompletion(value); |
|
} |
|
} // Reset autocomplete state after insertion rather than before |
|
// so insertion events don't cause the completion menu to redisplay. |
|
|
|
|
|
this.reset(); |
|
} |
|
}, { |
|
key: "reset", |
|
value: function reset() { |
|
this.setState(this.constructor.getInitialState()); |
|
} |
|
}, { |
|
key: "resetWhenSuppressed", |
|
value: function resetWhenSuppressed() { |
|
var _this$state3 = this.state, |
|
open = _this$state3.open, |
|
suppress = _this$state3.suppress; |
|
|
|
if (open && suppress === open.idx) { |
|
this.reset(); |
|
} |
|
} |
|
}, { |
|
key: "announce", |
|
value: function announce(filteredOptions) { |
|
var debouncedSpeak = this.props.debouncedSpeak; |
|
|
|
if (!debouncedSpeak) { |
|
return; |
|
} |
|
|
|
if (!!filteredOptions.length) { |
|
debouncedSpeak(Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_n"])('%d result found, use up and down arrow keys to navigate.', '%d results found, use up and down arrow keys to navigate.', filteredOptions.length), filteredOptions.length), 'assertive'); |
|
} else { |
|
debouncedSpeak(Object(external_this_wp_i18n_["__"])('No results.'), 'assertive'); |
|
} |
|
} |
|
/** |
|
* Load options for an autocompleter. |
|
* |
|
* @param {Completer} completer The autocompleter. |
|
* @param {string} query The query, if any. |
|
*/ |
|
|
|
}, { |
|
key: "loadOptions", |
|
value: function loadOptions(completer, query) { |
|
var _this2 = this; |
|
|
|
var options = completer.options; |
|
/* |
|
* We support both synchronous and asynchronous retrieval of completer options |
|
* but internally treat all as async so we maintain a single, consistent code path. |
|
* |
|
* Because networks can be slow, and the internet is wonderfully unpredictable, |
|
* we don't want two promises updating the state at once. This ensures that only |
|
* the most recent promise will act on `optionsData`. This doesn't use the state |
|
* because `setState` is batched, and so there's no guarantee that setting |
|
* `activePromise` in the state would result in it actually being in `this.state` |
|
* before the promise resolves and we check to see if this is the active promise or not. |
|
*/ |
|
|
|
var promise = this.activePromise = Promise.resolve(typeof options === 'function' ? options(query) : options).then(function (optionsData) { |
|
var _this2$setState; |
|
|
|
if (promise !== _this2.activePromise) { |
|
// Another promise has become active since this one was asked to resolve, so do nothing, |
|
// or else we might end triggering a race condition updating the state. |
|
return; |
|
} |
|
|
|
var keyedOptions = optionsData.map(function (optionData, optionIndex) { |
|
return { |
|
key: "".concat(completer.idx, "-").concat(optionIndex), |
|
value: optionData, |
|
label: completer.getOptionLabel(optionData), |
|
keywords: completer.getOptionKeywords ? completer.getOptionKeywords(optionData) : [], |
|
isDisabled: completer.isOptionDisabled ? completer.isOptionDisabled(optionData) : false |
|
}; |
|
}); |
|
var filteredOptions = filterOptions(_this2.state.search, keyedOptions); |
|
var selectedIndex = filteredOptions.length === _this2.state.filteredOptions.length ? _this2.state.selectedIndex : 0; |
|
|
|
_this2.setState((_this2$setState = {}, Object(defineProperty["a" /* default */])(_this2$setState, 'options_' + completer.idx, keyedOptions), Object(defineProperty["a" /* default */])(_this2$setState, "filteredOptions", filteredOptions), Object(defineProperty["a" /* default */])(_this2$setState, "selectedIndex", selectedIndex), _this2$setState)); |
|
|
|
_this2.announce(filteredOptions); |
|
}); |
|
} |
|
}, { |
|
key: "handleKeyDown", |
|
value: function handleKeyDown(event) { |
|
var _this$state4 = this.state, |
|
open = _this$state4.open, |
|
suppress = _this$state4.suppress, |
|
selectedIndex = _this$state4.selectedIndex, |
|
filteredOptions = _this$state4.filteredOptions; |
|
|
|
if (!open) { |
|
return; |
|
} |
|
|
|
if (suppress === open.idx) { |
|
switch (event.keyCode) { |
|
// cancel popup suppression on CTRL+SPACE |
|
case external_this_wp_keycodes_["SPACE"]: |
|
var ctrlKey = event.ctrlKey, |
|
shiftKey = event.shiftKey, |
|
altKey = event.altKey, |
|
metaKey = event.metaKey; |
|
|
|
if (ctrlKey && !(shiftKey || altKey || metaKey)) { |
|
this.setState({ |
|
suppress: undefined |
|
}); |
|
event.preventDefault(); |
|
event.stopPropagation(); |
|
} |
|
|
|
break; |
|
// reset on cursor movement |
|
|
|
case external_this_wp_keycodes_["UP"]: |
|
case external_this_wp_keycodes_["DOWN"]: |
|
case external_this_wp_keycodes_["LEFT"]: |
|
case external_this_wp_keycodes_["RIGHT"]: |
|
this.reset(); |
|
} |
|
|
|
return; |
|
} |
|
|
|
if (filteredOptions.length === 0) { |
|
return; |
|
} |
|
|
|
var nextSelectedIndex; |
|
|
|
switch (event.keyCode) { |
|
case external_this_wp_keycodes_["UP"]: |
|
nextSelectedIndex = (selectedIndex === 0 ? filteredOptions.length : selectedIndex) - 1; |
|
this.setState({ |
|
selectedIndex: nextSelectedIndex |
|
}); |
|
break; |
|
|
|
case external_this_wp_keycodes_["DOWN"]: |
|
nextSelectedIndex = (selectedIndex + 1) % filteredOptions.length; |
|
this.setState({ |
|
selectedIndex: nextSelectedIndex |
|
}); |
|
break; |
|
|
|
case external_this_wp_keycodes_["ESCAPE"]: |
|
this.setState({ |
|
suppress: open.idx |
|
}); |
|
break; |
|
|
|
case external_this_wp_keycodes_["ENTER"]: |
|
this.select(filteredOptions[selectedIndex]); |
|
break; |
|
|
|
case external_this_wp_keycodes_["LEFT"]: |
|
case external_this_wp_keycodes_["RIGHT"]: |
|
this.reset(); |
|
return; |
|
|
|
default: |
|
return; |
|
} // Any handled keycode should prevent original behavior. This relies on |
|
// the early return in the default case. |
|
|
|
|
|
event.preventDefault(); |
|
} |
|
}, { |
|
key: "componentDidUpdate", |
|
value: function componentDidUpdate(prevProps) { |
|
var _this$props2 = this.props, |
|
record = _this$props2.record, |
|
completers = _this$props2.completers; |
|
var prevRecord = prevProps.record; |
|
|
|
if (Object(external_this_wp_richText_["isCollapsed"])(record)) { |
|
var text = Object(external_lodash_["deburr"])(Object(external_this_wp_richText_["getTextContent"])(Object(external_this_wp_richText_["slice"])(record, 0))); |
|
var prevText = Object(external_lodash_["deburr"])(Object(external_this_wp_richText_["getTextContent"])(Object(external_this_wp_richText_["slice"])(prevRecord, 0))); |
|
|
|
if (text !== prevText) { |
|
var textAfterSelection = Object(external_this_wp_richText_["getTextContent"])(Object(external_this_wp_richText_["slice"])(record, undefined, Object(external_this_wp_richText_["getTextContent"])(record).length)); |
|
var allCompleters = Object(external_lodash_["map"])(completers, function (completer, idx) { |
|
return Object(objectSpread["a" /* default */])({}, completer, { |
|
idx: idx |
|
}); |
|
}); |
|
var open = Object(external_lodash_["find"])(allCompleters, function (_ref3) { |
|
var triggerPrefix = _ref3.triggerPrefix, |
|
allowContext = _ref3.allowContext; |
|
var index = text.lastIndexOf(triggerPrefix); |
|
|
|
if (index === -1) { |
|
return false; |
|
} |
|
|
|
if (allowContext && !allowContext(text.slice(0, index), textAfterSelection)) { |
|
return false; |
|
} |
|
|
|
return /^\S*$/.test(text.slice(index + triggerPrefix.length)); |
|
}); |
|
|
|
if (!open) { |
|
this.reset(); |
|
return; |
|
} |
|
|
|
var safeTrigger = Object(external_lodash_["escapeRegExp"])(open.triggerPrefix); |
|
var match = text.match(new RegExp("".concat(safeTrigger, "(\\S*)$"))); |
|
var query = match && match[1]; |
|
var _this$state5 = this.state, |
|
wasOpen = _this$state5.open, |
|
wasSuppress = _this$state5.suppress, |
|
wasQuery = _this$state5.query; |
|
|
|
if (open && (!wasOpen || open.idx !== wasOpen.idx || query !== wasQuery)) { |
|
if (open.isDebounced) { |
|
this.debouncedLoadOptions(open, query); |
|
} else { |
|
this.loadOptions(open, query); |
|
} |
|
} // create a regular expression to filter the options |
|
|
|
|
|
var search = open ? new RegExp('(?:\\b|\\s|^)' + Object(external_lodash_["escapeRegExp"])(query), 'i') : /./; // filter the options we already have |
|
|
|
var filteredOptions = open ? filterOptions(search, this.state['options_' + open.idx]) : []; // check if we should still suppress the popover |
|
|
|
var suppress = open && wasSuppress === open.idx ? wasSuppress : undefined; // update the state |
|
|
|
if (wasOpen || open) { |
|
this.setState({ |
|
selectedIndex: 0, |
|
filteredOptions: filteredOptions, |
|
suppress: suppress, |
|
search: search, |
|
open: open, |
|
query: query |
|
}); |
|
} // announce the count of filtered options but only if they have loaded |
|
|
|
|
|
if (open && this.state['options_' + open.idx]) { |
|
this.announce(filteredOptions); |
|
} |
|
} |
|
} |
|
} |
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.debouncedLoadOptions.cancel(); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this3 = this; |
|
|
|
var _this$props3 = this.props, |
|
children = _this$props3.children, |
|
instanceId = _this$props3.instanceId, |
|
isSelected = _this$props3.isSelected; |
|
var _this$state6 = this.state, |
|
open = _this$state6.open, |
|
suppress = _this$state6.suppress, |
|
selectedIndex = _this$state6.selectedIndex, |
|
filteredOptions = _this$state6.filteredOptions; |
|
|
|
var _ref4 = filteredOptions[selectedIndex] || {}, |
|
_ref4$key = _ref4.key, |
|
selectedKey = _ref4$key === void 0 ? '' : _ref4$key; |
|
|
|
var _ref5 = open || {}, |
|
className = _ref5.className, |
|
idx = _ref5.idx; |
|
|
|
var isExpanded = suppress !== idx && filteredOptions.length > 0; |
|
var listBoxId = isExpanded ? "components-autocomplete-listbox-".concat(instanceId) : null; |
|
var activeId = isExpanded ? "components-autocomplete-item-".concat(instanceId, "-").concat(selectedKey) : null; |
|
return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, children({ |
|
isExpanded: isExpanded, |
|
listBoxId: listBoxId, |
|
activeId: activeId, |
|
onKeyDown: this.handleKeyDown |
|
}), isExpanded && isSelected && Object(external_this_wp_element_["createElement"])(popover, { |
|
focusOnMount: false, |
|
onClose: this.reset, |
|
position: "top right", |
|
className: "components-autocomplete__popover", |
|
getAnchorRect: getCaretRect |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
id: listBoxId, |
|
role: "listbox", |
|
className: "components-autocomplete__results" |
|
}, isExpanded && Object(external_lodash_["map"])(filteredOptions, function (option, index) { |
|
return Object(external_this_wp_element_["createElement"])(build_module_button, { |
|
key: option.key, |
|
id: "components-autocomplete-item-".concat(instanceId, "-").concat(option.key), |
|
role: "option", |
|
"aria-selected": index === selectedIndex, |
|
disabled: option.isDisabled, |
|
className: classnames_default()('components-autocomplete__result', className, { |
|
'is-selected': index === selectedIndex |
|
}), |
|
onClick: function onClick() { |
|
return _this3.select(option); |
|
} |
|
}, option.label); |
|
})))); |
|
} |
|
}]); |
|
|
|
return Autocomplete; |
|
}(external_this_wp_element_["Component"]); |
|
/* harmony default export */ var autocomplete = (Object(external_this_wp_compose_["compose"])([with_spoken_messages, external_this_wp_compose_["withInstanceId"]])(autocomplete_Autocomplete)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/base-control/index.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
function BaseControl(_ref) { |
|
var id = _ref.id, |
|
label = _ref.label, |
|
hideLabelFromVision = _ref.hideLabelFromVision, |
|
help = _ref.help, |
|
className = _ref.className, |
|
children = _ref.children; |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: classnames_default()('components-base-control', className) |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-base-control__field" |
|
}, label && id && Object(external_this_wp_element_["createElement"])("label", { |
|
className: classnames_default()('components-base-control__label', { |
|
'screen-reader-text': hideLabelFromVision |
|
}), |
|
htmlFor: id |
|
}, label), label && !id && Object(external_this_wp_element_["createElement"])(BaseControl.VisualLabel, null, label), children), !!help && Object(external_this_wp_element_["createElement"])("p", { |
|
id: id + '__help', |
|
className: "components-base-control__help" |
|
}, help)); |
|
} |
|
|
|
BaseControl.VisualLabel = function (_ref2) { |
|
var className = _ref2.className, |
|
children = _ref2.children; |
|
className = classnames_default()('components-base-control__label', className); |
|
return Object(external_this_wp_element_["createElement"])("span", { |
|
className: className |
|
}, children); |
|
}; |
|
|
|
/* harmony default export */ var base_control = (BaseControl); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/button-group/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
function ButtonGroup(_ref) { |
|
var className = _ref.className, |
|
props = Object(objectWithoutProperties["a" /* default */])(_ref, ["className"]); |
|
|
|
var classes = classnames_default()('components-button-group', className); |
|
return Object(external_this_wp_element_["createElement"])("div", Object(esm_extends["a" /* default */])({}, props, { |
|
className: classes, |
|
role: "group" |
|
})); |
|
} |
|
|
|
/* harmony default export */ var button_group = (ButtonGroup); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/checkbox-control/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
function CheckboxControl(_ref) { |
|
var label = _ref.label, |
|
className = _ref.className, |
|
heading = _ref.heading, |
|
checked = _ref.checked, |
|
help = _ref.help, |
|
instanceId = _ref.instanceId, |
|
onChange = _ref.onChange, |
|
props = Object(objectWithoutProperties["a" /* default */])(_ref, ["label", "className", "heading", "checked", "help", "instanceId", "onChange"]); |
|
|
|
var id = "inspector-checkbox-control-".concat(instanceId); |
|
|
|
var onChangeValue = function onChangeValue(event) { |
|
return onChange(event.target.checked); |
|
}; |
|
|
|
return Object(external_this_wp_element_["createElement"])(base_control, { |
|
label: heading, |
|
id: id, |
|
help: help, |
|
className: className |
|
}, Object(external_this_wp_element_["createElement"])("span", { |
|
className: "components-checkbox-control__input-container" |
|
}, Object(external_this_wp_element_["createElement"])("input", Object(esm_extends["a" /* default */])({ |
|
id: id, |
|
className: "components-checkbox-control__input", |
|
type: "checkbox", |
|
value: "1", |
|
onChange: onChangeValue, |
|
checked: checked, |
|
"aria-describedby": !!help ? id + '__help' : undefined |
|
}, props)), checked ? Object(external_this_wp_element_["createElement"])(dashicon_Dashicon, { |
|
icon: "yes", |
|
className: "components-checkbox-control__checked", |
|
role: "presentation" |
|
}) : null), Object(external_this_wp_element_["createElement"])("label", { |
|
className: "components-checkbox-control__label", |
|
htmlFor: id |
|
}, label)); |
|
} |
|
|
|
/* harmony default export */ var checkbox_control = (Object(external_this_wp_compose_["withInstanceId"])(CheckboxControl)); |
|
|
|
// EXTERNAL MODULE: ./node_modules/clipboard/dist/clipboard.js |
|
var clipboard = __webpack_require__(224); |
|
var clipboard_default = /*#__PURE__*/__webpack_require__.n(clipboard); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/clipboard-button/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
var clipboard_button_ClipboardButton = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(ClipboardButton, _Component); |
|
|
|
function ClipboardButton() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, ClipboardButton); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(ClipboardButton).apply(this, arguments)); |
|
_this.bindContainer = _this.bindContainer.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onCopy = _this.onCopy.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.getText = _this.getText.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(ClipboardButton, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
var container = this.container, |
|
getText = this.getText, |
|
onCopy = this.onCopy; |
|
var button = container.firstChild; |
|
this.clipboard = new clipboard_default.a(button, { |
|
text: getText, |
|
container: container |
|
}); |
|
this.clipboard.on('success', onCopy); |
|
} |
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.clipboard.destroy(); |
|
delete this.clipboard; |
|
clearTimeout(this.onCopyTimeout); |
|
} |
|
}, { |
|
key: "bindContainer", |
|
value: function bindContainer(container) { |
|
this.container = container; |
|
} |
|
}, { |
|
key: "onCopy", |
|
value: function onCopy(args) { |
|
// Clearing selection will move focus back to the triggering button, |
|
// ensuring that it is not reset to the body, and further that it is |
|
// kept within the rendered node. |
|
args.clearSelection(); |
|
var _this$props = this.props, |
|
onCopy = _this$props.onCopy, |
|
onFinishCopy = _this$props.onFinishCopy; |
|
|
|
if (onCopy) { |
|
onCopy(); // For convenience and consistency, ClipboardButton offers to call |
|
// a secondary callback with delay. This is useful to reset |
|
// consumers' state, e.g. to revert a label from "Copied" to |
|
// "Copy". |
|
|
|
if (onFinishCopy) { |
|
clearTimeout(this.onCopyTimeout); |
|
this.onCopyTimeout = setTimeout(onFinishCopy, 4000); |
|
} |
|
} |
|
} |
|
}, { |
|
key: "getText", |
|
value: function getText() { |
|
var text = this.props.text; |
|
|
|
if ('function' === typeof text) { |
|
text = text(); |
|
} |
|
|
|
return text; |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
// Disable reason: Exclude from spread props passed to Button |
|
// eslint-disable-next-line no-unused-vars |
|
var _this$props2 = this.props, |
|
className = _this$props2.className, |
|
children = _this$props2.children, |
|
onCopy = _this$props2.onCopy, |
|
onFinishCopy = _this$props2.onFinishCopy, |
|
text = _this$props2.text, |
|
buttonProps = Object(objectWithoutProperties["a" /* default */])(_this$props2, ["className", "children", "onCopy", "onFinishCopy", "text"]); |
|
|
|
var icon = buttonProps.icon; |
|
var classes = classnames_default()('components-clipboard-button', className); |
|
var ComponentToUse = icon ? icon_button : build_module_button; // Workaround for inconsistent behavior in Safari, where <textarea> is not |
|
// the document.activeElement at the moment when the copy event fires. |
|
// This causes documentHasSelection() in the copy-handler component to |
|
// mistakenly override the ClipboardButton, and copy a serialized string |
|
// of the current block instead. |
|
|
|
var focusOnCopyEventTarget = function focusOnCopyEventTarget(event) { |
|
event.target.focus(); |
|
}; |
|
|
|
return Object(external_this_wp_element_["createElement"])("span", { |
|
ref: this.bindContainer, |
|
onCopy: focusOnCopyEventTarget |
|
}, Object(external_this_wp_element_["createElement"])(ComponentToUse, Object(esm_extends["a" /* default */])({}, buttonProps, { |
|
className: classes |
|
}), children)); |
|
} |
|
}]); |
|
|
|
return ClipboardButton; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var clipboard_button = (clipboard_button_ClipboardButton); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/color-indicator/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
var color_indicator_ColorIndicator = function ColorIndicator(_ref) { |
|
var className = _ref.className, |
|
colorValue = _ref.colorValue, |
|
props = Object(objectWithoutProperties["a" /* default */])(_ref, ["className", "colorValue"]); |
|
|
|
return Object(external_this_wp_element_["createElement"])("span", Object(esm_extends["a" /* default */])({ |
|
className: classnames_default()('component-color-indicator', className), |
|
style: { |
|
background: colorValue |
|
} |
|
}, props)); |
|
}; |
|
|
|
/* harmony default export */ var color_indicator = (color_indicator_ColorIndicator); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/dropdown/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
var dropdown_Dropdown = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Dropdown, _Component); |
|
|
|
function Dropdown() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Dropdown); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Dropdown).apply(this, arguments)); |
|
_this.toggle = _this.toggle.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.close = _this.close.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.closeIfFocusOutside = _this.closeIfFocusOutside.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.containerRef = Object(external_this_wp_element_["createRef"])(); |
|
_this.state = { |
|
isOpen: false |
|
}; |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(Dropdown, [{ |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
var isOpen = this.state.isOpen; |
|
var onToggle = this.props.onToggle; |
|
|
|
if (isOpen && onToggle) { |
|
onToggle(false); |
|
} |
|
} |
|
}, { |
|
key: "componentDidUpdate", |
|
value: function componentDidUpdate(prevProps, prevState) { |
|
var isOpen = this.state.isOpen; |
|
var onToggle = this.props.onToggle; |
|
|
|
if (prevState.isOpen !== isOpen && onToggle) { |
|
onToggle(isOpen); |
|
} |
|
} |
|
}, { |
|
key: "toggle", |
|
value: function toggle() { |
|
this.setState(function (state) { |
|
return { |
|
isOpen: !state.isOpen |
|
}; |
|
}); |
|
} |
|
/** |
|
* Closes the dropdown if a focus leaves the dropdown wrapper. This is |
|
* intentionally distinct from `onClose` since focus loss from the popover |
|
* is expected to occur when using the Dropdown's toggle button, in which |
|
* case the correct behavior is to keep the dropdown closed. The same applies |
|
* in case when focus is moved to the modal dialog. |
|
*/ |
|
|
|
}, { |
|
key: "closeIfFocusOutside", |
|
value: function closeIfFocusOutside() { |
|
if (!this.containerRef.current.contains(document.activeElement) && !document.activeElement.closest('[role="dialog"]')) { |
|
this.close(); |
|
} |
|
} |
|
}, { |
|
key: "close", |
|
value: function close() { |
|
this.setState({ |
|
isOpen: false |
|
}); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var isOpen = this.state.isOpen; |
|
var _this$props = this.props, |
|
renderContent = _this$props.renderContent, |
|
renderToggle = _this$props.renderToggle, |
|
_this$props$position = _this$props.position, |
|
position = _this$props$position === void 0 ? 'bottom' : _this$props$position, |
|
className = _this$props.className, |
|
contentClassName = _this$props.contentClassName, |
|
expandOnMobile = _this$props.expandOnMobile, |
|
headerTitle = _this$props.headerTitle, |
|
focusOnMount = _this$props.focusOnMount, |
|
popoverProps = _this$props.popoverProps; |
|
var args = { |
|
isOpen: isOpen, |
|
onToggle: this.toggle, |
|
onClose: this.close |
|
}; |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: className, |
|
ref: this.containerRef |
|
}, renderToggle(args), isOpen && Object(external_this_wp_element_["createElement"])(popover, Object(esm_extends["a" /* default */])({ |
|
className: contentClassName, |
|
position: position, |
|
onClose: this.close, |
|
onFocusOutside: this.closeIfFocusOutside, |
|
expandOnMobile: expandOnMobile, |
|
headerTitle: headerTitle, |
|
focusOnMount: focusOnMount |
|
}, popoverProps), renderContent(args))); |
|
} |
|
}]); |
|
|
|
return Dropdown; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var dropdown = (dropdown_Dropdown); |
|
|
|
// EXTERNAL MODULE: ./node_modules/tinycolor2/tinycolor.js |
|
var tinycolor = __webpack_require__(48); |
|
var tinycolor_default = /*#__PURE__*/__webpack_require__.n(tinycolor); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/color-picker/utils.js |
|
/** |
|
* Parts of this source were derived and modified from react-color, |
|
* released under the MIT license. |
|
* |
|
* https://github.com/casesandberg/react-color/ |
|
* |
|
* Copyright (c) 2015 Case Sandberg |
|
* |
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
|
* of this software and associated documentation files (the "Software"), to deal |
|
* in the Software without restriction, including without limitation the rights |
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
* copies of the Software, and to permit persons to whom the Software is |
|
* furnished to do so, subject to the following conditions: |
|
* |
|
* The above copyright notice and this permission notice shall be included in |
|
* all copies or substantial portions of the Software. |
|
* |
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|
* THE SOFTWARE. |
|
*/ |
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Given a hex color, get all other color properties (rgb, alpha, etc). |
|
* |
|
* @param {Object|string} data A hex color string or an object with a hex property |
|
* @param {string} oldHue A reference to the hue of the previous color, otherwise dragging the saturation to zero will reset the current hue to zero as well. See https://github.com/casesandberg/react-color/issues/29#issuecomment-132686909. |
|
* @return {Object} An object of different color representations. |
|
*/ |
|
|
|
function colorToState() { |
|
var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; |
|
var oldHue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; |
|
var color = data.hex ? tinycolor_default()(data.hex) : tinycolor_default()(data); |
|
var hsl = color.toHsl(); |
|
hsl.h = Math.round(hsl.h); |
|
hsl.s = Math.round(hsl.s * 100); |
|
hsl.l = Math.round(hsl.l * 100); |
|
var hsv = color.toHsv(); |
|
hsv.h = Math.round(hsv.h); |
|
hsv.s = Math.round(hsv.s * 100); |
|
hsv.v = Math.round(hsv.v * 100); |
|
var rgb = color.toRgb(); |
|
var hex = color.toHex(); |
|
|
|
if (hsl.s === 0) { |
|
hsl.h = oldHue || 0; |
|
hsv.h = oldHue || 0; |
|
} |
|
|
|
var transparent = hex === '000000' && rgb.a === 0; |
|
return { |
|
color: color, |
|
hex: transparent ? 'transparent' : "#".concat(hex), |
|
hsl: hsl, |
|
hsv: hsv, |
|
oldHue: data.h || oldHue || hsl.h, |
|
rgb: rgb, |
|
source: data.source |
|
}; |
|
} |
|
/** |
|
* Get the top/left offsets of a point in a container, also returns the container width/height. |
|
* |
|
* @param {Event} e Mouse or touch event with a location coordinate. |
|
* @param {HTMLElement} container The container div, returned point is relative to this container. |
|
* @return {Object} An object of the offset positions & container size. |
|
*/ |
|
|
|
function getPointOffset(e, container) { |
|
e.preventDefault(); |
|
|
|
var _container$getBoundin = container.getBoundingClientRect(), |
|
containerLeft = _container$getBoundin.left, |
|
containerTop = _container$getBoundin.top, |
|
width = _container$getBoundin.width, |
|
height = _container$getBoundin.height; |
|
|
|
var x = typeof e.pageX === 'number' ? e.pageX : e.touches[0].pageX; |
|
var y = typeof e.pageY === 'number' ? e.pageY : e.touches[0].pageY; |
|
var left = x - (containerLeft + window.pageXOffset); |
|
var top = y - (containerTop + window.pageYOffset); |
|
|
|
if (left < 0) { |
|
left = 0; |
|
} else if (left > width) { |
|
left = width; |
|
} else if (top < 0) { |
|
top = 0; |
|
} else if (top > height) { |
|
top = height; |
|
} |
|
|
|
return { |
|
top: top, |
|
left: left, |
|
width: width, |
|
height: height |
|
}; |
|
} |
|
/** |
|
* Check if a string is a valid hex color code. |
|
* |
|
* @param {string} hex A possible hex color. |
|
* @return {boolean} True if the color is a valid hex color. |
|
*/ |
|
|
|
|
|
function isValidHex(hex) { |
|
// disable hex4 and hex8 |
|
var lh = String(hex).charAt(0) === '#' ? 1 : 0; |
|
return hex.length !== 4 + lh && hex.length < 7 + lh && tinycolor_default()(hex).isValid(); |
|
} |
|
/** |
|
* Check an object for any valid color properties. |
|
* |
|
* @param {Object} data A possible object representing a color. |
|
* @return {Object|boolean} If a valid representation of color, returns the data object. Otherwise returns false. |
|
*/ |
|
|
|
function simpleCheckForValidColor(data) { |
|
var keysToCheck = ['r', 'g', 'b', 'a', 'h', 's', 'l', 'v']; |
|
var checked = 0; |
|
var passed = 0; |
|
Object(external_lodash_["each"])(keysToCheck, function (letter) { |
|
if (data[letter]) { |
|
checked += 1; |
|
|
|
if (!isNaN(data[letter])) { |
|
passed += 1; |
|
} |
|
} |
|
}); |
|
return checked === passed ? data : false; |
|
} |
|
/** |
|
* Calculate the current alpha based on a mouse or touch event |
|
* |
|
* @param {Event} e A mouse or touch event on the alpha bar. |
|
* @param {Object} props The current component props |
|
* @param {HTMLElement} container The container div for the alpha bar graph. |
|
* @return {Object|null} If the alpha value has changed, returns a new color object. |
|
*/ |
|
|
|
function calculateAlphaChange(e, props, container) { |
|
var _getPointOffset = getPointOffset(e, container), |
|
left = _getPointOffset.left, |
|
width = _getPointOffset.width; |
|
|
|
var a = left < 0 ? 0 : Math.round(left * 100 / width) / 100; |
|
|
|
if (props.hsl.a !== a) { |
|
return { |
|
h: props.hsl.h, |
|
s: props.hsl.s, |
|
l: props.hsl.l, |
|
a: a, |
|
source: 'rgb' |
|
}; |
|
} |
|
|
|
return null; |
|
} |
|
/** |
|
* Calculate the current hue based on a mouse or touch event |
|
* |
|
* @param {Event} e A mouse or touch event on the hue bar. |
|
* @param {Object} props The current component props |
|
* @param {HTMLElement} container The container div for the hue bar graph. |
|
* @return {Object|null} If the hue value has changed, returns a new color object. |
|
*/ |
|
|
|
function calculateHueChange(e, props, container) { |
|
var _getPointOffset2 = getPointOffset(e, container), |
|
left = _getPointOffset2.left, |
|
width = _getPointOffset2.width; |
|
|
|
var percent = left * 100 / width; |
|
var h = left >= width ? 359 : 360 * percent / 100; |
|
|
|
if (props.hsl.h !== h) { |
|
return { |
|
h: h, |
|
s: props.hsl.s, |
|
l: props.hsl.l, |
|
a: props.hsl.a, |
|
source: 'rgb' |
|
}; |
|
} |
|
|
|
return null; |
|
} |
|
/** |
|
* Calculate the current saturation & brightness based on a mouse or touch event |
|
* |
|
* @param {Event} e A mouse or touch event on the saturation graph. |
|
* @param {Object} props The current component props |
|
* @param {HTMLElement} container The container div for the 2D saturation graph. |
|
* @return {Object} Returns a new color object. |
|
*/ |
|
|
|
function calculateSaturationChange(e, props, container) { |
|
var _getPointOffset3 = getPointOffset(e, container), |
|
top = _getPointOffset3.top, |
|
left = _getPointOffset3.left, |
|
width = _getPointOffset3.width, |
|
height = _getPointOffset3.height; |
|
|
|
var saturation = left < 0 ? 0 : left * 100 / width; |
|
var bright = top >= height ? 0 : -(top * 100 / height) + 100; // `v` values less than 1 are considered in the [0,1] range, causing unexpected behavior at the bottom |
|
// of the chart. To fix this, we assume any value less than 1 should be 0 brightness. |
|
|
|
if (bright < 1) { |
|
bright = 0; |
|
} |
|
|
|
return { |
|
h: props.hsl.h, |
|
s: saturation, |
|
v: bright, |
|
a: props.hsl.a, |
|
source: 'rgb' |
|
}; |
|
} |
|
|
|
// EXTERNAL MODULE: ./node_modules/mousetrap/mousetrap.js |
|
var mousetrap = __webpack_require__(225); |
|
var mousetrap_default = /*#__PURE__*/__webpack_require__.n(mousetrap); |
|
|
|
// EXTERNAL MODULE: ./node_modules/mousetrap/plugins/global-bind/mousetrap-global-bind.js |
|
var mousetrap_global_bind = __webpack_require__(236); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/keyboard-shortcuts/platform.js |
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* Return true if platform is MacOS. |
|
* |
|
* @param {Object} _window window object by default; used for DI testing. |
|
* |
|
* @return {boolean} True if MacOS; false otherwise. |
|
*/ |
|
|
|
function isAppleOS() { |
|
var _window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window; |
|
|
|
var platform = _window.navigator.platform; |
|
return platform.indexOf('Mac') !== -1 || Object(external_lodash_["includes"])(['iPad', 'iPhone'], platform); |
|
} |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/keyboard-shortcuts/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
var keyboard_shortcuts_KeyboardShortcuts = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(KeyboardShortcuts, _Component); |
|
|
|
function KeyboardShortcuts() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, KeyboardShortcuts); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(KeyboardShortcuts).apply(this, arguments)); |
|
_this.bindKeyTarget = _this.bindKeyTarget.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(KeyboardShortcuts, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
var _this2 = this; |
|
|
|
var _this$keyTarget = this.keyTarget, |
|
keyTarget = _this$keyTarget === void 0 ? document : _this$keyTarget; |
|
this.mousetrap = new mousetrap_default.a(keyTarget); |
|
Object(external_lodash_["forEach"])(this.props.shortcuts, function (callback, key) { |
|
if (false) { var hasShift, hasAlt, modifiers, keys; } |
|
|
|
var _this2$props = _this2.props, |
|
bindGlobal = _this2$props.bindGlobal, |
|
eventName = _this2$props.eventName; |
|
var bindFn = bindGlobal ? 'bindGlobal' : 'bind'; |
|
|
|
_this2.mousetrap[bindFn](key, callback, eventName); |
|
}); |
|
} |
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.mousetrap.reset(); |
|
} |
|
/** |
|
* When rendering with children, binds the wrapper node on which events |
|
* will be bound. |
|
* |
|
* @param {Element} node Key event target. |
|
*/ |
|
|
|
}, { |
|
key: "bindKeyTarget", |
|
value: function bindKeyTarget(node) { |
|
this.keyTarget = node; |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
// Render as non-visual if there are no children pressed. Keyboard |
|
// events will be bound to the document instead. |
|
var children = this.props.children; |
|
|
|
if (!external_this_wp_element_["Children"].count(children)) { |
|
return null; |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
ref: this.bindKeyTarget |
|
}, children); |
|
} |
|
}]); |
|
|
|
return KeyboardShortcuts; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var keyboard_shortcuts = (keyboard_shortcuts_KeyboardShortcuts); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/color-picker/alpha.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Parts of this source were derived and modified from react-color, |
|
* released under the MIT license. |
|
* |
|
* https://github.com/casesandberg/react-color/ |
|
* |
|
* Copyright (c) 2015 Case Sandberg |
|
* |
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
|
* of this software and associated documentation files (the "Software"), to deal |
|
* in the Software without restriction, including without limitation the rights |
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
* copies of the Software, and to permit persons to whom the Software is |
|
* furnished to do so, subject to the following conditions: |
|
* |
|
* The above copyright notice and this permission notice shall be included in |
|
* all copies or substantial portions of the Software. |
|
* |
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|
* THE SOFTWARE. |
|
*/ |
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
var alpha_Alpha = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Alpha, _Component); |
|
|
|
function Alpha() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Alpha); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Alpha).apply(this, arguments)); |
|
_this.container = Object(external_this_wp_element_["createRef"])(); |
|
_this.increase = _this.increase.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.decrease = _this.decrease.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleChange = _this.handleChange.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleMouseDown = _this.handleMouseDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleMouseUp = _this.handleMouseUp.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(Alpha, [{ |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.unbindEventListeners(); |
|
} |
|
}, { |
|
key: "increase", |
|
value: function increase() { |
|
var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.01; |
|
var _this$props = this.props, |
|
hsl = _this$props.hsl, |
|
_this$props$onChange = _this$props.onChange, |
|
onChange = _this$props$onChange === void 0 ? external_lodash_["noop"] : _this$props$onChange; |
|
amount = parseInt(amount * 100, 10); |
|
var change = { |
|
h: hsl.h, |
|
s: hsl.s, |
|
l: hsl.l, |
|
a: (parseInt(hsl.a * 100, 10) + amount) / 100, |
|
source: 'rgb' |
|
}; |
|
onChange(change); |
|
} |
|
}, { |
|
key: "decrease", |
|
value: function decrease() { |
|
var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.01; |
|
var _this$props2 = this.props, |
|
hsl = _this$props2.hsl, |
|
_this$props2$onChange = _this$props2.onChange, |
|
onChange = _this$props2$onChange === void 0 ? external_lodash_["noop"] : _this$props2$onChange; |
|
var intValue = parseInt(hsl.a * 100, 10) - parseInt(amount * 100, 10); |
|
var change = { |
|
h: hsl.h, |
|
s: hsl.s, |
|
l: hsl.l, |
|
a: hsl.a <= amount ? 0 : intValue / 100, |
|
source: 'rgb' |
|
}; |
|
onChange(change); |
|
} |
|
}, { |
|
key: "handleChange", |
|
value: function handleChange(e) { |
|
var _this$props$onChange2 = this.props.onChange, |
|
onChange = _this$props$onChange2 === void 0 ? external_lodash_["noop"] : _this$props$onChange2; |
|
var change = calculateAlphaChange(e, this.props, this.container.current); |
|
|
|
if (change) { |
|
onChange(change, e); |
|
} |
|
} |
|
}, { |
|
key: "handleMouseDown", |
|
value: function handleMouseDown(e) { |
|
this.handleChange(e); |
|
window.addEventListener('mousemove', this.handleChange); |
|
window.addEventListener('mouseup', this.handleMouseUp); |
|
} |
|
}, { |
|
key: "handleMouseUp", |
|
value: function handleMouseUp() { |
|
this.unbindEventListeners(); |
|
} |
|
}, { |
|
key: "preventKeyEvents", |
|
value: function preventKeyEvents(event) { |
|
if (event.keyCode === external_this_wp_keycodes_["TAB"]) { |
|
return; |
|
} |
|
|
|
event.preventDefault(); |
|
} |
|
}, { |
|
key: "unbindEventListeners", |
|
value: function unbindEventListeners() { |
|
window.removeEventListener('mousemove', this.handleChange); |
|
window.removeEventListener('mouseup', this.handleMouseUp); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this2 = this; |
|
|
|
var rgb = this.props.rgb; |
|
var rgbString = "".concat(rgb.r, ",").concat(rgb.g, ",").concat(rgb.b); |
|
var gradient = { |
|
background: "linear-gradient(to right, rgba(".concat(rgbString, ", 0) 0%, rgba(").concat(rgbString, ", 1) 100%)") |
|
}; |
|
var pointerLocation = { |
|
left: "".concat(rgb.a * 100, "%") |
|
}; |
|
var shortcuts = { |
|
up: function up() { |
|
return _this2.increase(); |
|
}, |
|
right: function right() { |
|
return _this2.increase(); |
|
}, |
|
'shift+up': function shiftUp() { |
|
return _this2.increase(0.1); |
|
}, |
|
'shift+right': function shiftRight() { |
|
return _this2.increase(0.1); |
|
}, |
|
pageup: function pageup() { |
|
return _this2.increase(0.1); |
|
}, |
|
end: function end() { |
|
return _this2.increase(1); |
|
}, |
|
down: function down() { |
|
return _this2.decrease(); |
|
}, |
|
left: function left() { |
|
return _this2.decrease(); |
|
}, |
|
'shift+down': function shiftDown() { |
|
return _this2.decrease(0.1); |
|
}, |
|
'shift+left': function shiftLeft() { |
|
return _this2.decrease(0.1); |
|
}, |
|
pagedown: function pagedown() { |
|
return _this2.decrease(0.1); |
|
}, |
|
home: function home() { |
|
return _this2.decrease(1); |
|
} |
|
}; |
|
return Object(external_this_wp_element_["createElement"])(keyboard_shortcuts, { |
|
shortcuts: shortcuts |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__alpha" |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__alpha-gradient", |
|
style: gradient |
|
}), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__alpha-bar", |
|
ref: this.container, |
|
onMouseDown: this.handleMouseDown, |
|
onTouchMove: this.handleChange, |
|
onTouchStart: this.handleChange |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
tabIndex: "0", |
|
role: "slider", |
|
"aria-valuemax": "1", |
|
"aria-valuemin": "0", |
|
"aria-valuenow": rgb.a, |
|
"aria-orientation": "horizontal", |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Alpha value, from 0 (transparent) to 1 (fully opaque).'), |
|
className: "components-color-picker__alpha-pointer", |
|
style: pointerLocation, |
|
onKeyDown: this.preventKeyEvents |
|
})))); |
|
} |
|
}]); |
|
|
|
return Alpha; |
|
}(external_this_wp_element_["Component"]); |
|
/* harmony default export */ var alpha = (Object(external_this_wp_compose_["pure"])(alpha_Alpha)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/color-picker/hue.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Parts of this source were derived and modified from react-color, |
|
* released under the MIT license. |
|
* |
|
* https://github.com/casesandberg/react-color/ |
|
* |
|
* Copyright (c) 2015 Case Sandberg |
|
* |
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
|
* of this software and associated documentation files (the "Software"), to deal |
|
* in the Software without restriction, including without limitation the rights |
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
* copies of the Software, and to permit persons to whom the Software is |
|
* furnished to do so, subject to the following conditions: |
|
* |
|
* The above copyright notice and this permission notice shall be included in |
|
* all copies or substantial portions of the Software. |
|
* |
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|
* THE SOFTWARE. |
|
*/ |
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
var hue_Hue = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Hue, _Component); |
|
|
|
function Hue() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Hue); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Hue).apply(this, arguments)); |
|
_this.container = Object(external_this_wp_element_["createRef"])(); |
|
_this.increase = _this.increase.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.decrease = _this.decrease.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleChange = _this.handleChange.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleMouseDown = _this.handleMouseDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleMouseUp = _this.handleMouseUp.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(Hue, [{ |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.unbindEventListeners(); |
|
} |
|
}, { |
|
key: "increase", |
|
value: function increase() { |
|
var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; |
|
var _this$props = this.props, |
|
hsl = _this$props.hsl, |
|
_this$props$onChange = _this$props.onChange, |
|
onChange = _this$props$onChange === void 0 ? external_lodash_["noop"] : _this$props$onChange; |
|
var change = { |
|
h: hsl.h + amount >= 359 ? 359 : hsl.h + amount, |
|
s: hsl.s, |
|
l: hsl.l, |
|
a: hsl.a, |
|
source: 'rgb' |
|
}; |
|
onChange(change); |
|
} |
|
}, { |
|
key: "decrease", |
|
value: function decrease() { |
|
var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; |
|
var _this$props2 = this.props, |
|
hsl = _this$props2.hsl, |
|
_this$props2$onChange = _this$props2.onChange, |
|
onChange = _this$props2$onChange === void 0 ? external_lodash_["noop"] : _this$props2$onChange; |
|
var change = { |
|
h: hsl.h <= amount ? 0 : hsl.h - amount, |
|
s: hsl.s, |
|
l: hsl.l, |
|
a: hsl.a, |
|
source: 'rgb' |
|
}; |
|
onChange(change); |
|
} |
|
}, { |
|
key: "handleChange", |
|
value: function handleChange(e) { |
|
var _this$props$onChange2 = this.props.onChange, |
|
onChange = _this$props$onChange2 === void 0 ? external_lodash_["noop"] : _this$props$onChange2; |
|
var change = calculateHueChange(e, this.props, this.container.current); |
|
|
|
if (change) { |
|
onChange(change, e); |
|
} |
|
} |
|
}, { |
|
key: "handleMouseDown", |
|
value: function handleMouseDown(e) { |
|
this.handleChange(e); |
|
window.addEventListener('mousemove', this.handleChange); |
|
window.addEventListener('mouseup', this.handleMouseUp); |
|
} |
|
}, { |
|
key: "handleMouseUp", |
|
value: function handleMouseUp() { |
|
this.unbindEventListeners(); |
|
} |
|
}, { |
|
key: "preventKeyEvents", |
|
value: function preventKeyEvents(event) { |
|
if (event.keyCode === external_this_wp_keycodes_["TAB"]) { |
|
return; |
|
} |
|
|
|
event.preventDefault(); |
|
} |
|
}, { |
|
key: "unbindEventListeners", |
|
value: function unbindEventListeners() { |
|
window.removeEventListener('mousemove', this.handleChange); |
|
window.removeEventListener('mouseup', this.handleMouseUp); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this2 = this; |
|
|
|
var _this$props3 = this.props, |
|
_this$props3$hsl = _this$props3.hsl, |
|
hsl = _this$props3$hsl === void 0 ? {} : _this$props3$hsl, |
|
instanceId = _this$props3.instanceId; |
|
var pointerLocation = { |
|
left: "".concat(hsl.h * 100 / 360, "%") |
|
}; |
|
var shortcuts = { |
|
up: function up() { |
|
return _this2.increase(); |
|
}, |
|
right: function right() { |
|
return _this2.increase(); |
|
}, |
|
'shift+up': function shiftUp() { |
|
return _this2.increase(10); |
|
}, |
|
'shift+right': function shiftRight() { |
|
return _this2.increase(10); |
|
}, |
|
pageup: function pageup() { |
|
return _this2.increase(10); |
|
}, |
|
end: function end() { |
|
return _this2.increase(359); |
|
}, |
|
down: function down() { |
|
return _this2.decrease(); |
|
}, |
|
left: function left() { |
|
return _this2.decrease(); |
|
}, |
|
'shift+down': function shiftDown() { |
|
return _this2.decrease(10); |
|
}, |
|
'shift+left': function shiftLeft() { |
|
return _this2.decrease(10); |
|
}, |
|
pagedown: function pagedown() { |
|
return _this2.decrease(10); |
|
}, |
|
home: function home() { |
|
return _this2.decrease(359); |
|
} |
|
}; |
|
return Object(external_this_wp_element_["createElement"])(keyboard_shortcuts, { |
|
shortcuts: shortcuts |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__hue" |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__hue-gradient" |
|
}), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__hue-bar", |
|
ref: this.container, |
|
onMouseDown: this.handleMouseDown, |
|
onTouchMove: this.handleChange, |
|
onTouchStart: this.handleChange |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
tabIndex: "0", |
|
role: "slider", |
|
"aria-valuemax": "1", |
|
"aria-valuemin": "359", |
|
"aria-valuenow": hsl.h, |
|
"aria-orientation": "horizontal", |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Hue value in degrees, from 0 to 359.'), |
|
"aria-describedby": "components-color-picker__hue-description-".concat(instanceId), |
|
className: "components-color-picker__hue-pointer", |
|
style: pointerLocation, |
|
onKeyDown: this.preventKeyEvents |
|
}), Object(external_this_wp_element_["createElement"])("p", { |
|
className: "components-color-picker__hue-description screen-reader-text", |
|
id: "components-color-picker__hue-description-".concat(instanceId) |
|
}, Object(external_this_wp_i18n_["__"])('Move the arrow left or right to change hue.'))))); |
|
} |
|
}]); |
|
|
|
return Hue; |
|
}(external_this_wp_element_["Component"]); |
|
/* harmony default export */ var hue = (Object(external_this_wp_compose_["compose"])(external_this_wp_compose_["pure"], external_this_wp_compose_["withInstanceId"])(hue_Hue)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/text-control/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
function TextControl(_ref) { |
|
var label = _ref.label, |
|
hideLabelFromVision = _ref.hideLabelFromVision, |
|
value = _ref.value, |
|
help = _ref.help, |
|
className = _ref.className, |
|
instanceId = _ref.instanceId, |
|
onChange = _ref.onChange, |
|
_ref$type = _ref.type, |
|
type = _ref$type === void 0 ? 'text' : _ref$type, |
|
props = Object(objectWithoutProperties["a" /* default */])(_ref, ["label", "hideLabelFromVision", "value", "help", "className", "instanceId", "onChange", "type"]); |
|
|
|
var id = "inspector-text-control-".concat(instanceId); |
|
|
|
var onChangeValue = function onChangeValue(event) { |
|
return onChange(event.target.value); |
|
}; |
|
|
|
return Object(external_this_wp_element_["createElement"])(base_control, { |
|
label: label, |
|
hideLabelFromVision: hideLabelFromVision, |
|
id: id, |
|
help: help, |
|
className: className |
|
}, Object(external_this_wp_element_["createElement"])("input", Object(esm_extends["a" /* default */])({ |
|
className: "components-text-control__input", |
|
type: type, |
|
id: id, |
|
value: value, |
|
onChange: onChangeValue, |
|
"aria-describedby": !!help ? id + '__help' : undefined |
|
}, props))); |
|
} |
|
|
|
/* harmony default export */ var text_control = (Object(external_this_wp_compose_["withInstanceId"])(TextControl)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/color-picker/inputs.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
/* Wrapper for TextControl, only used to handle intermediate state while typing. */ |
|
|
|
var inputs_Input = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Input, _Component); |
|
|
|
function Input() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Input); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Input).apply(this, arguments)); |
|
_this.handleBlur = _this.handleBlur.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleChange = _this.handleChange.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleKeyDown = _this.handleKeyDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(Input, [{ |
|
key: "handleBlur", |
|
value: function handleBlur() { |
|
var _this$props = this.props, |
|
value = _this$props.value, |
|
valueKey = _this$props.valueKey, |
|
onChange = _this$props.onChange, |
|
source = _this$props.source; |
|
onChange({ |
|
source: source, |
|
state: 'commit', |
|
value: value, |
|
valueKey: valueKey |
|
}); |
|
} |
|
}, { |
|
key: "handleChange", |
|
value: function handleChange(value) { |
|
var _this$props2 = this.props, |
|
valueKey = _this$props2.valueKey, |
|
onChange = _this$props2.onChange, |
|
source = _this$props2.source; |
|
|
|
if (value.length > 4 && isValidHex(value)) { |
|
onChange({ |
|
source: source, |
|
state: 'commit', |
|
value: value, |
|
valueKey: valueKey |
|
}); |
|
} else { |
|
onChange({ |
|
source: source, |
|
state: 'draft', |
|
value: value, |
|
valueKey: valueKey |
|
}); |
|
} |
|
} |
|
}, { |
|
key: "handleKeyDown", |
|
value: function handleKeyDown(_ref) { |
|
var keyCode = _ref.keyCode; |
|
|
|
if (keyCode !== external_this_wp_keycodes_["ENTER"] && keyCode !== external_this_wp_keycodes_["UP"] && keyCode !== external_this_wp_keycodes_["DOWN"]) { |
|
return; |
|
} |
|
|
|
var _this$props3 = this.props, |
|
value = _this$props3.value, |
|
valueKey = _this$props3.valueKey, |
|
onChange = _this$props3.onChange, |
|
source = _this$props3.source; |
|
onChange({ |
|
source: source, |
|
state: 'commit', |
|
value: value, |
|
valueKey: valueKey |
|
}); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this2 = this; |
|
|
|
var _this$props4 = this.props, |
|
label = _this$props4.label, |
|
value = _this$props4.value, |
|
props = Object(objectWithoutProperties["a" /* default */])(_this$props4, ["label", "value"]); |
|
|
|
return Object(external_this_wp_element_["createElement"])(text_control, Object(esm_extends["a" /* default */])({ |
|
className: "components-color-picker__inputs-field", |
|
label: label, |
|
value: value, |
|
onChange: function onChange(newValue) { |
|
return _this2.handleChange(newValue); |
|
}, |
|
onBlur: this.handleBlur, |
|
onKeyDown: this.handleKeyDown |
|
}, Object(external_lodash_["omit"])(props, ['onChange', 'valueKey', 'source']))); |
|
} |
|
}]); |
|
|
|
return Input; |
|
}(external_this_wp_element_["Component"]); |
|
var PureIconButton = Object(external_this_wp_compose_["pure"])(icon_button); |
|
var inputs_Inputs = |
|
/*#__PURE__*/ |
|
function (_Component2) { |
|
Object(inherits["a" /* default */])(Inputs, _Component2); |
|
|
|
function Inputs(_ref2) { |
|
var _this3; |
|
|
|
var hsl = _ref2.hsl; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Inputs); |
|
|
|
_this3 = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Inputs).apply(this, arguments)); |
|
var view = hsl.a === 1 ? 'hex' : 'rgb'; |
|
_this3.state = { |
|
view: view |
|
}; |
|
_this3.toggleViews = _this3.toggleViews.bind(Object(assertThisInitialized["a" /* default */])(_this3)); |
|
_this3.resetDraftValues = _this3.resetDraftValues.bind(Object(assertThisInitialized["a" /* default */])(_this3)); |
|
_this3.handleChange = _this3.handleChange.bind(Object(assertThisInitialized["a" /* default */])(_this3)); |
|
_this3.normalizeValue = _this3.normalizeValue.bind(Object(assertThisInitialized["a" /* default */])(_this3)); |
|
return _this3; |
|
} |
|
|
|
Object(createClass["a" /* default */])(Inputs, [{ |
|
key: "toggleViews", |
|
value: function toggleViews() { |
|
if (this.state.view === 'hex') { |
|
this.setState({ |
|
view: 'rgb' |
|
}, this.resetDraftValues); |
|
Object(external_this_wp_a11y_["speak"])(Object(external_this_wp_i18n_["__"])('RGB mode active')); |
|
} else if (this.state.view === 'rgb') { |
|
this.setState({ |
|
view: 'hsl' |
|
}, this.resetDraftValues); |
|
Object(external_this_wp_a11y_["speak"])(Object(external_this_wp_i18n_["__"])('Hue/saturation/lightness mode active')); |
|
} else if (this.state.view === 'hsl') { |
|
if (this.props.hsl.a === 1) { |
|
this.setState({ |
|
view: 'hex' |
|
}, this.resetDraftValues); |
|
Object(external_this_wp_a11y_["speak"])(Object(external_this_wp_i18n_["__"])('Hex color mode active')); |
|
} else { |
|
this.setState({ |
|
view: 'rgb' |
|
}, this.resetDraftValues); |
|
Object(external_this_wp_a11y_["speak"])(Object(external_this_wp_i18n_["__"])('RGB mode active')); |
|
} |
|
} |
|
} |
|
}, { |
|
key: "resetDraftValues", |
|
value: function resetDraftValues() { |
|
return this.props.onChange({ |
|
state: 'reset' |
|
}); |
|
} |
|
}, { |
|
key: "normalizeValue", |
|
value: function normalizeValue(valueKey, value) { |
|
if (valueKey !== 'a') { |
|
return value; |
|
} |
|
|
|
if (value > 0) { |
|
return 0; |
|
} else if (value > 1) { |
|
return 1; |
|
} |
|
|
|
return Math.round(value * 100) / 100; |
|
} |
|
}, { |
|
key: "handleChange", |
|
value: function handleChange(_ref3) { |
|
var source = _ref3.source, |
|
state = _ref3.state, |
|
value = _ref3.value, |
|
valueKey = _ref3.valueKey; |
|
this.props.onChange({ |
|
source: source, |
|
state: state, |
|
valueKey: valueKey, |
|
value: this.normalizeValue(valueKey, value) |
|
}); |
|
} |
|
}, { |
|
key: "renderFields", |
|
value: function renderFields() { |
|
var _this$props$disableAl = this.props.disableAlpha, |
|
disableAlpha = _this$props$disableAl === void 0 ? false : _this$props$disableAl; |
|
|
|
if (this.state.view === 'hex') { |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__inputs-fields" |
|
}, Object(external_this_wp_element_["createElement"])(inputs_Input, { |
|
source: this.state.view, |
|
label: Object(external_this_wp_i18n_["__"])('Color value in hexadecimal'), |
|
valueKey: "hex", |
|
value: this.props.hex, |
|
onChange: this.handleChange |
|
})); |
|
} else if (this.state.view === 'rgb') { |
|
return Object(external_this_wp_element_["createElement"])("fieldset", null, Object(external_this_wp_element_["createElement"])("legend", { |
|
className: "screen-reader-text" |
|
}, Object(external_this_wp_i18n_["__"])('Color value in RGB')), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__inputs-fields" |
|
}, Object(external_this_wp_element_["createElement"])(inputs_Input, { |
|
source: this.state.view, |
|
label: "r", |
|
valueKey: "r", |
|
value: this.props.rgb.r, |
|
onChange: this.handleChange, |
|
type: "number", |
|
min: "0", |
|
max: "255" |
|
}), Object(external_this_wp_element_["createElement"])(inputs_Input, { |
|
source: this.state.view, |
|
label: "g", |
|
valueKey: "g", |
|
value: this.props.rgb.g, |
|
onChange: this.handleChange, |
|
type: "number", |
|
min: "0", |
|
max: "255" |
|
}), Object(external_this_wp_element_["createElement"])(inputs_Input, { |
|
source: this.state.view, |
|
label: "b", |
|
valueKey: "b", |
|
value: this.props.rgb.b, |
|
onChange: this.handleChange, |
|
type: "number", |
|
min: "0", |
|
max: "255" |
|
}), disableAlpha ? null : Object(external_this_wp_element_["createElement"])(inputs_Input, { |
|
source: this.state.view, |
|
label: "a", |
|
valueKey: "a", |
|
value: this.props.rgb.a, |
|
onChange: this.handleChange, |
|
type: "number", |
|
min: "0", |
|
max: "1", |
|
step: "0.05" |
|
}))); |
|
} else if (this.state.view === 'hsl') { |
|
return Object(external_this_wp_element_["createElement"])("fieldset", null, Object(external_this_wp_element_["createElement"])("legend", { |
|
className: "screen-reader-text" |
|
}, Object(external_this_wp_i18n_["__"])('Color value in HSL')), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__inputs-fields" |
|
}, Object(external_this_wp_element_["createElement"])(inputs_Input, { |
|
source: this.state.view, |
|
label: "h", |
|
valueKey: "h", |
|
value: this.props.hsl.h, |
|
onChange: this.handleChange, |
|
type: "number", |
|
min: "0", |
|
max: "359" |
|
}), Object(external_this_wp_element_["createElement"])(inputs_Input, { |
|
source: this.state.view, |
|
label: "s", |
|
valueKey: "s", |
|
value: this.props.hsl.s, |
|
onChange: this.handleChange, |
|
type: "number", |
|
min: "0", |
|
max: "100" |
|
}), Object(external_this_wp_element_["createElement"])(inputs_Input, { |
|
source: this.state.view, |
|
label: "l", |
|
valueKey: "l", |
|
value: this.props.hsl.l, |
|
onChange: this.handleChange, |
|
type: "number", |
|
min: "0", |
|
max: "100" |
|
}), disableAlpha ? null : Object(external_this_wp_element_["createElement"])(inputs_Input, { |
|
source: this.state.view, |
|
label: "a", |
|
valueKey: "a", |
|
value: this.props.hsl.a, |
|
onChange: this.handleChange, |
|
type: "number", |
|
min: "0", |
|
max: "1", |
|
step: "0.05" |
|
}))); |
|
} |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__inputs-wrapper" |
|
}, this.renderFields(), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__inputs-toggle" |
|
}, Object(external_this_wp_element_["createElement"])(PureIconButton, { |
|
icon: "arrow-down-alt2", |
|
label: Object(external_this_wp_i18n_["__"])('Change color format'), |
|
onClick: this.toggleViews |
|
}))); |
|
} |
|
}], [{ |
|
key: "getDerivedStateFromProps", |
|
value: function getDerivedStateFromProps(props, state) { |
|
if (props.hsl.a !== 1 && state.view === 'hex') { |
|
return { |
|
view: 'rgb' |
|
}; |
|
} |
|
|
|
return null; |
|
} |
|
}]); |
|
|
|
return Inputs; |
|
}(external_this_wp_element_["Component"]); |
|
/* harmony default export */ var inputs = (inputs_Inputs); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/color-picker/saturation.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Parts of this source were derived and modified from react-color, |
|
* released under the MIT license. |
|
* |
|
* https://github.com/casesandberg/react-color/ |
|
* |
|
* Copyright (c) 2015 Case Sandberg |
|
* |
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
|
* of this software and associated documentation files (the "Software"), to deal |
|
* in the Software without restriction, including without limitation the rights |
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
* copies of the Software, and to permit persons to whom the Software is |
|
* furnished to do so, subject to the following conditions: |
|
* |
|
* The above copyright notice and this permission notice shall be included in |
|
* all copies or substantial portions of the Software. |
|
* |
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|
* THE SOFTWARE. |
|
*/ |
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
var saturation_Saturation = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Saturation, _Component); |
|
|
|
function Saturation(props) { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Saturation); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Saturation).call(this, props)); |
|
_this.throttle = Object(external_lodash_["throttle"])(function (fn, data, e) { |
|
fn(data, e); |
|
}, 50); |
|
_this.container = Object(external_this_wp_element_["createRef"])(); |
|
_this.saturate = _this.saturate.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.brighten = _this.brighten.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleChange = _this.handleChange.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleMouseDown = _this.handleMouseDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleMouseUp = _this.handleMouseUp.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(Saturation, [{ |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.throttle.cancel(); |
|
this.unbindEventListeners(); |
|
} |
|
}, { |
|
key: "saturate", |
|
value: function saturate() { |
|
var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.01; |
|
var _this$props = this.props, |
|
hsv = _this$props.hsv, |
|
_this$props$onChange = _this$props.onChange, |
|
onChange = _this$props$onChange === void 0 ? external_lodash_["noop"] : _this$props$onChange; |
|
var intSaturation = Object(external_lodash_["clamp"])(hsv.s + Math.round(amount * 100), 0, 100); |
|
var change = { |
|
h: hsv.h, |
|
s: intSaturation, |
|
v: hsv.v, |
|
a: hsv.a, |
|
source: 'rgb' |
|
}; |
|
onChange(change); |
|
} |
|
}, { |
|
key: "brighten", |
|
value: function brighten() { |
|
var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.01; |
|
var _this$props2 = this.props, |
|
hsv = _this$props2.hsv, |
|
_this$props2$onChange = _this$props2.onChange, |
|
onChange = _this$props2$onChange === void 0 ? external_lodash_["noop"] : _this$props2$onChange; |
|
var intValue = Object(external_lodash_["clamp"])(hsv.v + Math.round(amount * 100), 0, 100); |
|
var change = { |
|
h: hsv.h, |
|
s: hsv.s, |
|
v: intValue, |
|
a: hsv.a, |
|
source: 'rgb' |
|
}; |
|
onChange(change); |
|
} |
|
}, { |
|
key: "handleChange", |
|
value: function handleChange(e) { |
|
var _this$props$onChange2 = this.props.onChange, |
|
onChange = _this$props$onChange2 === void 0 ? external_lodash_["noop"] : _this$props$onChange2; |
|
var change = calculateSaturationChange(e, this.props, this.container.current); |
|
this.throttle(onChange, change, e); |
|
} |
|
}, { |
|
key: "handleMouseDown", |
|
value: function handleMouseDown(e) { |
|
this.handleChange(e); |
|
window.addEventListener('mousemove', this.handleChange); |
|
window.addEventListener('mouseup', this.handleMouseUp); |
|
} |
|
}, { |
|
key: "handleMouseUp", |
|
value: function handleMouseUp() { |
|
this.unbindEventListeners(); |
|
} |
|
}, { |
|
key: "preventKeyEvents", |
|
value: function preventKeyEvents(event) { |
|
if (event.keyCode === external_this_wp_keycodes_["TAB"]) { |
|
return; |
|
} |
|
|
|
event.preventDefault(); |
|
} |
|
}, { |
|
key: "unbindEventListeners", |
|
value: function unbindEventListeners() { |
|
window.removeEventListener('mousemove', this.handleChange); |
|
window.removeEventListener('mouseup', this.handleMouseUp); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this2 = this; |
|
|
|
var _this$props3 = this.props, |
|
hsv = _this$props3.hsv, |
|
hsl = _this$props3.hsl, |
|
instanceId = _this$props3.instanceId; |
|
var pointerLocation = { |
|
top: "".concat(-hsv.v + 100, "%"), |
|
left: "".concat(hsv.s, "%") |
|
}; |
|
var shortcuts = { |
|
up: function up() { |
|
return _this2.brighten(); |
|
}, |
|
'shift+up': function shiftUp() { |
|
return _this2.brighten(0.1); |
|
}, |
|
pageup: function pageup() { |
|
return _this2.brighten(1); |
|
}, |
|
down: function down() { |
|
return _this2.brighten(-0.01); |
|
}, |
|
'shift+down': function shiftDown() { |
|
return _this2.brighten(-0.1); |
|
}, |
|
pagedown: function pagedown() { |
|
return _this2.brighten(-1); |
|
}, |
|
right: function right() { |
|
return _this2.saturate(); |
|
}, |
|
'shift+right': function shiftRight() { |
|
return _this2.saturate(0.1); |
|
}, |
|
end: function end() { |
|
return _this2.saturate(1); |
|
}, |
|
left: function left() { |
|
return _this2.saturate(-0.01); |
|
}, |
|
'shift+left': function shiftLeft() { |
|
return _this2.saturate(-0.1); |
|
}, |
|
home: function home() { |
|
return _this2.saturate(-1); |
|
} |
|
}; |
|
/* eslint-disable jsx-a11y/no-noninteractive-element-interactions */ |
|
|
|
return Object(external_this_wp_element_["createElement"])(keyboard_shortcuts, { |
|
shortcuts: shortcuts |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
style: { |
|
background: "hsl(".concat(hsl.h, ",100%, 50%)") |
|
}, |
|
className: "components-color-picker__saturation-color", |
|
ref: this.container, |
|
onMouseDown: this.handleMouseDown, |
|
onTouchMove: this.handleChange, |
|
onTouchStart: this.handleChange, |
|
role: "application" |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__saturation-white" |
|
}), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__saturation-black" |
|
}), Object(external_this_wp_element_["createElement"])("button", { |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Choose a shade'), |
|
"aria-describedby": "color-picker-saturation-".concat(instanceId), |
|
className: "components-color-picker__saturation-pointer", |
|
style: pointerLocation, |
|
onKeyDown: this.preventKeyEvents |
|
}), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "screen-reader-text", |
|
id: "color-picker-saturation-".concat(instanceId) |
|
}, Object(external_this_wp_i18n_["__"])('Use your arrow keys to change the base color. Move up to lighten the color, down to darken, left to decrease saturation, and right to increase saturation.')))); |
|
/* eslint-enable jsx-a11y/no-noninteractive-element-interactions */ |
|
} |
|
}]); |
|
|
|
return Saturation; |
|
}(external_this_wp_element_["Component"]); |
|
/* harmony default export */ var saturation = (Object(external_this_wp_compose_["compose"])(external_this_wp_compose_["pure"], external_this_wp_compose_["withInstanceId"])(saturation_Saturation)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/color-picker/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Parts of this source were derived and modified from react-color, |
|
* released under the MIT license. |
|
* |
|
* https://github.com/casesandberg/react-color/ |
|
* |
|
* Copyright (c) 2015 Case Sandberg |
|
* |
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
|
* of this software and associated documentation files (the "Software"), to deal |
|
* in the Software without restriction, including without limitation the rights |
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
* copies of the Software, and to permit persons to whom the Software is |
|
* furnished to do so, subject to the following conditions: |
|
* |
|
* The above copyright notice and this permission notice shall be included in |
|
* all copies or substantial portions of the Software. |
|
* |
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|
* THE SOFTWARE. |
|
*/ |
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var toLowerCase = function toLowerCase(value) { |
|
return String(value).toLowerCase(); |
|
}; |
|
|
|
var isValueEmpty = function isValueEmpty(data) { |
|
if (data.source === 'hex' && !data.hex) { |
|
return true; |
|
} else if (data.source === 'hsl' && (!data.h || !data.s || !data.l)) { |
|
return true; |
|
} else if (data.source === 'rgb' && (!data.r || !data.g || !data.b) && (!data.h || !data.s || !data.v || !data.a) && (!data.h || !data.s || !data.l || !data.a)) { |
|
return true; |
|
} |
|
|
|
return false; |
|
}; |
|
|
|
var color_picker_isValidColor = function isValidColor(colors) { |
|
return colors.hex ? isValidHex(colors.hex) : simpleCheckForValidColor(colors); |
|
}; |
|
/** |
|
* Function that creates the new color object |
|
* from old data and the new value. |
|
* |
|
* @param {Object} oldColors The old color object. |
|
* @param {string} oldColors.hex |
|
* @param {Object} oldColors.rgb |
|
* @param {number} oldColors.rgb.r |
|
* @param {number} oldColors.rgb.g |
|
* @param {number} oldColors.rgb.b |
|
* @param {number} oldColors.rgb.a |
|
* @param {Object} oldColors.hsl |
|
* @param {number} oldColors.hsl.h |
|
* @param {number} oldColors.hsl.s |
|
* @param {number} oldColors.hsl.l |
|
* @param {number} oldColors.hsl.a |
|
* @param {string} oldColors.draftHex Same format as oldColors.hex |
|
* @param {Object} oldColors.draftRgb Same format as oldColors.rgb |
|
* @param {Object} oldColors.draftHsl Same format as oldColors.hsl |
|
* @param {Object} data Data containing the new value to update. |
|
* @param {Object} data.source One of `hex`, `rgb`, `hsl`. |
|
* @param {string|number} data.value Value to update. |
|
* @param {string} data.valueKey Depends on `data.source` values: |
|
* - when source = `rgb`, valuKey can be `r`, `g`, `b`, or `a`. |
|
* - when source = `hsl`, valuKey can be `h`, `s`, `l`, or `a`. |
|
* @return {Object} A new color object for a specific source. For example: |
|
* { source: 'rgb', r: 1, g: 2, b:3, a:0 } |
|
*/ |
|
|
|
|
|
var color_picker_dataToColors = function dataToColors(oldColors, _ref) { |
|
var source = _ref.source, |
|
valueKey = _ref.valueKey, |
|
value = _ref.value; |
|
|
|
if (source === 'hex') { |
|
return Object(defineProperty["a" /* default */])({ |
|
source: source |
|
}, source, value); |
|
} |
|
|
|
return Object(objectSpread["a" /* default */])({ |
|
source: source |
|
}, Object(objectSpread["a" /* default */])({}, oldColors[source], Object(defineProperty["a" /* default */])({}, valueKey, value))); |
|
}; |
|
|
|
var color_picker_ColorPicker = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(ColorPicker, _Component); |
|
|
|
function ColorPicker(_ref3) { |
|
var _this; |
|
|
|
var _ref3$color = _ref3.color, |
|
color = _ref3$color === void 0 ? '0071a1' : _ref3$color; |
|
|
|
Object(classCallCheck["a" /* default */])(this, ColorPicker); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(ColorPicker).apply(this, arguments)); |
|
var colors = colorToState(color); |
|
_this.state = Object(objectSpread["a" /* default */])({}, colors, { |
|
draftHex: toLowerCase(colors.hex), |
|
draftRgb: colors.rgb, |
|
draftHsl: colors.hsl |
|
}); |
|
_this.commitValues = _this.commitValues.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.setDraftValues = _this.setDraftValues.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.resetDraftValues = _this.resetDraftValues.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleInputChange = _this.handleInputChange.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(ColorPicker, [{ |
|
key: "commitValues", |
|
value: function commitValues(data) { |
|
var _this$props = this.props, |
|
oldHue = _this$props.oldHue, |
|
_this$props$onChangeC = _this$props.onChangeComplete, |
|
onChangeComplete = _this$props$onChangeC === void 0 ? external_lodash_["noop"] : _this$props$onChangeC; |
|
|
|
if (color_picker_isValidColor(data)) { |
|
var colors = colorToState(data, data.h || oldHue); |
|
this.setState(Object(objectSpread["a" /* default */])({}, colors, { |
|
draftHex: toLowerCase(colors.hex), |
|
draftHsl: colors.hsl, |
|
draftRgb: colors.rgb |
|
}), Object(external_lodash_["debounce"])(Object(external_lodash_["partial"])(onChangeComplete, colors), 100)); |
|
} |
|
} |
|
}, { |
|
key: "resetDraftValues", |
|
value: function resetDraftValues() { |
|
this.setState({ |
|
draftHex: this.state.hex, |
|
draftHsl: this.state.hsl, |
|
draftRgb: this.state.rgb |
|
}); |
|
} |
|
}, { |
|
key: "setDraftValues", |
|
value: function setDraftValues(data) { |
|
switch (data.source) { |
|
case 'hex': |
|
this.setState({ |
|
draftHex: toLowerCase(data.hex) |
|
}); |
|
break; |
|
|
|
case 'rgb': |
|
this.setState({ |
|
draftRgb: data |
|
}); |
|
break; |
|
|
|
case 'hsl': |
|
this.setState({ |
|
draftHsl: data |
|
}); |
|
break; |
|
} |
|
} |
|
}, { |
|
key: "handleInputChange", |
|
value: function handleInputChange(data) { |
|
switch (data.state) { |
|
case 'reset': |
|
this.resetDraftValues(); |
|
break; |
|
|
|
case 'commit': |
|
var colors = color_picker_dataToColors(this.state, data); |
|
|
|
if (!isValueEmpty(colors)) { |
|
this.commitValues(colors); |
|
} |
|
|
|
break; |
|
|
|
case 'draft': |
|
this.setDraftValues(color_picker_dataToColors(this.state, data)); |
|
break; |
|
} |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props2 = this.props, |
|
className = _this$props2.className, |
|
disableAlpha = _this$props2.disableAlpha; |
|
var _this$state = this.state, |
|
color = _this$state.color, |
|
hsl = _this$state.hsl, |
|
hsv = _this$state.hsv, |
|
rgb = _this$state.rgb, |
|
draftHex = _this$state.draftHex, |
|
draftHsl = _this$state.draftHsl, |
|
draftRgb = _this$state.draftRgb; |
|
var classes = classnames_default()(className, { |
|
'components-color-picker': true, |
|
'is-alpha-disabled': disableAlpha, |
|
'is-alpha-enabled': !disableAlpha |
|
}); |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: classes |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__saturation" |
|
}, Object(external_this_wp_element_["createElement"])(saturation, { |
|
hsl: hsl, |
|
hsv: hsv, |
|
onChange: this.commitValues |
|
})), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__body" |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__controls" |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__swatch" |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__active", |
|
style: { |
|
backgroundColor: color && color.toRgbString() |
|
} |
|
})), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-picker__toggles" |
|
}, Object(external_this_wp_element_["createElement"])(hue, { |
|
hsl: hsl, |
|
onChange: this.commitValues |
|
}), disableAlpha ? null : Object(external_this_wp_element_["createElement"])(alpha, { |
|
rgb: rgb, |
|
hsl: hsl, |
|
onChange: this.commitValues |
|
}))), Object(external_this_wp_element_["createElement"])(inputs, { |
|
rgb: draftRgb, |
|
hsl: draftHsl, |
|
hex: draftHex, |
|
onChange: this.handleInputChange, |
|
disableAlpha: disableAlpha |
|
}))); |
|
} |
|
}]); |
|
|
|
return ColorPicker; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/color-palette/index.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
function ColorPalette(_ref) { |
|
var colors = _ref.colors, |
|
_ref$disableCustomCol = _ref.disableCustomColors, |
|
disableCustomColors = _ref$disableCustomCol === void 0 ? false : _ref$disableCustomCol, |
|
value = _ref.value, |
|
onChange = _ref.onChange, |
|
className = _ref.className, |
|
_ref$clearable = _ref.clearable, |
|
clearable = _ref$clearable === void 0 ? true : _ref$clearable; |
|
|
|
function applyOrUnset(color) { |
|
return function () { |
|
return onChange(value === color ? undefined : color); |
|
}; |
|
} |
|
|
|
var customColorPickerLabel = Object(external_this_wp_i18n_["__"])('Custom color picker'); |
|
|
|
var classes = classnames_default()('components-color-palette', className); |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: classes |
|
}, Object(external_lodash_["map"])(colors, function (_ref2) { |
|
var color = _ref2.color, |
|
name = _ref2.name; |
|
var style = { |
|
color: color |
|
}; |
|
var itemClasses = classnames_default()('components-color-palette__item', { |
|
'is-active': value === color |
|
}); |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
key: color, |
|
className: "components-color-palette__item-wrapper" |
|
}, Object(external_this_wp_element_["createElement"])(build_module_tooltip, { |
|
text: name || // translators: %s: color hex code e.g: "#f00". |
|
Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["__"])('Color code: %s'), color) |
|
}, Object(external_this_wp_element_["createElement"])("button", { |
|
type: "button", |
|
className: itemClasses, |
|
style: style, |
|
onClick: applyOrUnset(color), |
|
"aria-label": name ? // translators: %s: The name of the color e.g: "vivid red". |
|
Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["__"])('Color: %s'), name) : // translators: %s: color hex code e.g: "#f00". |
|
Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["__"])('Color code: %s'), color), |
|
"aria-pressed": value === color |
|
})), value === color && Object(external_this_wp_element_["createElement"])(dashicon_Dashicon, { |
|
icon: "saved" |
|
})); |
|
}), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-color-palette__custom-clear-wrapper" |
|
}, !disableCustomColors && Object(external_this_wp_element_["createElement"])(dropdown, { |
|
className: "components-color-palette__custom-color", |
|
contentClassName: "components-color-palette__picker", |
|
renderToggle: function renderToggle(_ref3) { |
|
var isOpen = _ref3.isOpen, |
|
onToggle = _ref3.onToggle; |
|
return Object(external_this_wp_element_["createElement"])(build_module_button, { |
|
"aria-expanded": isOpen, |
|
onClick: onToggle, |
|
"aria-label": customColorPickerLabel, |
|
isLink: true |
|
}, Object(external_this_wp_i18n_["__"])('Custom Color')); |
|
}, |
|
renderContent: function renderContent() { |
|
return Object(external_this_wp_element_["createElement"])(color_picker_ColorPicker, { |
|
color: value, |
|
onChangeComplete: function onChangeComplete(color) { |
|
return onChange(color.hex); |
|
}, |
|
disableAlpha: true |
|
}); |
|
} |
|
}), !!clearable && Object(external_this_wp_element_["createElement"])(build_module_button, { |
|
className: "components-color-palette__clear", |
|
type: "button", |
|
onClick: function onClick() { |
|
return onChange(undefined); |
|
}, |
|
isSmall: true, |
|
isDefault: true |
|
}, Object(external_this_wp_i18n_["__"])('Clear')))); |
|
} |
|
|
|
// EXTERNAL MODULE: ./node_modules/react-dates/initialize.js |
|
var initialize = __webpack_require__(237); |
|
|
|
// EXTERNAL MODULE: external "moment" |
|
var external_moment_ = __webpack_require__(29); |
|
var external_moment_default = /*#__PURE__*/__webpack_require__.n(external_moment_); |
|
|
|
// EXTERNAL MODULE: ./node_modules/react-dates/index.js |
|
var react_dates = __webpack_require__(226); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/date-time/date.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Module Constants |
|
*/ |
|
|
|
var TIMEZONELESS_FORMAT = 'YYYY-MM-DDTHH:mm:ss'; |
|
|
|
var date_isRTL = function isRTL() { |
|
return document.documentElement.dir === 'rtl'; |
|
}; |
|
|
|
var date_DatePicker = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(DatePicker, _Component); |
|
|
|
function DatePicker() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, DatePicker); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(DatePicker).apply(this, arguments)); |
|
_this.onChangeMoment = _this.onChangeMoment.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.nodeRef = Object(external_this_wp_element_["createRef"])(); |
|
_this.keepFocusInside = _this.keepFocusInside.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
/* |
|
* Todo: We should remove this function ASAP. |
|
* It is kept because focus is lost when we click on the previous and next month buttons. |
|
* This focus loss closes the date picker popover. |
|
* Ideally we should add an upstream commit on react-dates to fix this issue. |
|
*/ |
|
|
|
|
|
Object(createClass["a" /* default */])(DatePicker, [{ |
|
key: "keepFocusInside", |
|
value: function keepFocusInside() { |
|
if (!this.nodeRef.current) { |
|
return; |
|
} // If focus was lost. |
|
|
|
|
|
if (!document.activeElement || !this.nodeRef.current.contains(document.activeElement)) { |
|
// Retrieve the focus region div. |
|
var focusRegion = this.nodeRef.current.querySelector('.DayPicker_focusRegion'); |
|
|
|
if (!focusRegion) { |
|
return; |
|
} // Keep the focus on focus region. |
|
|
|
|
|
focusRegion.focus(); |
|
} |
|
} |
|
}, { |
|
key: "onChangeMoment", |
|
value: function onChangeMoment(newDate) { |
|
var _this$props = this.props, |
|
currentDate = _this$props.currentDate, |
|
onChange = _this$props.onChange; // If currentDate is null, use now as momentTime to designate hours, minutes, seconds. |
|
|
|
var momentDate = currentDate ? external_moment_default()(currentDate) : external_moment_default()(); |
|
var momentTime = { |
|
hours: momentDate.hours(), |
|
minutes: momentDate.minutes(), |
|
seconds: 0 |
|
}; |
|
onChange(newDate.set(momentTime).format(TIMEZONELESS_FORMAT)); |
|
} |
|
/** |
|
* Create a Moment object from a date string. With no currentDate supplied, default to a Moment |
|
* object representing now. If a null value is passed, return a null value. |
|
* |
|
* @param {?string} currentDate Date representing the currently selected date or null to signify no selection. |
|
* @return {?Moment} Moment object for selected date or null. |
|
*/ |
|
|
|
}, { |
|
key: "getMomentDate", |
|
value: function getMomentDate(currentDate) { |
|
if (null === currentDate) { |
|
return null; |
|
} |
|
|
|
return currentDate ? external_moment_default()(currentDate) : external_moment_default()(); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props2 = this.props, |
|
currentDate = _this$props2.currentDate, |
|
isInvalidDate = _this$props2.isInvalidDate; |
|
var momentDate = this.getMomentDate(currentDate); |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-datetime__date", |
|
ref: this.nodeRef |
|
}, Object(external_this_wp_element_["createElement"])(react_dates["DayPickerSingleDateController"], { |
|
date: momentDate, |
|
daySize: 30, |
|
focused: true, |
|
hideKeyboardShortcutsPanel: true // This is a hack to force the calendar to update on month or year change |
|
// https://github.com/airbnb/react-dates/issues/240#issuecomment-361776665 |
|
, |
|
key: "datepicker-controller-".concat(momentDate ? momentDate.format('MM-YYYY') : 'null'), |
|
noBorder: true, |
|
numberOfMonths: 1, |
|
onDateChange: this.onChangeMoment, |
|
transitionDuration: 0, |
|
weekDayFormat: "ddd", |
|
isRTL: date_isRTL(), |
|
isOutsideRange: function isOutsideRange(date) { |
|
return isInvalidDate && isInvalidDate(date.toDate()); |
|
}, |
|
onPrevMonthClick: this.keepFocusInside, |
|
onNextMonthClick: this.keepFocusInside |
|
})); |
|
} |
|
}]); |
|
|
|
return DatePicker; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var date_time_date = (date_DatePicker); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/date-time/time.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Module Constants |
|
*/ |
|
|
|
var time_TIMEZONELESS_FORMAT = 'YYYY-MM-DDTHH:mm:ss'; |
|
|
|
var time_TimePicker = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(TimePicker, _Component); |
|
|
|
function TimePicker() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, TimePicker); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(TimePicker).apply(this, arguments)); |
|
_this.state = { |
|
day: '', |
|
month: '', |
|
year: '', |
|
hours: '', |
|
minutes: '', |
|
am: true, |
|
date: null |
|
}; |
|
_this.changeDate = _this.changeDate.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.updateMonth = _this.updateMonth.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onChangeMonth = _this.onChangeMonth.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.updateDay = _this.updateDay.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onChangeDay = _this.onChangeDay.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.updateYear = _this.updateYear.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onChangeYear = _this.onChangeYear.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.updateHours = _this.updateHours.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.updateMinutes = _this.updateMinutes.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onChangeHours = _this.onChangeHours.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onChangeMinutes = _this.onChangeMinutes.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.renderMonth = _this.renderMonth.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.renderDay = _this.renderDay.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.renderDayMonthFormat = _this.renderDayMonthFormat.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(TimePicker, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
this.syncState(this.props); |
|
} |
|
}, { |
|
key: "componentDidUpdate", |
|
value: function componentDidUpdate(prevProps) { |
|
var _this$props = this.props, |
|
currentTime = _this$props.currentTime, |
|
is12Hour = _this$props.is12Hour; |
|
|
|
if (currentTime !== prevProps.currentTime || is12Hour !== prevProps.is12Hour) { |
|
this.syncState(this.props); |
|
} |
|
} |
|
/** |
|
* Function that sets the date state and calls the onChange with a new date. |
|
* The date is truncated at the minutes. |
|
* |
|
* @param {Object} newDate The date object. |
|
*/ |
|
|
|
}, { |
|
key: "changeDate", |
|
value: function changeDate(newDate) { |
|
var dateWithStartOfMinutes = newDate.clone().startOf('minute'); |
|
this.setState({ |
|
date: dateWithStartOfMinutes |
|
}); |
|
this.props.onChange(newDate.format(time_TIMEZONELESS_FORMAT)); |
|
} |
|
}, { |
|
key: "getMaxHours", |
|
value: function getMaxHours() { |
|
return this.props.is12Hour ? 12 : 23; |
|
} |
|
}, { |
|
key: "getMinHours", |
|
value: function getMinHours() { |
|
return this.props.is12Hour ? 1 : 0; |
|
} |
|
}, { |
|
key: "syncState", |
|
value: function syncState(_ref) { |
|
var currentTime = _ref.currentTime, |
|
is12Hour = _ref.is12Hour; |
|
var selected = currentTime ? external_moment_default()(currentTime) : external_moment_default()(); |
|
var day = selected.format('DD'); |
|
var month = selected.format('MM'); |
|
var year = selected.format('YYYY'); |
|
var minutes = selected.format('mm'); |
|
var am = selected.format('A'); |
|
var hours = selected.format(is12Hour ? 'hh' : 'HH'); |
|
var date = currentTime ? external_moment_default()(currentTime) : external_moment_default()(); |
|
this.setState({ |
|
day: day, |
|
month: month, |
|
year: year, |
|
minutes: minutes, |
|
hours: hours, |
|
am: am, |
|
date: date |
|
}); |
|
} |
|
}, { |
|
key: "updateHours", |
|
value: function updateHours() { |
|
var is12Hour = this.props.is12Hour; |
|
var _this$state = this.state, |
|
am = _this$state.am, |
|
hours = _this$state.hours, |
|
date = _this$state.date; |
|
var value = parseInt(hours, 10); |
|
|
|
if (!Object(external_lodash_["isInteger"])(value) || is12Hour && (value < 1 || value > 12) || !is12Hour && (value < 0 || value > 23)) { |
|
this.syncState(this.props); |
|
return; |
|
} |
|
|
|
var newDate = is12Hour ? date.clone().hours(am === 'AM' ? value % 12 : (value % 12 + 12) % 24) : date.clone().hours(value); |
|
this.changeDate(newDate); |
|
} |
|
}, { |
|
key: "updateMinutes", |
|
value: function updateMinutes() { |
|
var _this$state2 = this.state, |
|
minutes = _this$state2.minutes, |
|
date = _this$state2.date; |
|
var value = parseInt(minutes, 10); |
|
|
|
if (!Object(external_lodash_["isInteger"])(value) || value < 0 || value > 59) { |
|
this.syncState(this.props); |
|
return; |
|
} |
|
|
|
var newDate = date.clone().minutes(value); |
|
this.changeDate(newDate); |
|
} |
|
}, { |
|
key: "updateDay", |
|
value: function updateDay() { |
|
var _this$state3 = this.state, |
|
day = _this$state3.day, |
|
date = _this$state3.date; |
|
var value = parseInt(day, 10); |
|
|
|
if (!Object(external_lodash_["isInteger"])(value) || value < 1 || value > 31) { |
|
this.syncState(this.props); |
|
return; |
|
} |
|
|
|
var newDate = date.clone().date(value); |
|
this.changeDate(newDate); |
|
} |
|
}, { |
|
key: "updateMonth", |
|
value: function updateMonth() { |
|
var _this$state4 = this.state, |
|
month = _this$state4.month, |
|
date = _this$state4.date; |
|
var value = parseInt(month, 10); |
|
|
|
if (!Object(external_lodash_["isInteger"])(value) || value < 1 || value > 12) { |
|
this.syncState(this.props); |
|
return; |
|
} |
|
|
|
var newDate = date.clone().month(value - 1); |
|
this.changeDate(newDate); |
|
} |
|
}, { |
|
key: "updateYear", |
|
value: function updateYear() { |
|
var _this$state5 = this.state, |
|
year = _this$state5.year, |
|
date = _this$state5.date; |
|
var value = parseInt(year, 10); |
|
|
|
if (!Object(external_lodash_["isInteger"])(value) || value < 0 || value > 9999) { |
|
this.syncState(this.props); |
|
return; |
|
} |
|
|
|
var newDate = date.clone().year(value); |
|
this.changeDate(newDate); |
|
} |
|
}, { |
|
key: "updateAmPm", |
|
value: function updateAmPm(value) { |
|
var _this2 = this; |
|
|
|
return function () { |
|
var _this2$state = _this2.state, |
|
am = _this2$state.am, |
|
date = _this2$state.date, |
|
hours = _this2$state.hours; |
|
|
|
if (am === value) { |
|
return; |
|
} |
|
|
|
var newDate; |
|
|
|
if (value === 'PM') { |
|
newDate = date.clone().hours((parseInt(hours, 10) % 12 + 12) % 24); |
|
} else { |
|
newDate = date.clone().hours(parseInt(hours, 10) % 12); |
|
} |
|
|
|
_this2.changeDate(newDate); |
|
}; |
|
} |
|
}, { |
|
key: "onChangeDay", |
|
value: function onChangeDay(event) { |
|
this.setState({ |
|
day: event.target.value |
|
}); |
|
} |
|
}, { |
|
key: "onChangeMonth", |
|
value: function onChangeMonth(event) { |
|
this.setState({ |
|
month: event.target.value |
|
}); |
|
} |
|
}, { |
|
key: "onChangeYear", |
|
value: function onChangeYear(event) { |
|
this.setState({ |
|
year: event.target.value |
|
}); |
|
} |
|
}, { |
|
key: "onChangeHours", |
|
value: function onChangeHours(event) { |
|
this.setState({ |
|
hours: event.target.value |
|
}); |
|
} |
|
}, { |
|
key: "onChangeMinutes", |
|
value: function onChangeMinutes(event) { |
|
var minutes = event.target.value; |
|
this.setState({ |
|
minutes: minutes === '' ? '' : ('0' + minutes).slice(-2) |
|
}); |
|
} |
|
}, { |
|
key: "renderMonth", |
|
value: function renderMonth(month) { |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
key: "render-month", |
|
className: "components-datetime__time-field components-datetime__time-field-month" |
|
}, Object(external_this_wp_element_["createElement"])("select", { |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Month'), |
|
className: "components-datetime__time-field-month-select", |
|
value: month, |
|
onChange: this.onChangeMonth, |
|
onBlur: this.updateMonth |
|
}, Object(external_this_wp_element_["createElement"])("option", { |
|
value: "01" |
|
}, Object(external_this_wp_i18n_["__"])('January')), Object(external_this_wp_element_["createElement"])("option", { |
|
value: "02" |
|
}, Object(external_this_wp_i18n_["__"])('February')), Object(external_this_wp_element_["createElement"])("option", { |
|
value: "03" |
|
}, Object(external_this_wp_i18n_["__"])('March')), Object(external_this_wp_element_["createElement"])("option", { |
|
value: "04" |
|
}, Object(external_this_wp_i18n_["__"])('April')), Object(external_this_wp_element_["createElement"])("option", { |
|
value: "05" |
|
}, Object(external_this_wp_i18n_["__"])('May')), Object(external_this_wp_element_["createElement"])("option", { |
|
value: "06" |
|
}, Object(external_this_wp_i18n_["__"])('June')), Object(external_this_wp_element_["createElement"])("option", { |
|
value: "07" |
|
}, Object(external_this_wp_i18n_["__"])('July')), Object(external_this_wp_element_["createElement"])("option", { |
|
value: "08" |
|
}, Object(external_this_wp_i18n_["__"])('August')), Object(external_this_wp_element_["createElement"])("option", { |
|
value: "09" |
|
}, Object(external_this_wp_i18n_["__"])('September')), Object(external_this_wp_element_["createElement"])("option", { |
|
value: "10" |
|
}, Object(external_this_wp_i18n_["__"])('October')), Object(external_this_wp_element_["createElement"])("option", { |
|
value: "11" |
|
}, Object(external_this_wp_i18n_["__"])('November')), Object(external_this_wp_element_["createElement"])("option", { |
|
value: "12" |
|
}, Object(external_this_wp_i18n_["__"])('December')))); |
|
} |
|
}, { |
|
key: "renderDay", |
|
value: function renderDay(day) { |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
key: "render-day", |
|
className: "components-datetime__time-field components-datetime__time-field-day" |
|
}, Object(external_this_wp_element_["createElement"])("input", { |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Day'), |
|
className: "components-datetime__time-field-day-input", |
|
type: "number", |
|
value: day, |
|
step: 1, |
|
min: 1, |
|
onChange: this.onChangeDay, |
|
onBlur: this.updateDay |
|
})); |
|
} |
|
}, { |
|
key: "renderDayMonthFormat", |
|
value: function renderDayMonthFormat(is12Hour) { |
|
var _this$state6 = this.state, |
|
day = _this$state6.day, |
|
month = _this$state6.month; |
|
var layout = [this.renderDay(day), this.renderMonth(month)]; |
|
return is12Hour ? layout : layout.reverse(); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var is12Hour = this.props.is12Hour; |
|
var _this$state7 = this.state, |
|
year = _this$state7.year, |
|
minutes = _this$state7.minutes, |
|
hours = _this$state7.hours, |
|
am = _this$state7.am; |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: classnames_default()('components-datetime__time') |
|
}, Object(external_this_wp_element_["createElement"])("fieldset", null, Object(external_this_wp_element_["createElement"])("legend", { |
|
className: "components-datetime__time-legend invisible" |
|
}, Object(external_this_wp_i18n_["__"])('Date')), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-datetime__time-wrapper" |
|
}, this.renderDayMonthFormat(is12Hour), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-datetime__time-field components-datetime__time-field-year" |
|
}, Object(external_this_wp_element_["createElement"])("input", { |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Year'), |
|
className: "components-datetime__time-field-year-input", |
|
type: "number", |
|
step: 1, |
|
value: year, |
|
onChange: this.onChangeYear, |
|
onBlur: this.updateYear |
|
})))), Object(external_this_wp_element_["createElement"])("fieldset", null, Object(external_this_wp_element_["createElement"])("legend", { |
|
className: "components-datetime__time-legend invisible" |
|
}, Object(external_this_wp_i18n_["__"])('Time')), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-datetime__time-wrapper" |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-datetime__time-field components-datetime__time-field-time" |
|
}, Object(external_this_wp_element_["createElement"])("input", { |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Hours'), |
|
className: "components-datetime__time-field-hours-input", |
|
type: "number", |
|
step: 1, |
|
min: this.getMinHours(), |
|
max: this.getMaxHours(), |
|
value: hours, |
|
onChange: this.onChangeHours, |
|
onBlur: this.updateHours |
|
}), Object(external_this_wp_element_["createElement"])("span", { |
|
className: "components-datetime__time-separator", |
|
"aria-hidden": "true" |
|
}, ":"), Object(external_this_wp_element_["createElement"])("input", { |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Minutes'), |
|
className: "components-datetime__time-field-minutes-input", |
|
type: "number", |
|
min: 0, |
|
max: 59, |
|
value: minutes, |
|
onChange: this.onChangeMinutes, |
|
onBlur: this.updateMinutes |
|
})), is12Hour && Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-datetime__time-field components-datetime__time-field-am-pm" |
|
}, Object(external_this_wp_element_["createElement"])(build_module_button, { |
|
"aria-pressed": am === 'AM', |
|
isDefault: true, |
|
className: "components-datetime__time-am-button", |
|
isToggled: am === 'AM', |
|
onClick: this.updateAmPm('AM') |
|
}, Object(external_this_wp_i18n_["__"])('AM')), Object(external_this_wp_element_["createElement"])(build_module_button, { |
|
"aria-pressed": am === 'PM', |
|
isDefault: true, |
|
className: "components-datetime__time-pm-button", |
|
isToggled: am === 'PM', |
|
onClick: this.updateAmPm('PM') |
|
}, Object(external_this_wp_i18n_["__"])('PM')))))); |
|
} |
|
}]); |
|
|
|
return TimePicker; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var time = (time_TimePicker); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/date-time/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
// Needed to initialise the default datepicker styles. |
|
// See: https://github.com/airbnb/react-dates#initialize |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
var date_time_DateTimePicker = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(DateTimePicker, _Component); |
|
|
|
function DateTimePicker() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, DateTimePicker); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(DateTimePicker).apply(this, arguments)); |
|
_this.state = { |
|
calendarHelpIsVisible: false |
|
}; |
|
_this.onClickDescriptionToggle = _this.onClickDescriptionToggle.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(DateTimePicker, [{ |
|
key: "onClickDescriptionToggle", |
|
value: function onClickDescriptionToggle() { |
|
this.setState({ |
|
calendarHelpIsVisible: !this.state.calendarHelpIsVisible |
|
}); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
currentDate = _this$props.currentDate, |
|
is12Hour = _this$props.is12Hour, |
|
onChange = _this$props.onChange; |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-datetime" |
|
}, !this.state.calendarHelpIsVisible && Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(time, { |
|
currentTime: currentDate, |
|
onChange: onChange, |
|
is12Hour: is12Hour |
|
}), Object(external_this_wp_element_["createElement"])(date_time_date, { |
|
currentDate: currentDate, |
|
onChange: onChange |
|
})), this.state.calendarHelpIsVisible && Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-datetime__calendar-help" |
|
}, Object(external_this_wp_element_["createElement"])("h4", null, Object(external_this_wp_i18n_["__"])('Click to Select')), Object(external_this_wp_element_["createElement"])("ul", null, Object(external_this_wp_element_["createElement"])("li", null, Object(external_this_wp_i18n_["__"])('Click the right or left arrows to select other months in the past or the future.')), Object(external_this_wp_element_["createElement"])("li", null, Object(external_this_wp_i18n_["__"])('Click the desired day to select it.'))), Object(external_this_wp_element_["createElement"])("h4", null, Object(external_this_wp_i18n_["__"])('Navigating with a keyboard')), Object(external_this_wp_element_["createElement"])("ul", null, Object(external_this_wp_element_["createElement"])("li", null, Object(external_this_wp_element_["createElement"])("abbr", { |
|
"aria-label": Object(external_this_wp_i18n_["_x"])('Enter', 'keyboard button') |
|
}, "\u21B5"), ' ' |
|
/* JSX removes whitespace, but a space is required for screen readers. */ |
|
, Object(external_this_wp_element_["createElement"])("span", null, Object(external_this_wp_i18n_["__"])('Select the date in focus.'))), Object(external_this_wp_element_["createElement"])("li", null, Object(external_this_wp_element_["createElement"])("abbr", { |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Left and Right Arrows') |
|
}, "\u2190/\u2192"), ' ' |
|
/* JSX removes whitespace, but a space is required for screen readers. */ |
|
, Object(external_this_wp_i18n_["__"])('Move backward (left) or forward (right) by one day.')), Object(external_this_wp_element_["createElement"])("li", null, Object(external_this_wp_element_["createElement"])("abbr", { |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Up and Down Arrows') |
|
}, "\u2191/\u2193"), ' ' |
|
/* JSX removes whitespace, but a space is required for screen readers. */ |
|
, Object(external_this_wp_i18n_["__"])('Move backward (up) or forward (down) by one week.')), Object(external_this_wp_element_["createElement"])("li", null, Object(external_this_wp_element_["createElement"])("abbr", { |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Page Up and Page Down') |
|
}, Object(external_this_wp_i18n_["__"])('PgUp/PgDn')), ' ' |
|
/* JSX removes whitespace, but a space is required for screen readers. */ |
|
, Object(external_this_wp_i18n_["__"])('Move backward (PgUp) or forward (PgDn) by one month.')), Object(external_this_wp_element_["createElement"])("li", null, Object(external_this_wp_element_["createElement"])("abbr", { |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Home and End') |
|
}, Object(external_this_wp_i18n_["__"])('Home/End')), ' ' |
|
/* JSX removes whitespace, but a space is required for screen readers. */ |
|
, Object(external_this_wp_i18n_["__"])('Go to the first (home) or last (end) day of a week.'))), Object(external_this_wp_element_["createElement"])(build_module_button, { |
|
isSmall: true, |
|
onClick: this.onClickDescriptionToggle |
|
}, Object(external_this_wp_i18n_["__"])('Close')))), !this.state.calendarHelpIsVisible && Object(external_this_wp_element_["createElement"])(build_module_button, { |
|
className: "components-datetime__date-help-button", |
|
isLink: true, |
|
onClick: this.onClickDescriptionToggle |
|
}, Object(external_this_wp_i18n_["__"])('Calendar Help'))); |
|
} |
|
}]); |
|
|
|
return DateTimePicker; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/disabled/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
var disabled_createContext = Object(external_this_wp_element_["createContext"])(false), |
|
disabled_Consumer = disabled_createContext.Consumer, |
|
disabled_Provider = disabled_createContext.Provider; |
|
/** |
|
* Names of control nodes which qualify for disabled behavior. |
|
* |
|
* See WHATWG HTML Standard: 4.10.18.5: "Enabling and disabling form controls: the disabled attribute". |
|
* |
|
* @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#enabling-and-disabling-form-controls:-the-disabled-attribute |
|
* |
|
* @type {string[]} |
|
*/ |
|
|
|
|
|
var DISABLED_ELIGIBLE_NODE_NAMES = ['BUTTON', 'FIELDSET', 'INPUT', 'OPTGROUP', 'OPTION', 'SELECT', 'TEXTAREA']; |
|
|
|
var disabled_Disabled = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Disabled, _Component); |
|
|
|
function Disabled() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Disabled); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Disabled).apply(this, arguments)); |
|
_this.bindNode = _this.bindNode.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.disable = _this.disable.bind(Object(assertThisInitialized["a" /* default */])(_this)); // Debounce re-disable since disabling process itself will incur |
|
// additional mutations which should be ignored. |
|
|
|
_this.debouncedDisable = Object(external_lodash_["debounce"])(_this.disable, { |
|
leading: true |
|
}); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(Disabled, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
this.disable(); |
|
this.observer = new window.MutationObserver(this.debouncedDisable); |
|
this.observer.observe(this.node, { |
|
childList: true, |
|
attributes: true, |
|
subtree: true |
|
}); |
|
} |
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.observer.disconnect(); |
|
this.debouncedDisable.cancel(); |
|
} |
|
}, { |
|
key: "bindNode", |
|
value: function bindNode(node) { |
|
this.node = node; |
|
} |
|
}, { |
|
key: "disable", |
|
value: function disable() { |
|
external_this_wp_dom_["focus"].focusable.find(this.node).forEach(function (focusable) { |
|
if (Object(external_lodash_["includes"])(DISABLED_ELIGIBLE_NODE_NAMES, focusable.nodeName)) { |
|
focusable.setAttribute('disabled', ''); |
|
} |
|
|
|
if (focusable.hasAttribute('tabindex')) { |
|
focusable.removeAttribute('tabindex'); |
|
} |
|
|
|
if (focusable.hasAttribute('contenteditable')) { |
|
focusable.setAttribute('contenteditable', 'false'); |
|
} |
|
}); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
className = _this$props.className, |
|
props = Object(objectWithoutProperties["a" /* default */])(_this$props, ["className"]); |
|
|
|
return Object(external_this_wp_element_["createElement"])(disabled_Provider, { |
|
value: true |
|
}, Object(external_this_wp_element_["createElement"])("div", Object(esm_extends["a" /* default */])({ |
|
ref: this.bindNode, |
|
className: classnames_default()(className, 'components-disabled') |
|
}, props), this.props.children)); |
|
} |
|
}]); |
|
|
|
return Disabled; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
disabled_Disabled.Consumer = disabled_Consumer; |
|
/* harmony default export */ var build_module_disabled = (disabled_Disabled); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/draggable/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
var dragImageClass = 'components-draggable__invisible-drag-image'; |
|
var cloneWrapperClass = 'components-draggable__clone'; |
|
var cloneHeightTransformationBreakpoint = 700; |
|
var clonePadding = 20; |
|
|
|
var draggable_Draggable = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Draggable, _Component); |
|
|
|
function Draggable() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Draggable); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Draggable).apply(this, arguments)); |
|
_this.onDragStart = _this.onDragStart.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onDragOver = _this.onDragOver.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onDragEnd = _this.onDragEnd.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.resetDragState = _this.resetDragState.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(Draggable, [{ |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.resetDragState(); |
|
} |
|
/** |
|
* Removes the element clone, resets cursor, and removes drag listener. |
|
* |
|
* @param {Object} event The non-custom DragEvent. |
|
*/ |
|
|
|
}, { |
|
key: "onDragEnd", |
|
value: function onDragEnd(event) { |
|
var _this$props$onDragEnd = this.props.onDragEnd, |
|
onDragEnd = _this$props$onDragEnd === void 0 ? external_lodash_["noop"] : _this$props$onDragEnd; |
|
event.preventDefault(); |
|
this.resetDragState(); |
|
this.props.setTimeout(onDragEnd); |
|
} |
|
/** |
|
* Updates positioning of element clone based on mouse movement during dragging. |
|
* |
|
* @param {Object} event The non-custom DragEvent. |
|
*/ |
|
|
|
}, { |
|
key: "onDragOver", |
|
value: function onDragOver(event) { |
|
this.cloneWrapper.style.top = "".concat(parseInt(this.cloneWrapper.style.top, 10) + event.clientY - this.cursorTop, "px"); |
|
this.cloneWrapper.style.left = "".concat(parseInt(this.cloneWrapper.style.left, 10) + event.clientX - this.cursorLeft, "px"); // Update cursor coordinates. |
|
|
|
this.cursorLeft = event.clientX; |
|
this.cursorTop = event.clientY; |
|
} |
|
/** |
|
* This method does a couple of things: |
|
* |
|
* - Clones the current element and spawns clone over original element. |
|
* - Adds a fake temporary drag image to avoid browser defaults. |
|
* - Sets transfer data. |
|
* - Adds dragover listener. |
|
* |
|
* @param {Object} event The non-custom DragEvent. |
|
*/ |
|
|
|
}, { |
|
key: "onDragStart", |
|
value: function onDragStart(event) { |
|
var _this$props = this.props, |
|
elementId = _this$props.elementId, |
|
transferData = _this$props.transferData, |
|
_this$props$onDragSta = _this$props.onDragStart, |
|
onDragStart = _this$props$onDragSta === void 0 ? external_lodash_["noop"] : _this$props$onDragSta; |
|
var element = document.getElementById(elementId); |
|
|
|
if (!element) { |
|
event.preventDefault(); |
|
return; |
|
} // Set a fake drag image to avoid browser defaults. Remove from DOM |
|
// right after. event.dataTransfer.setDragImage is not supported yet in |
|
// IE, we need to check for its existence first. |
|
|
|
|
|
if ('function' === typeof event.dataTransfer.setDragImage) { |
|
var dragImage = document.createElement('div'); |
|
dragImage.id = "drag-image-".concat(elementId); |
|
dragImage.classList.add(dragImageClass); |
|
document.body.appendChild(dragImage); |
|
event.dataTransfer.setDragImage(dragImage, 0, 0); |
|
this.props.setTimeout(function () { |
|
document.body.removeChild(dragImage); |
|
}); |
|
} |
|
|
|
event.dataTransfer.setData('text', JSON.stringify(transferData)); // Prepare element clone and append to element wrapper. |
|
|
|
var elementRect = element.getBoundingClientRect(); |
|
var elementWrapper = element.parentNode; |
|
var elementTopOffset = parseInt(elementRect.top, 10); |
|
var elementLeftOffset = parseInt(elementRect.left, 10); |
|
var clone = element.cloneNode(true); |
|
clone.id = "clone-".concat(elementId); |
|
this.cloneWrapper = document.createElement('div'); |
|
this.cloneWrapper.classList.add(cloneWrapperClass); |
|
this.cloneWrapper.style.width = "".concat(elementRect.width + clonePadding * 2, "px"); |
|
|
|
if (elementRect.height > cloneHeightTransformationBreakpoint) { |
|
// Scale down clone if original element is larger than 700px. |
|
this.cloneWrapper.style.transform = 'scale(0.5)'; |
|
this.cloneWrapper.style.transformOrigin = 'top left'; // Position clone near the cursor. |
|
|
|
this.cloneWrapper.style.top = "".concat(event.clientY - 100, "px"); |
|
this.cloneWrapper.style.left = "".concat(event.clientX, "px"); |
|
} else { |
|
// Position clone right over the original element (20px padding). |
|
this.cloneWrapper.style.top = "".concat(elementTopOffset - clonePadding, "px"); |
|
this.cloneWrapper.style.left = "".concat(elementLeftOffset - clonePadding, "px"); |
|
} // Hack: Remove iFrames as it's causing the embeds drag clone to freeze |
|
|
|
|
|
Object(toConsumableArray["a" /* default */])(clone.querySelectorAll('iframe')).forEach(function (child) { |
|
return child.parentNode.removeChild(child); |
|
}); |
|
|
|
this.cloneWrapper.appendChild(clone); |
|
elementWrapper.appendChild(this.cloneWrapper); // Mark the current cursor coordinates. |
|
|
|
this.cursorLeft = event.clientX; |
|
this.cursorTop = event.clientY; // Update cursor to 'grabbing', document wide. |
|
|
|
document.body.classList.add('is-dragging-components-draggable'); |
|
document.addEventListener('dragover', this.onDragOver); |
|
this.props.setTimeout(onDragStart); |
|
} |
|
/** |
|
* Cleans up drag state when drag has completed, or component unmounts |
|
* while dragging. |
|
*/ |
|
|
|
}, { |
|
key: "resetDragState", |
|
value: function resetDragState() { |
|
// Remove drag clone |
|
document.removeEventListener('dragover', this.onDragOver); |
|
|
|
if (this.cloneWrapper && this.cloneWrapper.parentNode) { |
|
this.cloneWrapper.parentNode.removeChild(this.cloneWrapper); |
|
this.cloneWrapper = null; |
|
} // Reset cursor. |
|
|
|
|
|
document.body.classList.remove('is-dragging-components-draggable'); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var children = this.props.children; |
|
return children({ |
|
onDraggableStart: this.onDragStart, |
|
onDraggableEnd: this.onDragEnd |
|
}); |
|
} |
|
}]); |
|
|
|
return Draggable; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var draggable = (Object(external_this_wp_compose_["withSafeTimeout"])(draggable_Draggable)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/drop-zone/provider.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
var provider_createContext = Object(external_this_wp_element_["createContext"])({ |
|
addDropZone: function addDropZone() {}, |
|
removeDropZone: function removeDropZone() {} |
|
}), |
|
provider_Provider = provider_createContext.Provider, |
|
provider_Consumer = provider_createContext.Consumer; |
|
|
|
var provider_getDragEventType = function getDragEventType(_ref) { |
|
var dataTransfer = _ref.dataTransfer; |
|
|
|
if (dataTransfer) { |
|
// Use lodash `includes` here as in the Edge browser `types` is implemented |
|
// as a DomStringList, whereas in other browsers it's an array. `includes` |
|
// happily works with both types. |
|
if (Object(external_lodash_["includes"])(dataTransfer.types, 'Files')) { |
|
return 'file'; |
|
} |
|
|
|
if (Object(external_lodash_["includes"])(dataTransfer.types, 'text/html')) { |
|
return 'html'; |
|
} |
|
} |
|
|
|
return 'default'; |
|
}; |
|
|
|
var isTypeSupportedByDropZone = function isTypeSupportedByDropZone(type, dropZone) { |
|
return type === 'file' && dropZone.onFilesDrop || type === 'html' && dropZone.onHTMLDrop || type === 'default' && dropZone.onDrop; |
|
}; |
|
|
|
var isWithinElementBounds = function isWithinElementBounds(element, x, y) { |
|
var rect = element.getBoundingClientRect(); /// make sure the rect is a valid rect |
|
|
|
if (rect.bottom === rect.top || rect.left === rect.right) { |
|
return false; |
|
} |
|
|
|
return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom; |
|
}; |
|
|
|
var provider_DropZoneProvider = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(DropZoneProvider, _Component); |
|
|
|
function DropZoneProvider() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, DropZoneProvider); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(DropZoneProvider).apply(this, arguments)); // Event listeners |
|
|
|
_this.onDragOver = _this.onDragOver.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onDrop = _this.onDrop.bind(Object(assertThisInitialized["a" /* default */])(_this)); // Context methods so this component can receive data from consumers |
|
|
|
_this.addDropZone = _this.addDropZone.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.removeDropZone = _this.removeDropZone.bind(Object(assertThisInitialized["a" /* default */])(_this)); // Utility methods |
|
|
|
_this.resetDragState = _this.resetDragState.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.toggleDraggingOverDocument = Object(external_lodash_["throttle"])(_this.toggleDraggingOverDocument.bind(Object(assertThisInitialized["a" /* default */])(_this)), 200); |
|
_this.dropZones = []; |
|
_this.dropZoneCallbacks = { |
|
addDropZone: _this.addDropZone, |
|
removeDropZone: _this.removeDropZone |
|
}; |
|
_this.state = { |
|
hoveredDropZone: -1, |
|
isDraggingOverDocument: false, |
|
position: null |
|
}; |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(DropZoneProvider, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
window.addEventListener('dragover', this.onDragOver); |
|
window.addEventListener('mouseup', this.resetDragState); |
|
} |
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
window.removeEventListener('dragover', this.onDragOver); |
|
window.removeEventListener('mouseup', this.resetDragState); |
|
} |
|
}, { |
|
key: "addDropZone", |
|
value: function addDropZone(dropZone) { |
|
this.dropZones.push(dropZone); |
|
} |
|
}, { |
|
key: "removeDropZone", |
|
value: function removeDropZone(dropZone) { |
|
this.dropZones = Object(external_lodash_["filter"])(this.dropZones, function (dz) { |
|
return dz !== dropZone; |
|
}); |
|
} |
|
}, { |
|
key: "resetDragState", |
|
value: function resetDragState() { |
|
// Avoid throttled drag over handler calls |
|
this.toggleDraggingOverDocument.cancel(); |
|
var _this$state = this.state, |
|
isDraggingOverDocument = _this$state.isDraggingOverDocument, |
|
hoveredDropZone = _this$state.hoveredDropZone; |
|
|
|
if (!isDraggingOverDocument && hoveredDropZone === -1) { |
|
return; |
|
} |
|
|
|
this.setState({ |
|
hoveredDropZone: -1, |
|
isDraggingOverDocument: false, |
|
position: null |
|
}); |
|
this.dropZones.forEach(function (dropZone) { |
|
return dropZone.setState({ |
|
isDraggingOverDocument: false, |
|
isDraggingOverElement: false, |
|
position: null, |
|
type: null |
|
}); |
|
}); |
|
} |
|
}, { |
|
key: "toggleDraggingOverDocument", |
|
value: function toggleDraggingOverDocument(event, dragEventType) { |
|
var _this2 = this; |
|
|
|
// In some contexts, it may be necessary to capture and redirect the |
|
// drag event (e.g. atop an `iframe`). To accommodate this, you can |
|
// create an instance of CustomEvent with the original event specified |
|
// as the `detail` property. |
|
// |
|
// See: https://developer.mozilla.org/en-US/docs/Web/Guide/Events/Creating_and_triggering_events |
|
var detail = window.CustomEvent && event instanceof window.CustomEvent ? event.detail : event; // Index of hovered dropzone. |
|
|
|
var hoveredDropZones = Object(external_lodash_["filter"])(this.dropZones, function (dropZone) { |
|
return isTypeSupportedByDropZone(dragEventType, dropZone) && isWithinElementBounds(dropZone.element, detail.clientX, detail.clientY); |
|
}); // Find the leaf dropzone not containing another dropzone |
|
|
|
var hoveredDropZone = Object(external_lodash_["find"])(hoveredDropZones, function (zone) { |
|
return !Object(external_lodash_["some"])(hoveredDropZones, function (subZone) { |
|
return subZone !== zone && zone.element.parentElement.contains(subZone.element); |
|
}); |
|
}); |
|
var hoveredDropZoneIndex = this.dropZones.indexOf(hoveredDropZone); |
|
var position = null; |
|
|
|
if (hoveredDropZone) { |
|
var rect = hoveredDropZone.element.getBoundingClientRect(); |
|
position = { |
|
x: detail.clientX - rect.left < rect.right - detail.clientX ? 'left' : 'right', |
|
y: detail.clientY - rect.top < rect.bottom - detail.clientY ? 'top' : 'bottom' |
|
}; |
|
} // Optimisation: Only update the changed dropzones |
|
|
|
|
|
var toUpdate = []; |
|
|
|
if (!this.state.isDraggingOverDocument) { |
|
toUpdate = this.dropZones; |
|
} else if (hoveredDropZoneIndex !== this.state.hoveredDropZone) { |
|
if (this.state.hoveredDropZone !== -1) { |
|
toUpdate.push(this.dropZones[this.state.hoveredDropZone]); |
|
} |
|
|
|
if (hoveredDropZone) { |
|
toUpdate.push(hoveredDropZone); |
|
} |
|
} else if (hoveredDropZone && hoveredDropZoneIndex === this.state.hoveredDropZone && !Object(external_lodash_["isEqual"])(position, this.state.position)) { |
|
toUpdate.push(hoveredDropZone); |
|
} // Notifying the dropzones |
|
|
|
|
|
toUpdate.forEach(function (dropZone) { |
|
var index = _this2.dropZones.indexOf(dropZone); |
|
|
|
var isDraggingOverDropZone = index === hoveredDropZoneIndex; |
|
dropZone.setState({ |
|
isDraggingOverDocument: isTypeSupportedByDropZone(dragEventType, dropZone), |
|
isDraggingOverElement: isDraggingOverDropZone, |
|
position: isDraggingOverDropZone ? position : null, |
|
type: isDraggingOverDropZone ? dragEventType : null |
|
}); |
|
}); |
|
var newState = { |
|
isDraggingOverDocument: true, |
|
hoveredDropZone: hoveredDropZoneIndex, |
|
position: position |
|
}; |
|
|
|
if (!external_this_wp_isShallowEqual_default()(newState, this.state)) { |
|
this.setState(newState); |
|
} |
|
} |
|
}, { |
|
key: "onDragOver", |
|
value: function onDragOver(event) { |
|
this.toggleDraggingOverDocument(event, provider_getDragEventType(event)); |
|
event.preventDefault(); |
|
} |
|
}, { |
|
key: "onDrop", |
|
value: function onDrop(event) { |
|
// This seemingly useless line has been shown to resolve a Safari issue |
|
// where files dragged directly from the dock are not recognized |
|
event.dataTransfer && event.dataTransfer.files.length; // eslint-disable-line no-unused-expressions |
|
|
|
var _this$state2 = this.state, |
|
position = _this$state2.position, |
|
hoveredDropZone = _this$state2.hoveredDropZone; |
|
var dragEventType = provider_getDragEventType(event); |
|
var dropZone = this.dropZones[hoveredDropZone]; |
|
this.resetDragState(); |
|
|
|
if (dropZone) { |
|
switch (dragEventType) { |
|
case 'file': |
|
dropZone.onFilesDrop(Object(toConsumableArray["a" /* default */])(event.dataTransfer.files), position); |
|
break; |
|
|
|
case 'html': |
|
dropZone.onHTMLDrop(event.dataTransfer.getData('text/html'), position); |
|
break; |
|
|
|
case 'default': |
|
dropZone.onDrop(event, position); |
|
} |
|
} |
|
|
|
event.stopPropagation(); |
|
event.preventDefault(); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
onDrop: this.onDrop, |
|
className: "components-drop-zone__provider" |
|
}, Object(external_this_wp_element_["createElement"])(provider_Provider, { |
|
value: this.dropZoneCallbacks |
|
}, this.props.children)); |
|
} |
|
}]); |
|
|
|
return DropZoneProvider; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var provider = (provider_DropZoneProvider); |
|
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/drop-zone/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
var drop_zone_DropZone = function DropZone(props) { |
|
return Object(external_this_wp_element_["createElement"])(provider_Consumer, null, function (_ref) { |
|
var addDropZone = _ref.addDropZone, |
|
removeDropZone = _ref.removeDropZone; |
|
return Object(external_this_wp_element_["createElement"])(drop_zone_DropZoneComponent, Object(esm_extends["a" /* default */])({ |
|
addDropZone: addDropZone, |
|
removeDropZone: removeDropZone |
|
}, props)); |
|
}); |
|
}; |
|
|
|
var drop_zone_DropZoneComponent = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(DropZoneComponent, _Component); |
|
|
|
function DropZoneComponent() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, DropZoneComponent); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(DropZoneComponent).apply(this, arguments)); |
|
_this.dropZoneElement = Object(external_this_wp_element_["createRef"])(); |
|
_this.dropZone = { |
|
element: null, |
|
onDrop: _this.props.onDrop, |
|
onFilesDrop: _this.props.onFilesDrop, |
|
onHTMLDrop: _this.props.onHTMLDrop, |
|
setState: _this.setState.bind(Object(assertThisInitialized["a" /* default */])(_this)) |
|
}; |
|
_this.state = { |
|
isDraggingOverDocument: false, |
|
isDraggingOverElement: false, |
|
position: null, |
|
type: null |
|
}; |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(DropZoneComponent, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
// Set element after the component has a node assigned in the DOM |
|
this.dropZone.element = this.dropZoneElement.current; |
|
this.props.addDropZone(this.dropZone); |
|
} |
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.props.removeDropZone(this.dropZone); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
className = _this$props.className, |
|
label = _this$props.label; |
|
var _this$state = this.state, |
|
isDraggingOverDocument = _this$state.isDraggingOverDocument, |
|
isDraggingOverElement = _this$state.isDraggingOverElement, |
|
position = _this$state.position, |
|
type = _this$state.type; |
|
var classes = classnames_default()('components-drop-zone', className, Object(defineProperty["a" /* default */])({ |
|
'is-active': isDraggingOverDocument || isDraggingOverElement, |
|
'is-dragging-over-document': isDraggingOverDocument, |
|
'is-dragging-over-element': isDraggingOverElement, |
|
'is-close-to-top': position && position.y === 'top', |
|
'is-close-to-bottom': position && position.y === 'bottom', |
|
'is-close-to-left': position && position.x === 'left', |
|
'is-close-to-right': position && position.x === 'right' |
|
}, "is-dragging-".concat(type), !!type)); |
|
var children; |
|
|
|
if (isDraggingOverElement) { |
|
children = Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-drop-zone__content" |
|
}, Object(external_this_wp_element_["createElement"])(dashicon_Dashicon, { |
|
icon: "upload", |
|
size: "40", |
|
className: "components-drop-zone__content-icon" |
|
}), Object(external_this_wp_element_["createElement"])("span", { |
|
className: "components-drop-zone__content-text" |
|
}, label ? label : Object(external_this_wp_i18n_["__"])('Drop files to upload'))); |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
ref: this.dropZoneElement, |
|
className: classes |
|
}, children); |
|
} |
|
}]); |
|
|
|
return DropZoneComponent; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var drop_zone = (drop_zone_DropZone); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/navigable-container/container.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
function cycleValue(value, total, offset) { |
|
var nextValue = value + offset; |
|
|
|
if (nextValue < 0) { |
|
return total + nextValue; |
|
} else if (nextValue >= total) { |
|
return nextValue - total; |
|
} |
|
|
|
return nextValue; |
|
} |
|
|
|
var container_NavigableContainer = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(NavigableContainer, _Component); |
|
|
|
function NavigableContainer() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, NavigableContainer); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(NavigableContainer).apply(this, arguments)); |
|
_this.onKeyDown = _this.onKeyDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.bindContainer = _this.bindContainer.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.getFocusableContext = _this.getFocusableContext.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.getFocusableIndex = _this.getFocusableIndex.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(NavigableContainer, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
// We use DOM event listeners instead of React event listeners |
|
// because we want to catch events from the underlying DOM tree |
|
// The React Tree can be different from the DOM tree when using |
|
// portals. Block Toolbars for instance are rendered in a separate |
|
// React Trees. |
|
this.container.addEventListener('keydown', this.onKeyDown); |
|
this.container.addEventListener('focus', this.onFocus); |
|
} |
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.container.removeEventListener('keydown', this.onKeyDown); |
|
this.container.removeEventListener('focus', this.onFocus); |
|
} |
|
}, { |
|
key: "bindContainer", |
|
value: function bindContainer(ref) { |
|
var forwardedRef = this.props.forwardedRef; |
|
this.container = ref; |
|
|
|
if (Object(external_lodash_["isFunction"])(forwardedRef)) { |
|
forwardedRef(ref); |
|
} else if (forwardedRef && 'current' in forwardedRef) { |
|
forwardedRef.current = ref; |
|
} |
|
} |
|
}, { |
|
key: "getFocusableContext", |
|
value: function getFocusableContext(target) { |
|
var onlyBrowserTabstops = this.props.onlyBrowserTabstops; |
|
var finder = onlyBrowserTabstops ? external_this_wp_dom_["focus"].tabbable : external_this_wp_dom_["focus"].focusable; |
|
var focusables = finder.find(this.container); |
|
var index = this.getFocusableIndex(focusables, target); |
|
|
|
if (index > -1 && target) { |
|
return { |
|
index: index, |
|
target: target, |
|
focusables: focusables |
|
}; |
|
} |
|
|
|
return null; |
|
} |
|
}, { |
|
key: "getFocusableIndex", |
|
value: function getFocusableIndex(focusables, target) { |
|
var directIndex = focusables.indexOf(target); |
|
|
|
if (directIndex !== -1) { |
|
return directIndex; |
|
} |
|
} |
|
}, { |
|
key: "onKeyDown", |
|
value: function onKeyDown(event) { |
|
if (this.props.onKeyDown) { |
|
this.props.onKeyDown(event); |
|
} |
|
|
|
var getFocusableContext = this.getFocusableContext; |
|
var _this$props = this.props, |
|
_this$props$cycle = _this$props.cycle, |
|
cycle = _this$props$cycle === void 0 ? true : _this$props$cycle, |
|
eventToOffset = _this$props.eventToOffset, |
|
_this$props$onNavigat = _this$props.onNavigate, |
|
onNavigate = _this$props$onNavigat === void 0 ? external_lodash_["noop"] : _this$props$onNavigat, |
|
stopNavigationEvents = _this$props.stopNavigationEvents; |
|
var offset = eventToOffset(event); // eventToOffset returns undefined if the event is not handled by the component |
|
|
|
if (offset !== undefined && stopNavigationEvents) { |
|
// Prevents arrow key handlers bound to the document directly interfering |
|
event.stopImmediatePropagation(); // When navigating a collection of items, prevent scroll containers |
|
// from scrolling. |
|
|
|
if (event.target.getAttribute('role') === 'menuitem') { |
|
event.preventDefault(); |
|
} |
|
} |
|
|
|
if (!offset) { |
|
return; |
|
} |
|
|
|
var context = getFocusableContext(document.activeElement); |
|
|
|
if (!context) { |
|
return; |
|
} |
|
|
|
var index = context.index, |
|
focusables = context.focusables; |
|
var nextIndex = cycle ? cycleValue(index, focusables.length, offset) : index + offset; |
|
|
|
if (nextIndex >= 0 && nextIndex < focusables.length) { |
|
focusables[nextIndex].focus(); |
|
onNavigate(nextIndex, focusables[nextIndex]); |
|
} |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props2 = this.props, |
|
children = _this$props2.children, |
|
props = Object(objectWithoutProperties["a" /* default */])(_this$props2, ["children"]); |
|
|
|
return Object(external_this_wp_element_["createElement"])("div", Object(esm_extends["a" /* default */])({ |
|
ref: this.bindContainer |
|
}, Object(external_lodash_["omit"])(props, ['stopNavigationEvents', 'eventToOffset', 'onNavigate', 'cycle', 'onlyBrowserTabstops', 'forwardedRef'])), children); |
|
} |
|
}]); |
|
|
|
return NavigableContainer; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
var container_forwardedNavigableContainer = function forwardedNavigableContainer(props, ref) { |
|
return Object(external_this_wp_element_["createElement"])(container_NavigableContainer, Object(esm_extends["a" /* default */])({}, props, { |
|
forwardedRef: ref |
|
})); |
|
}; |
|
|
|
container_forwardedNavigableContainer.displayName = 'NavigableContainer'; |
|
/* harmony default export */ var navigable_container_container = (Object(external_this_wp_element_["forwardRef"])(container_forwardedNavigableContainer)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/navigable-container/menu.js |
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
function NavigableMenu(_ref, ref) { |
|
var _ref$role = _ref.role, |
|
role = _ref$role === void 0 ? 'menu' : _ref$role, |
|
_ref$orientation = _ref.orientation, |
|
orientation = _ref$orientation === void 0 ? 'vertical' : _ref$orientation, |
|
rest = Object(objectWithoutProperties["a" /* default */])(_ref, ["role", "orientation"]); |
|
|
|
var eventToOffset = function eventToOffset(evt) { |
|
var keyCode = evt.keyCode; |
|
var next = [external_this_wp_keycodes_["DOWN"]]; |
|
var previous = [external_this_wp_keycodes_["UP"]]; |
|
|
|
if (orientation === 'horizontal') { |
|
next = [external_this_wp_keycodes_["RIGHT"]]; |
|
previous = [external_this_wp_keycodes_["LEFT"]]; |
|
} |
|
|
|
if (orientation === 'both') { |
|
next = [external_this_wp_keycodes_["RIGHT"], external_this_wp_keycodes_["DOWN"]]; |
|
previous = [external_this_wp_keycodes_["LEFT"], external_this_wp_keycodes_["UP"]]; |
|
} |
|
|
|
if (Object(external_lodash_["includes"])(next, keyCode)) { |
|
return 1; |
|
} else if (Object(external_lodash_["includes"])(previous, keyCode)) { |
|
return -1; |
|
} |
|
}; |
|
|
|
return Object(external_this_wp_element_["createElement"])(navigable_container_container, Object(esm_extends["a" /* default */])({ |
|
ref: ref, |
|
stopNavigationEvents: true, |
|
onlyBrowserTabstops: false, |
|
role: role, |
|
"aria-orientation": role === 'presentation' ? null : orientation, |
|
eventToOffset: eventToOffset |
|
}, rest)); |
|
} |
|
/* harmony default export */ var menu = (Object(external_this_wp_element_["forwardRef"])(NavigableMenu)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/navigable-container/tabbable.js |
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
function TabbableContainer(_ref, ref) { |
|
var eventToOffset = _ref.eventToOffset, |
|
props = Object(objectWithoutProperties["a" /* default */])(_ref, ["eventToOffset"]); |
|
|
|
var innerEventToOffset = function innerEventToOffset(evt) { |
|
var keyCode = evt.keyCode, |
|
shiftKey = evt.shiftKey; |
|
|
|
if (external_this_wp_keycodes_["TAB"] === keyCode) { |
|
return shiftKey ? -1 : 1; |
|
} // Allow custom handling of keys besides Tab. |
|
// |
|
// By default, TabbableContainer will move focus forward on Tab and |
|
// backward on Shift+Tab. The handler below will be used for all other |
|
// events. The semantics for `eventToOffset`'s return |
|
// values are the following: |
|
// |
|
// - +1: move focus forward |
|
// - -1: move focus backward |
|
// - 0: don't move focus, but acknowledge event and thus stop it |
|
// - undefined: do nothing, let the event propagate |
|
|
|
|
|
if (eventToOffset) { |
|
return eventToOffset(evt); |
|
} |
|
}; |
|
|
|
return Object(external_this_wp_element_["createElement"])(navigable_container_container, Object(esm_extends["a" /* default */])({ |
|
ref: ref, |
|
stopNavigationEvents: true, |
|
onlyBrowserTabstops: true, |
|
eventToOffset: innerEventToOffset |
|
}, props)); |
|
} |
|
/* harmony default export */ var tabbable = (Object(external_this_wp_element_["forwardRef"])(TabbableContainer)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/navigable-container/index.js |
|
/** |
|
* Internal Dependencies |
|
*/ |
|
|
|
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/dropdown-menu/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
function mergeProps() { |
|
var defaultProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; |
|
var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; |
|
|
|
var mergedProps = Object(objectSpread["a" /* default */])({}, defaultProps, props); |
|
|
|
if (props.className && defaultProps.className) { |
|
mergedProps.className = classnames_default()(props.className, defaultProps.className); |
|
} |
|
|
|
return mergedProps; |
|
} |
|
|
|
function DropdownMenu(_ref) { |
|
var children = _ref.children, |
|
className = _ref.className, |
|
controls = _ref.controls, |
|
_ref$hasArrowIndicato = _ref.hasArrowIndicator, |
|
hasArrowIndicator = _ref$hasArrowIndicato === void 0 ? false : _ref$hasArrowIndicato, |
|
_ref$icon = _ref.icon, |
|
icon = _ref$icon === void 0 ? 'menu' : _ref$icon, |
|
label = _ref.label, |
|
popoverProps = _ref.popoverProps, |
|
toggleProps = _ref.toggleProps, |
|
menuProps = _ref.menuProps, |
|
menuLabel = _ref.menuLabel, |
|
position = _ref.position; |
|
|
|
if (menuLabel) { |
|
external_this_wp_deprecated_default()('`menuLabel` prop in `DropdownComponent`', { |
|
alternative: '`menuProps` object and its `aria-label` property', |
|
plugin: 'Gutenberg' |
|
}); |
|
} |
|
|
|
if (position) { |
|
external_this_wp_deprecated_default()('`position` prop in `DropdownComponent`', { |
|
alternative: '`popoverProps` object and its `position` property', |
|
plugin: 'Gutenberg' |
|
}); |
|
} |
|
|
|
if (Object(external_lodash_["isEmpty"])(controls) && !Object(external_lodash_["isFunction"])(children)) { |
|
return null; |
|
} // Normalize controls to nested array of objects (sets of controls) |
|
|
|
|
|
var controlSets; |
|
|
|
if (!Object(external_lodash_["isEmpty"])(controls)) { |
|
controlSets = controls; |
|
|
|
if (!Array.isArray(controlSets[0])) { |
|
controlSets = [controlSets]; |
|
} |
|
} |
|
|
|
var mergedPopoverProps = mergeProps({ |
|
className: 'components-dropdown-menu__popover', |
|
position: position |
|
}, popoverProps); |
|
return Object(external_this_wp_element_["createElement"])(dropdown, { |
|
className: classnames_default()('components-dropdown-menu', className), |
|
popoverProps: mergedPopoverProps, |
|
renderToggle: function renderToggle(_ref2) { |
|
var isOpen = _ref2.isOpen, |
|
onToggle = _ref2.onToggle; |
|
|
|
var openOnArrowDown = function openOnArrowDown(event) { |
|
if (!isOpen && event.keyCode === external_this_wp_keycodes_["DOWN"]) { |
|
event.preventDefault(); |
|
event.stopPropagation(); |
|
onToggle(); |
|
} |
|
}; |
|
|
|
var mergedToggleProps = mergeProps({ |
|
className: classnames_default()('components-dropdown-menu__toggle', { |
|
'is-opened': isOpen |
|
}), |
|
tooltip: label |
|
}, toggleProps); |
|
return Object(external_this_wp_element_["createElement"])(icon_button, Object(esm_extends["a" /* default */])({}, mergedToggleProps, { |
|
icon: icon, |
|
onClick: onToggle, |
|
onKeyDown: openOnArrowDown, |
|
"aria-haspopup": "true", |
|
"aria-expanded": isOpen, |
|
label: label |
|
}), (!icon || hasArrowIndicator) && Object(external_this_wp_element_["createElement"])("span", { |
|
className: "components-dropdown-menu__indicator" |
|
})); |
|
}, |
|
renderContent: function renderContent(props) { |
|
var mergedMenuProps = mergeProps({ |
|
'aria-label': menuLabel || label, |
|
className: 'components-dropdown-menu__menu' |
|
}, menuProps); |
|
return Object(external_this_wp_element_["createElement"])(menu, Object(esm_extends["a" /* default */])({}, mergedMenuProps, { |
|
role: "menu" |
|
}), Object(external_lodash_["isFunction"])(children) ? children(props) : null, Object(external_lodash_["flatMap"])(controlSets, function (controlSet, indexOfSet) { |
|
return controlSet.map(function (control, indexOfControl) { |
|
return Object(external_this_wp_element_["createElement"])(icon_button, { |
|
key: [indexOfSet, indexOfControl].join(), |
|
onClick: function onClick(event) { |
|
event.stopPropagation(); |
|
props.onClose(); |
|
|
|
if (control.onClick) { |
|
control.onClick(); |
|
} |
|
}, |
|
className: classnames_default()('components-dropdown-menu__menu-item', { |
|
'has-separator': indexOfSet > 0 && indexOfControl === 0, |
|
'is-active': control.isActive |
|
}), |
|
icon: control.icon, |
|
role: "menuitem", |
|
disabled: control.isDisabled |
|
}, control.title); |
|
}); |
|
})); |
|
} |
|
}); |
|
} |
|
|
|
/* harmony default export */ var dropdown_menu = (DropdownMenu); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/external-link/index.js |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
function ExternalLink(_ref, ref) { |
|
var href = _ref.href, |
|
children = _ref.children, |
|
className = _ref.className, |
|
_ref$rel = _ref.rel, |
|
rel = _ref$rel === void 0 ? '' : _ref$rel, |
|
additionalProps = Object(objectWithoutProperties["a" /* default */])(_ref, ["href", "children", "className", "rel"]); |
|
|
|
rel = Object(external_lodash_["uniq"])(Object(external_lodash_["compact"])([].concat(Object(toConsumableArray["a" /* default */])(rel.split(' ')), ['external', 'noreferrer', 'noopener']))).join(' '); |
|
var classes = classnames_default()('components-external-link', className); |
|
return (// eslint-disable-next-line react/jsx-no-target-blank |
|
Object(external_this_wp_element_["createElement"])("a", Object(esm_extends["a" /* default */])({}, additionalProps, { |
|
className: classes, |
|
href: href, |
|
target: "_blank", |
|
rel: rel, |
|
ref: ref |
|
}), children, Object(external_this_wp_element_["createElement"])("span", { |
|
className: "screen-reader-text" |
|
}, |
|
/* translators: accessibility text */ |
|
Object(external_this_wp_i18n_["__"])('(opens in a new tab)')), Object(external_this_wp_element_["createElement"])(dashicon_Dashicon, { |
|
icon: "external", |
|
className: "components-external-link__icon" |
|
})) |
|
); |
|
} |
|
/* harmony default export */ var external_link = (Object(external_this_wp_element_["forwardRef"])(ExternalLink)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/focal-point-picker/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
var TEXTCONTROL_MIN = 0; |
|
var TEXTCONTROL_MAX = 100; |
|
var focal_point_picker_FocalPointPicker = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(FocalPointPicker, _Component); |
|
|
|
function FocalPointPicker(props) { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, FocalPointPicker); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(FocalPointPicker).call(this, props)); |
|
_this.onMouseMove = _this.onMouseMove.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.state = { |
|
isDragging: false, |
|
bounds: {}, |
|
percentages: props.value |
|
}; |
|
_this.containerRef = Object(external_this_wp_element_["createRef"])(); |
|
_this.imageRef = Object(external_this_wp_element_["createRef"])(); |
|
_this.horizontalPositionChanged = _this.horizontalPositionChanged.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.verticalPositionChanged = _this.verticalPositionChanged.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onLoad = _this.onLoad.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(FocalPointPicker, [{ |
|
key: "componentDidUpdate", |
|
value: function componentDidUpdate(prevProps) { |
|
if (prevProps.url !== this.props.url) { |
|
this.setState({ |
|
isDragging: false |
|
}); |
|
} |
|
} |
|
}, { |
|
key: "calculateBounds", |
|
value: function calculateBounds() { |
|
var bounds = { |
|
top: 0, |
|
left: 0, |
|
bottom: 0, |
|
right: 0, |
|
width: 0, |
|
height: 0 |
|
}; |
|
|
|
if (!this.imageRef.current) { |
|
return bounds; |
|
} |
|
|
|
var dimensions = { |
|
width: this.imageRef.current.clientWidth, |
|
height: this.imageRef.current.clientHeight |
|
}; |
|
var pickerDimensions = this.pickerDimensions(); |
|
var widthRatio = pickerDimensions.width / dimensions.width; |
|
var heightRatio = pickerDimensions.height / dimensions.height; |
|
|
|
if (heightRatio >= widthRatio) { |
|
bounds.width = bounds.right = pickerDimensions.width; |
|
bounds.height = dimensions.height * widthRatio; |
|
bounds.top = (pickerDimensions.height - bounds.height) / 2; |
|
bounds.bottom = bounds.top + bounds.height; |
|
} else { |
|
bounds.height = bounds.bottom = pickerDimensions.height; |
|
bounds.width = dimensions.width * heightRatio; |
|
bounds.left = (pickerDimensions.width - bounds.width) / 2; |
|
bounds.right = bounds.left + bounds.width; |
|
} |
|
|
|
return bounds; |
|
} |
|
}, { |
|
key: "onLoad", |
|
value: function onLoad() { |
|
this.setState({ |
|
bounds: this.calculateBounds() |
|
}); |
|
} |
|
}, { |
|
key: "onMouseMove", |
|
value: function onMouseMove(event) { |
|
var _this$state = this.state, |
|
isDragging = _this$state.isDragging, |
|
bounds = _this$state.bounds; |
|
var onChange = this.props.onChange; |
|
|
|
if (isDragging) { |
|
var pickerDimensions = this.pickerDimensions(); |
|
var cursorPosition = { |
|
left: event.pageX - pickerDimensions.left, |
|
top: event.pageY - pickerDimensions.top |
|
}; |
|
var left = Math.max(bounds.left, Math.min(cursorPosition.left, bounds.right)); |
|
var top = Math.max(bounds.top, Math.min(cursorPosition.top, bounds.bottom)); |
|
var percentages = { |
|
x: (left - bounds.left) / (pickerDimensions.width - bounds.left * 2), |
|
y: (top - bounds.top) / (pickerDimensions.height - bounds.top * 2) |
|
}; |
|
this.setState({ |
|
percentages: percentages |
|
}, function () { |
|
onChange({ |
|
x: this.state.percentages.x, |
|
y: this.state.percentages.y |
|
}); |
|
}); |
|
} |
|
} |
|
}, { |
|
key: "fractionToPercentage", |
|
value: function fractionToPercentage(fraction) { |
|
return Math.round(fraction * 100); |
|
} |
|
}, { |
|
key: "horizontalPositionChanged", |
|
value: function horizontalPositionChanged(event) { |
|
this.positionChangeFromTextControl('x', event.target.value); |
|
} |
|
}, { |
|
key: "verticalPositionChanged", |
|
value: function verticalPositionChanged(event) { |
|
this.positionChangeFromTextControl('y', event.target.value); |
|
} |
|
}, { |
|
key: "positionChangeFromTextControl", |
|
value: function positionChangeFromTextControl(axis, value) { |
|
var onChange = this.props.onChange; |
|
var percentages = this.state.percentages; |
|
var cleanValue = Math.max(Math.min(parseInt(value), 100), 0); |
|
percentages[axis] = cleanValue ? cleanValue / 100 : 0; |
|
this.setState({ |
|
percentages: percentages |
|
}, function () { |
|
onChange({ |
|
x: this.state.percentages.x, |
|
y: this.state.percentages.y |
|
}); |
|
}); |
|
} |
|
}, { |
|
key: "pickerDimensions", |
|
value: function pickerDimensions() { |
|
if (this.containerRef.current) { |
|
return { |
|
width: this.containerRef.current.clientWidth, |
|
height: this.containerRef.current.clientHeight, |
|
top: this.containerRef.current.getBoundingClientRect().top + document.body.scrollTop, |
|
left: this.containerRef.current.getBoundingClientRect().left |
|
}; |
|
} |
|
|
|
return { |
|
width: 0, |
|
height: 0, |
|
left: 0, |
|
top: 0 |
|
}; |
|
} |
|
}, { |
|
key: "handleFocusOutside", |
|
value: function handleFocusOutside() { |
|
this.setState({ |
|
isDragging: false |
|
}); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this2 = this; |
|
|
|
var _this$props = this.props, |
|
instanceId = _this$props.instanceId, |
|
url = _this$props.url, |
|
value = _this$props.value, |
|
label = _this$props.label, |
|
help = _this$props.help, |
|
className = _this$props.className; |
|
var _this$state2 = this.state, |
|
bounds = _this$state2.bounds, |
|
isDragging = _this$state2.isDragging, |
|
percentages = _this$state2.percentages; |
|
var pickerDimensions = this.pickerDimensions(); |
|
var iconCoordinates = { |
|
left: value.x * (pickerDimensions.width - bounds.left * 2) + bounds.left, |
|
top: value.y * (pickerDimensions.height - bounds.top * 2) + bounds.top |
|
}; |
|
var iconContainerStyle = { |
|
left: "".concat(iconCoordinates.left, "px"), |
|
top: "".concat(iconCoordinates.top, "px") |
|
}; |
|
var iconContainerClasses = classnames_default()('components-focal-point-picker__icon_container', isDragging ? 'is-dragging' : null); |
|
var id = "inspector-focal-point-picker-control-".concat(instanceId); |
|
var horizontalPositionId = "inspector-focal-point-picker-control-horizontal-position-".concat(instanceId); |
|
var verticalPositionId = "inspector-focal-point-picker-control-vertical-position-".concat(instanceId); |
|
return Object(external_this_wp_element_["createElement"])(base_control, { |
|
label: label, |
|
id: id, |
|
help: help, |
|
className: className |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-focal-point-picker-wrapper" |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-focal-point-picker", |
|
onMouseDown: function onMouseDown() { |
|
return _this2.setState({ |
|
isDragging: true |
|
}); |
|
}, |
|
onDragStart: function onDragStart() { |
|
return _this2.setState({ |
|
isDragging: true |
|
}); |
|
}, |
|
onMouseUp: function onMouseUp() { |
|
return _this2.setState({ |
|
isDragging: false |
|
}); |
|
}, |
|
onDrop: function onDrop() { |
|
return _this2.setState({ |
|
isDragging: false |
|
}); |
|
}, |
|
onMouseMove: this.onMouseMove, |
|
ref: this.containerRef, |
|
role: "button", |
|
tabIndex: "-1" |
|
}, Object(external_this_wp_element_["createElement"])("img", { |
|
alt: "Dimensions helper", |
|
onLoad: this.onLoad, |
|
ref: this.imageRef, |
|
src: url, |
|
draggable: "false" |
|
}), Object(external_this_wp_element_["createElement"])("div", { |
|
className: iconContainerClasses, |
|
style: iconContainerStyle |
|
}, Object(external_this_wp_element_["createElement"])(svg_SVG, { |
|
className: "components-focal-point-picker__icon", |
|
xmlns: "http://www.w3.org/2000/svg", |
|
viewBox: "0 0 30 30" |
|
}, Object(external_this_wp_element_["createElement"])(svg_Path, { |
|
className: "components-focal-point-picker__icon-outline", |
|
d: "M15 1C7.3 1 1 7.3 1 15s6.3 14 14 14 14-6.3 14-14S22.7 1 15 1zm0 22c-4.4 0-8-3.6-8-8s3.6-8 8-8 8 3.6 8 8-3.6 8-8 8z" |
|
}), Object(external_this_wp_element_["createElement"])(svg_Path, { |
|
className: "components-focal-point-picker__icon-fill", |
|
d: "M15 3C8.4 3 3 8.4 3 15s5.4 12 12 12 12-5.4 12-12S21.6 3 15 3zm0 22C9.5 25 5 20.5 5 15S9.5 5 15 5s10 4.5 10 10-4.5 10-10 10z" |
|
}))))), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-focal-point-picker_position-display-container" |
|
}, Object(external_this_wp_element_["createElement"])(base_control, { |
|
label: Object(external_this_wp_i18n_["__"])('Horizontal Pos.'), |
|
id: horizontalPositionId |
|
}, Object(external_this_wp_element_["createElement"])("input", { |
|
className: "components-text-control__input", |
|
id: horizontalPositionId, |
|
max: TEXTCONTROL_MAX, |
|
min: TEXTCONTROL_MIN, |
|
onChange: this.horizontalPositionChanged, |
|
type: "number", |
|
value: this.fractionToPercentage(percentages.x) |
|
}), Object(external_this_wp_element_["createElement"])("span", null, "%")), Object(external_this_wp_element_["createElement"])(base_control, { |
|
label: Object(external_this_wp_i18n_["__"])('Vertical Pos.'), |
|
id: verticalPositionId |
|
}, Object(external_this_wp_element_["createElement"])("input", { |
|
className: "components-text-control__input", |
|
id: verticalPositionId, |
|
max: TEXTCONTROL_MAX, |
|
min: TEXTCONTROL_MIN, |
|
onChange: this.verticalPositionChanged, |
|
type: "number", |
|
value: this.fractionToPercentage(percentages.y) |
|
}), Object(external_this_wp_element_["createElement"])("span", null, "%")))); |
|
} |
|
}]); |
|
|
|
return FocalPointPicker; |
|
}(external_this_wp_element_["Component"]); |
|
focal_point_picker_FocalPointPicker.defaultProps = { |
|
url: null, |
|
value: { |
|
x: 0.5, |
|
y: 0.5 |
|
}, |
|
onChange: function onChange() {} |
|
}; |
|
/* harmony default export */ var focal_point_picker = (Object(external_this_wp_compose_["compose"])([external_this_wp_compose_["withInstanceId"], with_focus_outside])(focal_point_picker_FocalPointPicker)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/focusable-iframe/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Browser dependencies |
|
*/ |
|
|
|
var focusable_iframe_window = window, |
|
FocusEvent = focusable_iframe_window.FocusEvent; |
|
|
|
var focusable_iframe_FocusableIframe = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(FocusableIframe, _Component); |
|
|
|
function FocusableIframe(props) { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, FocusableIframe); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(FocusableIframe).apply(this, arguments)); |
|
_this.checkFocus = _this.checkFocus.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.node = props.iframeRef || Object(external_this_wp_element_["createRef"])(); |
|
return _this; |
|
} |
|
/** |
|
* Checks whether the iframe is the activeElement, inferring that it has |
|
* then received focus, and calls the `onFocus` prop callback. |
|
*/ |
|
|
|
|
|
Object(createClass["a" /* default */])(FocusableIframe, [{ |
|
key: "checkFocus", |
|
value: function checkFocus() { |
|
var iframe = this.node.current; |
|
|
|
if (document.activeElement !== iframe) { |
|
return; |
|
} |
|
|
|
var focusEvent = new FocusEvent('focus', { |
|
bubbles: true |
|
}); |
|
iframe.dispatchEvent(focusEvent); |
|
var onFocus = this.props.onFocus; |
|
|
|
if (onFocus) { |
|
onFocus(focusEvent); |
|
} |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
// Disable reason: The rendered iframe is a pass-through component, |
|
// assigning props inherited from the rendering parent. It's the |
|
// responsibility of the parent to assign a title. |
|
|
|
/* eslint-disable jsx-a11y/iframe-has-title */ |
|
return Object(external_this_wp_element_["createElement"])("iframe", Object(esm_extends["a" /* default */])({ |
|
ref: this.node |
|
}, Object(external_lodash_["omit"])(this.props, ['iframeRef', 'onFocus']))); |
|
/* eslint-enable jsx-a11y/iframe-has-title */ |
|
} |
|
}]); |
|
|
|
return FocusableIframe; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var focusable_iframe = (Object(external_this_wp_compose_["withGlobalEvents"])({ |
|
blur: 'checkFocus' |
|
})(focusable_iframe_FocusableIframe)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/range-control/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
function RangeControl(_ref) { |
|
var className = _ref.className, |
|
currentInput = _ref.currentInput, |
|
label = _ref.label, |
|
value = _ref.value, |
|
instanceId = _ref.instanceId, |
|
onChange = _ref.onChange, |
|
beforeIcon = _ref.beforeIcon, |
|
afterIcon = _ref.afterIcon, |
|
help = _ref.help, |
|
allowReset = _ref.allowReset, |
|
initialPosition = _ref.initialPosition, |
|
min = _ref.min, |
|
max = _ref.max, |
|
setState = _ref.setState, |
|
props = Object(objectWithoutProperties["a" /* default */])(_ref, ["className", "currentInput", "label", "value", "instanceId", "onChange", "beforeIcon", "afterIcon", "help", "allowReset", "initialPosition", "min", "max", "setState"]); |
|
|
|
var id = "inspector-range-control-".concat(instanceId); |
|
var currentInputValue = currentInput === null ? value : currentInput; |
|
|
|
var resetValue = function resetValue() { |
|
resetCurrentInput(); |
|
onChange(); |
|
}; |
|
|
|
var resetCurrentInput = function resetCurrentInput() { |
|
if (currentInput !== null) { |
|
setState({ |
|
currentInput: null |
|
}); |
|
} |
|
}; |
|
|
|
var onChangeValue = function onChangeValue(event) { |
|
var newValue = event.target.value; // If the input value is invalid temporarily save it to the state, |
|
// without calling on change. |
|
|
|
if (!event.target.checkValidity()) { |
|
setState({ |
|
currentInput: newValue |
|
}); |
|
return; |
|
} // The input is valid, reset the local state property used to temporaly save the value, |
|
// and call onChange with the new value as a number. |
|
|
|
|
|
resetCurrentInput(); |
|
onChange(newValue === '' ? undefined : parseFloat(newValue)); |
|
}; |
|
|
|
var initialSliderValue = Object(external_lodash_["isFinite"])(currentInputValue) ? currentInputValue : initialPosition || ''; |
|
return Object(external_this_wp_element_["createElement"])(base_control, { |
|
label: label, |
|
id: id, |
|
help: help, |
|
className: classnames_default()('components-range-control', className) |
|
}, beforeIcon && Object(external_this_wp_element_["createElement"])(dashicon_Dashicon, { |
|
icon: beforeIcon |
|
}), Object(external_this_wp_element_["createElement"])("input", Object(esm_extends["a" /* default */])({ |
|
className: "components-range-control__slider", |
|
id: id, |
|
type: "range", |
|
value: initialSliderValue, |
|
onChange: onChangeValue, |
|
"aria-describedby": !!help ? id + '__help' : undefined, |
|
min: min, |
|
max: max |
|
}, props)), afterIcon && Object(external_this_wp_element_["createElement"])(dashicon_Dashicon, { |
|
icon: afterIcon |
|
}), Object(external_this_wp_element_["createElement"])("input", Object(esm_extends["a" /* default */])({ |
|
className: "components-range-control__number", |
|
type: "number", |
|
onChange: onChangeValue, |
|
"aria-label": label, |
|
value: currentInputValue, |
|
min: min, |
|
max: max, |
|
onBlur: resetCurrentInput |
|
}, props)), allowReset && Object(external_this_wp_element_["createElement"])(build_module_button, { |
|
onClick: resetValue, |
|
disabled: value === undefined, |
|
isSmall: true, |
|
isDefault: true, |
|
className: "components-range-control__reset" |
|
}, Object(external_this_wp_i18n_["__"])('Reset'))); |
|
} |
|
|
|
/* harmony default export */ var range_control = (Object(external_this_wp_compose_["compose"])([external_this_wp_compose_["withInstanceId"], Object(external_this_wp_compose_["withState"])({ |
|
currentInput: null |
|
})])(RangeControl)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/select-control/index.js |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
function SelectControl(_ref) { |
|
var help = _ref.help, |
|
instanceId = _ref.instanceId, |
|
label = _ref.label, |
|
_ref$multiple = _ref.multiple, |
|
multiple = _ref$multiple === void 0 ? false : _ref$multiple, |
|
onChange = _ref.onChange, |
|
_ref$options = _ref.options, |
|
options = _ref$options === void 0 ? [] : _ref$options, |
|
className = _ref.className, |
|
hideLabelFromVision = _ref.hideLabelFromVision, |
|
props = Object(objectWithoutProperties["a" /* default */])(_ref, ["help", "instanceId", "label", "multiple", "onChange", "options", "className", "hideLabelFromVision"]); |
|
|
|
var id = "inspector-select-control-".concat(instanceId); |
|
|
|
var onChangeValue = function onChangeValue(event) { |
|
if (multiple) { |
|
var selectedOptions = Object(toConsumableArray["a" /* default */])(event.target.options).filter(function (_ref2) { |
|
var selected = _ref2.selected; |
|
return selected; |
|
}); |
|
|
|
var newValues = selectedOptions.map(function (_ref3) { |
|
var value = _ref3.value; |
|
return value; |
|
}); |
|
onChange(newValues); |
|
return; |
|
} |
|
|
|
onChange(event.target.value); |
|
}; // Disable reason: A select with an onchange throws a warning |
|
|
|
/* eslint-disable jsx-a11y/no-onchange */ |
|
|
|
|
|
return !Object(external_lodash_["isEmpty"])(options) && Object(external_this_wp_element_["createElement"])(base_control, { |
|
label: label, |
|
hideLabelFromVision: hideLabelFromVision, |
|
id: id, |
|
help: help, |
|
className: className |
|
}, Object(external_this_wp_element_["createElement"])("select", Object(esm_extends["a" /* default */])({ |
|
id: id, |
|
className: "components-select-control__input", |
|
onChange: onChangeValue, |
|
"aria-describedby": !!help ? "".concat(id, "__help") : undefined, |
|
multiple: multiple |
|
}, props), options.map(function (option, index) { |
|
return Object(external_this_wp_element_["createElement"])("option", { |
|
key: "".concat(option.label, "-").concat(option.value, "-").concat(index), |
|
value: option.value, |
|
disabled: option.disabled |
|
}, option.label); |
|
}))); |
|
/* eslint-enable jsx-a11y/no-onchange */ |
|
} |
|
|
|
/* harmony default export */ var select_control = (Object(external_this_wp_compose_["withInstanceId"])(SelectControl)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/font-size-picker/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
function getSelectValueFromFontSize(fontSizes, value) { |
|
if (value) { |
|
var fontSizeValue = fontSizes.find(function (font) { |
|
return font.size === value; |
|
}); |
|
return fontSizeValue ? fontSizeValue.slug : 'custom'; |
|
} |
|
|
|
return 'normal'; |
|
} |
|
|
|
function getSelectOptions(optionsArray) { |
|
return [].concat(Object(toConsumableArray["a" /* default */])(optionsArray.map(function (option) { |
|
return { |
|
value: option.slug, |
|
label: option.name |
|
}; |
|
})), [{ |
|
value: 'custom', |
|
label: Object(external_this_wp_i18n_["__"])('Custom') |
|
}]); |
|
} |
|
|
|
function FontSizePicker(_ref) { |
|
var fallbackFontSize = _ref.fallbackFontSize, |
|
_ref$fontSizes = _ref.fontSizes, |
|
fontSizes = _ref$fontSizes === void 0 ? [] : _ref$fontSizes, |
|
_ref$disableCustomFon = _ref.disableCustomFontSizes, |
|
disableCustomFontSizes = _ref$disableCustomFon === void 0 ? false : _ref$disableCustomFon, |
|
onChange = _ref.onChange, |
|
value = _ref.value, |
|
_ref$withSlider = _ref.withSlider, |
|
withSlider = _ref$withSlider === void 0 ? false : _ref$withSlider; |
|
|
|
var _useState = Object(external_this_wp_element_["useState"])(getSelectValueFromFontSize(fontSizes, value)), |
|
_useState2 = Object(slicedToArray["a" /* default */])(_useState, 2), |
|
currentSelectValue = _useState2[0], |
|
setCurrentSelectValue = _useState2[1]; |
|
|
|
if (disableCustomFontSizes && !fontSizes.length) { |
|
return null; |
|
} |
|
|
|
var onChangeValue = function onChangeValue(event) { |
|
var newValue = event.target.value; |
|
setCurrentSelectValue(getSelectValueFromFontSize(fontSizes, Number(newValue))); |
|
|
|
if (newValue === '') { |
|
onChange(undefined); |
|
return; |
|
} |
|
|
|
onChange(Number(newValue)); |
|
}; |
|
|
|
var onSelectChangeValue = function onSelectChangeValue(eventValue) { |
|
setCurrentSelectValue(eventValue); |
|
var selectedFont = fontSizes.find(function (font) { |
|
return font.slug === eventValue; |
|
}); |
|
|
|
if (selectedFont) { |
|
onChange(selectedFont.size); |
|
} |
|
}; |
|
|
|
return Object(external_this_wp_element_["createElement"])("fieldset", null, Object(external_this_wp_element_["createElement"])("legend", null, Object(external_this_wp_i18n_["__"])('Font Size')), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-font-size-picker__controls" |
|
}, fontSizes.length > 0 && Object(external_this_wp_element_["createElement"])(select_control, { |
|
className: 'components-font-size-picker__select', |
|
label: 'Choose preset', |
|
hideLabelFromVision: true, |
|
value: currentSelectValue, |
|
onChange: onSelectChangeValue, |
|
options: getSelectOptions(fontSizes) |
|
}), !withSlider && !disableCustomFontSizes && Object(external_this_wp_element_["createElement"])("input", { |
|
className: "components-range-control__number", |
|
type: "number", |
|
onChange: onChangeValue, |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Custom'), |
|
value: value || '' |
|
}), Object(external_this_wp_element_["createElement"])(build_module_button, { |
|
className: "components-color-palette__clear", |
|
type: "button", |
|
disabled: value === undefined, |
|
onClick: function onClick() { |
|
onChange(undefined); |
|
setCurrentSelectValue(getSelectValueFromFontSize(fontSizes, undefined)); |
|
}, |
|
isSmall: true, |
|
isDefault: true |
|
}, Object(external_this_wp_i18n_["__"])('Reset'))), withSlider && Object(external_this_wp_element_["createElement"])(range_control, { |
|
className: "components-font-size-picker__custom-input", |
|
label: Object(external_this_wp_i18n_["__"])('Custom Size'), |
|
value: value || '', |
|
initialPosition: fallbackFontSize, |
|
onChange: onChange, |
|
min: 12, |
|
max: 100, |
|
beforeIcon: "editor-textcolor", |
|
afterIcon: "editor-textcolor" |
|
})); |
|
} |
|
|
|
/* harmony default export */ var font_size_picker = (FontSizePicker); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/form-file-upload/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
var form_file_upload_FormFileUpload = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(FormFileUpload, _Component); |
|
|
|
function FormFileUpload() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, FormFileUpload); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(FormFileUpload).apply(this, arguments)); |
|
_this.openFileDialog = _this.openFileDialog.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.bindInput = _this.bindInput.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(FormFileUpload, [{ |
|
key: "openFileDialog", |
|
value: function openFileDialog() { |
|
this.input.click(); |
|
} |
|
}, { |
|
key: "bindInput", |
|
value: function bindInput(ref) { |
|
this.input = ref; |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
accept = _this$props.accept, |
|
children = _this$props.children, |
|
_this$props$icon = _this$props.icon, |
|
icon = _this$props$icon === void 0 ? 'upload' : _this$props$icon, |
|
_this$props$multiple = _this$props.multiple, |
|
multiple = _this$props$multiple === void 0 ? false : _this$props$multiple, |
|
onChange = _this$props.onChange, |
|
render = _this$props.render, |
|
props = Object(objectWithoutProperties["a" /* default */])(_this$props, ["accept", "children", "icon", "multiple", "onChange", "render"]); |
|
|
|
var ui = render ? render({ |
|
openFileDialog: this.openFileDialog |
|
}) : Object(external_this_wp_element_["createElement"])(icon_button, Object(esm_extends["a" /* default */])({ |
|
icon: icon, |
|
onClick: this.openFileDialog |
|
}, props), children); |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-form-file-upload" |
|
}, ui, Object(external_this_wp_element_["createElement"])("input", { |
|
type: "file", |
|
ref: this.bindInput, |
|
multiple: multiple, |
|
style: { |
|
display: 'none' |
|
}, |
|
accept: accept, |
|
onChange: onChange |
|
})); |
|
} |
|
}]); |
|
|
|
return FormFileUpload; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var form_file_upload = (form_file_upload_FormFileUpload); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/form-toggle/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
function FormToggle(_ref) { |
|
var className = _ref.className, |
|
checked = _ref.checked, |
|
id = _ref.id, |
|
_ref$onChange = _ref.onChange, |
|
onChange = _ref$onChange === void 0 ? external_lodash_["noop"] : _ref$onChange, |
|
props = Object(objectWithoutProperties["a" /* default */])(_ref, ["className", "checked", "id", "onChange"]); |
|
|
|
var wrapperClasses = classnames_default()('components-form-toggle', className, { |
|
'is-checked': checked |
|
}); |
|
return Object(external_this_wp_element_["createElement"])("span", { |
|
className: wrapperClasses |
|
}, Object(external_this_wp_element_["createElement"])("input", Object(esm_extends["a" /* default */])({ |
|
className: "components-form-toggle__input", |
|
id: id, |
|
type: "checkbox", |
|
checked: checked, |
|
onChange: onChange |
|
}, props)), Object(external_this_wp_element_["createElement"])("span", { |
|
className: "components-form-toggle__track" |
|
}), Object(external_this_wp_element_["createElement"])("span", { |
|
className: "components-form-toggle__thumb" |
|
}), checked ? Object(external_this_wp_element_["createElement"])(svg_SVG, { |
|
className: "components-form-toggle__on", |
|
width: "2", |
|
height: "6", |
|
xmlns: "http://www.w3.org/2000/svg", |
|
viewBox: "0 0 2 6" |
|
}, Object(external_this_wp_element_["createElement"])(svg_Path, { |
|
d: "M0 0h2v6H0z" |
|
})) : Object(external_this_wp_element_["createElement"])(svg_SVG, { |
|
className: "components-form-toggle__off", |
|
width: "6", |
|
height: "6", |
|
"aria-hidden": "true", |
|
role: "img", |
|
focusable: "false", |
|
xmlns: "http://www.w3.org/2000/svg", |
|
viewBox: "0 0 6 6" |
|
}, Object(external_this_wp_element_["createElement"])(svg_Path, { |
|
d: "M3 1.5c.8 0 1.5.7 1.5 1.5S3.8 4.5 3 4.5 1.5 3.8 1.5 3 2.2 1.5 3 1.5M3 0C1.3 0 0 1.3 0 3s1.3 3 3 3 3-1.3 3-3-1.3-3-3-3z" |
|
}))); |
|
} |
|
|
|
/* harmony default export */ var form_toggle = (FormToggle); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js |
|
var esm_typeof = __webpack_require__(31); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/form-token-field/token.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
function Token(_ref) { |
|
var value = _ref.value, |
|
status = _ref.status, |
|
title = _ref.title, |
|
displayTransform = _ref.displayTransform, |
|
_ref$isBorderless = _ref.isBorderless, |
|
isBorderless = _ref$isBorderless === void 0 ? false : _ref$isBorderless, |
|
_ref$disabled = _ref.disabled, |
|
disabled = _ref$disabled === void 0 ? false : _ref$disabled, |
|
_ref$onClickRemove = _ref.onClickRemove, |
|
onClickRemove = _ref$onClickRemove === void 0 ? external_lodash_["noop"] : _ref$onClickRemove, |
|
onMouseEnter = _ref.onMouseEnter, |
|
onMouseLeave = _ref.onMouseLeave, |
|
messages = _ref.messages, |
|
termPosition = _ref.termPosition, |
|
termsCount = _ref.termsCount, |
|
instanceId = _ref.instanceId; |
|
var tokenClasses = classnames_default()('components-form-token-field__token', { |
|
'is-error': 'error' === status, |
|
'is-success': 'success' === status, |
|
'is-validating': 'validating' === status, |
|
'is-borderless': isBorderless, |
|
'is-disabled': disabled |
|
}); |
|
|
|
var onClick = function onClick() { |
|
return onClickRemove({ |
|
value: value |
|
}); |
|
}; |
|
|
|
var transformedValue = displayTransform(value); |
|
var termPositionAndCount = Object(external_this_wp_i18n_["sprintf"])( |
|
/* translators: 1: term name, 2: term position in a set of terms, 3: total term set count. */ |
|
Object(external_this_wp_i18n_["__"])('%1$s (%2$s of %3$s)'), transformedValue, termPosition, termsCount); |
|
return Object(external_this_wp_element_["createElement"])("span", { |
|
className: tokenClasses, |
|
onMouseEnter: onMouseEnter, |
|
onMouseLeave: onMouseLeave, |
|
title: title |
|
}, Object(external_this_wp_element_["createElement"])("span", { |
|
className: "components-form-token-field__token-text", |
|
id: "components-form-token-field__token-text-".concat(instanceId) |
|
}, Object(external_this_wp_element_["createElement"])("span", { |
|
className: "screen-reader-text" |
|
}, termPositionAndCount), Object(external_this_wp_element_["createElement"])("span", { |
|
"aria-hidden": "true" |
|
}, transformedValue)), Object(external_this_wp_element_["createElement"])(icon_button, { |
|
className: "components-form-token-field__remove-token", |
|
icon: "dismiss", |
|
onClick: !disabled && onClick, |
|
label: messages.remove, |
|
"aria-describedby": "components-form-token-field__token-text-".concat(instanceId) |
|
})); |
|
} |
|
|
|
/* harmony default export */ var form_token_field_token = (Object(external_this_wp_compose_["withInstanceId"])(Token)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/form-token-field/token-input.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
var token_input_TokenInput = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(TokenInput, _Component); |
|
|
|
function TokenInput() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, TokenInput); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(TokenInput).apply(this, arguments)); |
|
_this.onChange = _this.onChange.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.bindInput = _this.bindInput.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(TokenInput, [{ |
|
key: "focus", |
|
value: function focus() { |
|
this.input.focus(); |
|
} |
|
}, { |
|
key: "hasFocus", |
|
value: function hasFocus() { |
|
return this.input === document.activeElement; |
|
} |
|
}, { |
|
key: "bindInput", |
|
value: function bindInput(ref) { |
|
this.input = ref; |
|
} |
|
}, { |
|
key: "onChange", |
|
value: function onChange(event) { |
|
this.props.onChange({ |
|
value: event.target.value |
|
}); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
value = _this$props.value, |
|
isExpanded = _this$props.isExpanded, |
|
instanceId = _this$props.instanceId, |
|
selectedSuggestionIndex = _this$props.selectedSuggestionIndex, |
|
props = Object(objectWithoutProperties["a" /* default */])(_this$props, ["value", "isExpanded", "instanceId", "selectedSuggestionIndex"]); |
|
|
|
var size = value.length + 1; |
|
return Object(external_this_wp_element_["createElement"])("input", Object(esm_extends["a" /* default */])({ |
|
ref: this.bindInput, |
|
id: "components-form-token-input-".concat(instanceId), |
|
type: "text" |
|
}, props, { |
|
value: value, |
|
onChange: this.onChange, |
|
size: size, |
|
className: "components-form-token-field__input", |
|
role: "combobox", |
|
"aria-expanded": isExpanded, |
|
"aria-autocomplete": "list", |
|
"aria-owns": isExpanded ? "components-form-token-suggestions-".concat(instanceId) : undefined, |
|
"aria-activedescendant": selectedSuggestionIndex !== -1 ? "components-form-token-suggestions-".concat(instanceId, "-").concat(selectedSuggestionIndex) : undefined, |
|
"aria-describedby": "components-form-token-suggestions-howto-".concat(instanceId) |
|
})); |
|
} |
|
}]); |
|
|
|
return TokenInput; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var token_input = (token_input_TokenInput); |
|
|
|
// EXTERNAL MODULE: ./node_modules/dom-scroll-into-view/lib/index.js |
|
var lib = __webpack_require__(68); |
|
var lib_default = /*#__PURE__*/__webpack_require__.n(lib); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/form-token-field/suggestions-list.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
var suggestions_list_SuggestionsList = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(SuggestionsList, _Component); |
|
|
|
function SuggestionsList() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, SuggestionsList); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(SuggestionsList).apply(this, arguments)); |
|
_this.handleMouseDown = _this.handleMouseDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.bindList = _this.bindList.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(SuggestionsList, [{ |
|
key: "componentDidUpdate", |
|
value: function componentDidUpdate() { |
|
var _this2 = this; |
|
|
|
// only have to worry about scrolling selected suggestion into view |
|
// when already expanded |
|
if (this.props.selectedIndex > -1 && this.props.scrollIntoView) { |
|
this.scrollingIntoView = true; |
|
lib_default()(this.list.children[this.props.selectedIndex], this.list, { |
|
onlyScrollIfNeeded: true |
|
}); |
|
this.props.setTimeout(function () { |
|
_this2.scrollingIntoView = false; |
|
}, 100); |
|
} |
|
} |
|
}, { |
|
key: "bindList", |
|
value: function bindList(ref) { |
|
this.list = ref; |
|
} |
|
}, { |
|
key: "handleHover", |
|
value: function handleHover(suggestion) { |
|
var _this3 = this; |
|
|
|
return function () { |
|
if (!_this3.scrollingIntoView) { |
|
_this3.props.onHover(suggestion); |
|
} |
|
}; |
|
} |
|
}, { |
|
key: "handleClick", |
|
value: function handleClick(suggestion) { |
|
var _this4 = this; |
|
|
|
return function () { |
|
_this4.props.onSelect(suggestion); |
|
}; |
|
} |
|
}, { |
|
key: "handleMouseDown", |
|
value: function handleMouseDown(e) { |
|
// By preventing default here, we will not lose focus of <input> when clicking a suggestion |
|
e.preventDefault(); |
|
} |
|
}, { |
|
key: "computeSuggestionMatch", |
|
value: function computeSuggestionMatch(suggestion) { |
|
var match = this.props.displayTransform(this.props.match || '').toLocaleLowerCase(); |
|
|
|
if (match.length === 0) { |
|
return null; |
|
} |
|
|
|
suggestion = this.props.displayTransform(suggestion); |
|
var indexOfMatch = suggestion.toLocaleLowerCase().indexOf(match); |
|
return { |
|
suggestionBeforeMatch: suggestion.substring(0, indexOfMatch), |
|
suggestionMatch: suggestion.substring(indexOfMatch, indexOfMatch + match.length), |
|
suggestionAfterMatch: suggestion.substring(indexOfMatch + match.length) |
|
}; |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this5 = this; |
|
|
|
// We set `tabIndex` here because otherwise Firefox sets focus on this |
|
// div when tabbing off of the input in `TokenField` -- not really sure |
|
// why, since usually a div isn't focusable by default |
|
// TODO does this still apply now that it's a <ul> and not a <div>? |
|
return Object(external_this_wp_element_["createElement"])("ul", { |
|
ref: this.bindList, |
|
className: "components-form-token-field__suggestions-list", |
|
id: "components-form-token-suggestions-".concat(this.props.instanceId), |
|
role: "listbox" |
|
}, Object(external_lodash_["map"])(this.props.suggestions, function (suggestion, index) { |
|
var match = _this5.computeSuggestionMatch(suggestion); |
|
|
|
var classeName = classnames_default()('components-form-token-field__suggestion', { |
|
'is-selected': index === _this5.props.selectedIndex |
|
}); |
|
/* eslint-disable jsx-a11y/click-events-have-key-events */ |
|
|
|
return Object(external_this_wp_element_["createElement"])("li", { |
|
id: "components-form-token-suggestions-".concat(_this5.props.instanceId, "-").concat(index), |
|
role: "option", |
|
className: classeName, |
|
key: suggestion, |
|
onMouseDown: _this5.handleMouseDown, |
|
onClick: _this5.handleClick(suggestion), |
|
onMouseEnter: _this5.handleHover(suggestion), |
|
"aria-selected": index === _this5.props.selectedIndex |
|
}, match ? Object(external_this_wp_element_["createElement"])("span", { |
|
"aria-label": _this5.props.displayTransform(suggestion) |
|
}, match.suggestionBeforeMatch, Object(external_this_wp_element_["createElement"])("strong", { |
|
className: "components-form-token-field__suggestion-match" |
|
}, match.suggestionMatch), match.suggestionAfterMatch) : _this5.props.displayTransform(suggestion)); |
|
/* eslint-enable jsx-a11y/click-events-have-key-events */ |
|
})); |
|
} |
|
}]); |
|
|
|
return SuggestionsList; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
suggestions_list_SuggestionsList.defaultProps = { |
|
match: '', |
|
onHover: function onHover() {}, |
|
onSelect: function onSelect() {}, |
|
suggestions: Object.freeze([]) |
|
}; |
|
/* harmony default export */ var suggestions_list = (Object(external_this_wp_compose_["withSafeTimeout"])(suggestions_list_SuggestionsList)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/form-token-field/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
var initialState = { |
|
incompleteTokenValue: '', |
|
inputOffsetFromEnd: 0, |
|
isActive: false, |
|
isExpanded: false, |
|
selectedSuggestionIndex: -1, |
|
selectedSuggestionScroll: false |
|
}; |
|
|
|
var form_token_field_FormTokenField = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(FormTokenField, _Component); |
|
|
|
function FormTokenField() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, FormTokenField); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(FormTokenField).apply(this, arguments)); |
|
_this.state = initialState; |
|
_this.onKeyDown = _this.onKeyDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onKeyPress = _this.onKeyPress.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onFocus = _this.onFocus.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onBlur = _this.onBlur.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.deleteTokenBeforeInput = _this.deleteTokenBeforeInput.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.deleteTokenAfterInput = _this.deleteTokenAfterInput.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.addCurrentToken = _this.addCurrentToken.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onContainerTouched = _this.onContainerTouched.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.renderToken = _this.renderToken.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onTokenClickRemove = _this.onTokenClickRemove.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onSuggestionHovered = _this.onSuggestionHovered.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onSuggestionSelected = _this.onSuggestionSelected.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onInputChange = _this.onInputChange.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.bindInput = _this.bindInput.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.bindTokensAndInput = _this.bindTokensAndInput.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.updateSuggestions = _this.updateSuggestions.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(FormTokenField, [{ |
|
key: "componentDidUpdate", |
|
value: function componentDidUpdate(prevProps) { |
|
// Make sure to focus the input when the isActive state is true. |
|
if (this.state.isActive && !this.input.hasFocus()) { |
|
this.input.focus(); |
|
} |
|
|
|
var _this$props = this.props, |
|
suggestions = _this$props.suggestions, |
|
value = _this$props.value; |
|
var suggestionsDidUpdate = !external_this_wp_isShallowEqual_default()(suggestions, prevProps.suggestions); |
|
|
|
if (suggestionsDidUpdate || value !== prevProps.value) { |
|
this.updateSuggestions(suggestionsDidUpdate); |
|
} |
|
} |
|
}, { |
|
key: "bindInput", |
|
value: function bindInput(ref) { |
|
this.input = ref; |
|
} |
|
}, { |
|
key: "bindTokensAndInput", |
|
value: function bindTokensAndInput(ref) { |
|
this.tokensAndInput = ref; |
|
} |
|
}, { |
|
key: "onFocus", |
|
value: function onFocus(event) { |
|
// If focus is on the input or on the container, set the isActive state to true. |
|
if (this.input.hasFocus() || event.target === this.tokensAndInput) { |
|
this.setState({ |
|
isActive: true |
|
}); |
|
} else { |
|
/* |
|
* Otherwise, focus is on one of the token "remove" buttons and we |
|
* set the isActive state to false to prevent the input to be |
|
* re-focused, see componentDidUpdate(). |
|
*/ |
|
this.setState({ |
|
isActive: false |
|
}); |
|
} |
|
|
|
if ('function' === typeof this.props.onFocus) { |
|
this.props.onFocus(event); |
|
} |
|
} |
|
}, { |
|
key: "onBlur", |
|
value: function onBlur() { |
|
if (this.inputHasValidValue()) { |
|
this.setState({ |
|
isActive: false |
|
}); |
|
} else { |
|
this.setState(initialState); |
|
} |
|
} |
|
}, { |
|
key: "onKeyDown", |
|
value: function onKeyDown(event) { |
|
var preventDefault = false; |
|
|
|
switch (event.keyCode) { |
|
case external_this_wp_keycodes_["BACKSPACE"]: |
|
preventDefault = this.handleDeleteKey(this.deleteTokenBeforeInput); |
|
break; |
|
|
|
case external_this_wp_keycodes_["ENTER"]: |
|
preventDefault = this.addCurrentToken(); |
|
break; |
|
|
|
case external_this_wp_keycodes_["LEFT"]: |
|
preventDefault = this.handleLeftArrowKey(); |
|
break; |
|
|
|
case external_this_wp_keycodes_["UP"]: |
|
preventDefault = this.handleUpArrowKey(); |
|
break; |
|
|
|
case external_this_wp_keycodes_["RIGHT"]: |
|
preventDefault = this.handleRightArrowKey(); |
|
break; |
|
|
|
case external_this_wp_keycodes_["DOWN"]: |
|
preventDefault = this.handleDownArrowKey(); |
|
break; |
|
|
|
case external_this_wp_keycodes_["DELETE"]: |
|
preventDefault = this.handleDeleteKey(this.deleteTokenAfterInput); |
|
break; |
|
|
|
case external_this_wp_keycodes_["SPACE"]: |
|
if (this.props.tokenizeOnSpace) { |
|
preventDefault = this.addCurrentToken(); |
|
} |
|
|
|
break; |
|
|
|
case external_this_wp_keycodes_["ESCAPE"]: |
|
preventDefault = this.handleEscapeKey(event); |
|
event.stopPropagation(); |
|
break; |
|
|
|
default: |
|
break; |
|
} |
|
|
|
if (preventDefault) { |
|
event.preventDefault(); |
|
} |
|
} |
|
}, { |
|
key: "onKeyPress", |
|
value: function onKeyPress(event) { |
|
var preventDefault = false; |
|
|
|
switch (event.charCode) { |
|
case 44: |
|
// comma |
|
preventDefault = this.handleCommaKey(); |
|
break; |
|
|
|
default: |
|
break; |
|
} |
|
|
|
if (preventDefault) { |
|
event.preventDefault(); |
|
} |
|
} |
|
}, { |
|
key: "onContainerTouched", |
|
value: function onContainerTouched(event) { |
|
// Prevent clicking/touching the tokensAndInput container from blurring |
|
// the input and adding the current token. |
|
if (event.target === this.tokensAndInput && this.state.isActive) { |
|
event.preventDefault(); |
|
} |
|
} |
|
}, { |
|
key: "onTokenClickRemove", |
|
value: function onTokenClickRemove(event) { |
|
this.deleteToken(event.value); |
|
this.input.focus(); |
|
} |
|
}, { |
|
key: "onSuggestionHovered", |
|
value: function onSuggestionHovered(suggestion) { |
|
var index = this.getMatchingSuggestions().indexOf(suggestion); |
|
|
|
if (index >= 0) { |
|
this.setState({ |
|
selectedSuggestionIndex: index, |
|
selectedSuggestionScroll: false |
|
}); |
|
} |
|
} |
|
}, { |
|
key: "onSuggestionSelected", |
|
value: function onSuggestionSelected(suggestion) { |
|
this.addNewToken(suggestion); |
|
} |
|
}, { |
|
key: "onInputChange", |
|
value: function onInputChange(event) { |
|
var text = event.value; |
|
var separator = this.props.tokenizeOnSpace ? /[ ,\t]+/ : /[,\t]+/; |
|
var items = text.split(separator); |
|
var tokenValue = Object(external_lodash_["last"])(items) || ''; |
|
|
|
if (items.length > 1) { |
|
this.addNewTokens(items.slice(0, -1)); |
|
} |
|
|
|
this.setState({ |
|
incompleteTokenValue: tokenValue |
|
}, this.updateSuggestions); |
|
this.props.onInputChange(tokenValue); |
|
} |
|
}, { |
|
key: "handleDeleteKey", |
|
value: function handleDeleteKey(deleteToken) { |
|
var preventDefault = false; |
|
|
|
if (this.input.hasFocus() && this.isInputEmpty()) { |
|
deleteToken(); |
|
preventDefault = true; |
|
} |
|
|
|
return preventDefault; |
|
} |
|
}, { |
|
key: "handleLeftArrowKey", |
|
value: function handleLeftArrowKey() { |
|
var preventDefault = false; |
|
|
|
if (this.isInputEmpty()) { |
|
this.moveInputBeforePreviousToken(); |
|
preventDefault = true; |
|
} |
|
|
|
return preventDefault; |
|
} |
|
}, { |
|
key: "handleRightArrowKey", |
|
value: function handleRightArrowKey() { |
|
var preventDefault = false; |
|
|
|
if (this.isInputEmpty()) { |
|
this.moveInputAfterNextToken(); |
|
preventDefault = true; |
|
} |
|
|
|
return preventDefault; |
|
} |
|
}, { |
|
key: "handleUpArrowKey", |
|
value: function handleUpArrowKey() { |
|
var _this2 = this; |
|
|
|
this.setState(function (state, props) { |
|
return { |
|
selectedSuggestionIndex: (state.selectedSuggestionIndex === 0 ? _this2.getMatchingSuggestions(state.incompleteTokenValue, props.suggestions, props.value, props.maxSuggestions, props.saveTransform).length : state.selectedSuggestionIndex) - 1, |
|
selectedSuggestionScroll: true |
|
}; |
|
}); |
|
return true; // preventDefault |
|
} |
|
}, { |
|
key: "handleDownArrowKey", |
|
value: function handleDownArrowKey() { |
|
var _this3 = this; |
|
|
|
this.setState(function (state, props) { |
|
return { |
|
selectedSuggestionIndex: (state.selectedSuggestionIndex + 1) % _this3.getMatchingSuggestions(state.incompleteTokenValue, props.suggestions, props.value, props.maxSuggestions, props.saveTransform).length, |
|
selectedSuggestionScroll: true |
|
}; |
|
}); |
|
return true; // preventDefault |
|
} |
|
}, { |
|
key: "handleEscapeKey", |
|
value: function handleEscapeKey(event) { |
|
this.setState({ |
|
incompleteTokenValue: event.target.value, |
|
isExpanded: false, |
|
selectedSuggestionIndex: -1, |
|
selectedSuggestionScroll: false |
|
}); |
|
return true; // preventDefault |
|
} |
|
}, { |
|
key: "handleCommaKey", |
|
value: function handleCommaKey() { |
|
if (this.inputHasValidValue()) { |
|
this.addNewToken(this.state.incompleteTokenValue); |
|
} |
|
|
|
return true; // preventDefault |
|
} |
|
}, { |
|
key: "moveInputToIndex", |
|
value: function moveInputToIndex(index) { |
|
this.setState(function (state, props) { |
|
return { |
|
inputOffsetFromEnd: props.value.length - Math.max(index, -1) - 1 |
|
}; |
|
}); |
|
} |
|
}, { |
|
key: "moveInputBeforePreviousToken", |
|
value: function moveInputBeforePreviousToken() { |
|
this.setState(function (state, props) { |
|
return { |
|
inputOffsetFromEnd: Math.min(state.inputOffsetFromEnd + 1, props.value.length) |
|
}; |
|
}); |
|
} |
|
}, { |
|
key: "moveInputAfterNextToken", |
|
value: function moveInputAfterNextToken() { |
|
this.setState(function (state) { |
|
return { |
|
inputOffsetFromEnd: Math.max(state.inputOffsetFromEnd - 1, 0) |
|
}; |
|
}); |
|
} |
|
}, { |
|
key: "deleteTokenBeforeInput", |
|
value: function deleteTokenBeforeInput() { |
|
var index = this.getIndexOfInput() - 1; |
|
|
|
if (index > -1) { |
|
this.deleteToken(this.props.value[index]); |
|
} |
|
} |
|
}, { |
|
key: "deleteTokenAfterInput", |
|
value: function deleteTokenAfterInput() { |
|
var index = this.getIndexOfInput(); |
|
|
|
if (index < this.props.value.length) { |
|
this.deleteToken(this.props.value[index]); // update input offset since it's the offset from the last token |
|
|
|
this.moveInputToIndex(index); |
|
} |
|
} |
|
}, { |
|
key: "addCurrentToken", |
|
value: function addCurrentToken() { |
|
var preventDefault = false; |
|
var selectedSuggestion = this.getSelectedSuggestion(); |
|
|
|
if (selectedSuggestion) { |
|
this.addNewToken(selectedSuggestion); |
|
preventDefault = true; |
|
} else if (this.inputHasValidValue()) { |
|
this.addNewToken(this.state.incompleteTokenValue); |
|
preventDefault = true; |
|
} |
|
|
|
return preventDefault; |
|
} |
|
}, { |
|
key: "addNewTokens", |
|
value: function addNewTokens(tokens) { |
|
var _this4 = this; |
|
|
|
var tokensToAdd = Object(external_lodash_["uniq"])(tokens.map(this.props.saveTransform).filter(Boolean).filter(function (token) { |
|
return !_this4.valueContainsToken(token); |
|
})); |
|
|
|
if (tokensToAdd.length > 0) { |
|
var newValue = Object(external_lodash_["clone"])(this.props.value); |
|
newValue.splice.apply(newValue, [this.getIndexOfInput(), 0].concat(tokensToAdd)); |
|
this.props.onChange(newValue); |
|
} |
|
} |
|
}, { |
|
key: "addNewToken", |
|
value: function addNewToken(token) { |
|
this.addNewTokens([token]); |
|
this.props.speak(this.props.messages.added, 'assertive'); |
|
this.setState({ |
|
incompleteTokenValue: '', |
|
selectedSuggestionIndex: -1, |
|
selectedSuggestionScroll: false, |
|
isExpanded: false |
|
}); |
|
|
|
if (this.state.isActive) { |
|
this.input.focus(); |
|
} |
|
} |
|
}, { |
|
key: "deleteToken", |
|
value: function deleteToken(token) { |
|
var _this5 = this; |
|
|
|
var newTokens = this.props.value.filter(function (item) { |
|
return _this5.getTokenValue(item) !== _this5.getTokenValue(token); |
|
}); |
|
this.props.onChange(newTokens); |
|
this.props.speak(this.props.messages.removed, 'assertive'); |
|
} |
|
}, { |
|
key: "getTokenValue", |
|
value: function getTokenValue(token) { |
|
if ('object' === Object(esm_typeof["a" /* default */])(token)) { |
|
return token.value; |
|
} |
|
|
|
return token; |
|
} |
|
}, { |
|
key: "getMatchingSuggestions", |
|
value: function getMatchingSuggestions() { |
|
var searchValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state.incompleteTokenValue; |
|
var suggestions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.props.suggestions; |
|
var value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.props.value; |
|
var maxSuggestions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : this.props.maxSuggestions; |
|
var saveTransform = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : this.props.saveTransform; |
|
var match = saveTransform(searchValue); |
|
var startsWithMatch = []; |
|
var containsMatch = []; |
|
|
|
if (match.length === 0) { |
|
suggestions = Object(external_lodash_["difference"])(suggestions, value); |
|
} else { |
|
match = match.toLocaleLowerCase(); |
|
Object(external_lodash_["each"])(suggestions, function (suggestion) { |
|
var index = suggestion.toLocaleLowerCase().indexOf(match); |
|
|
|
if (value.indexOf(suggestion) === -1) { |
|
if (index === 0) { |
|
startsWithMatch.push(suggestion); |
|
} else if (index > 0) { |
|
containsMatch.push(suggestion); |
|
} |
|
} |
|
}); |
|
suggestions = startsWithMatch.concat(containsMatch); |
|
} |
|
|
|
return Object(external_lodash_["take"])(suggestions, maxSuggestions); |
|
} |
|
}, { |
|
key: "getSelectedSuggestion", |
|
value: function getSelectedSuggestion() { |
|
if (this.state.selectedSuggestionIndex !== -1) { |
|
return this.getMatchingSuggestions()[this.state.selectedSuggestionIndex]; |
|
} |
|
} |
|
}, { |
|
key: "valueContainsToken", |
|
value: function valueContainsToken(token) { |
|
var _this6 = this; |
|
|
|
return Object(external_lodash_["some"])(this.props.value, function (item) { |
|
return _this6.getTokenValue(token) === _this6.getTokenValue(item); |
|
}); |
|
} |
|
}, { |
|
key: "getIndexOfInput", |
|
value: function getIndexOfInput() { |
|
return this.props.value.length - this.state.inputOffsetFromEnd; |
|
} |
|
}, { |
|
key: "isInputEmpty", |
|
value: function isInputEmpty() { |
|
return this.state.incompleteTokenValue.length === 0; |
|
} |
|
}, { |
|
key: "inputHasValidValue", |
|
value: function inputHasValidValue() { |
|
return this.props.saveTransform(this.state.incompleteTokenValue).length > 0; |
|
} |
|
}, { |
|
key: "updateSuggestions", |
|
value: function updateSuggestions() { |
|
var resetSelectedSuggestion = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; |
|
var incompleteTokenValue = this.state.incompleteTokenValue; |
|
var inputHasMinimumChars = incompleteTokenValue.trim().length > 1; |
|
var matchingSuggestions = this.getMatchingSuggestions(incompleteTokenValue); |
|
var hasMatchingSuggestions = matchingSuggestions.length > 0; |
|
var newState = { |
|
isExpanded: inputHasMinimumChars && hasMatchingSuggestions |
|
}; |
|
|
|
if (resetSelectedSuggestion) { |
|
newState.selectedSuggestionIndex = -1; |
|
newState.selectedSuggestionScroll = false; |
|
} |
|
|
|
this.setState(newState); |
|
|
|
if (inputHasMinimumChars) { |
|
var debouncedSpeak = this.props.debouncedSpeak; |
|
var message = hasMatchingSuggestions ? Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_n"])('%d result found, use up and down arrow keys to navigate.', '%d results found, use up and down arrow keys to navigate.', matchingSuggestions.length), matchingSuggestions.length) : Object(external_this_wp_i18n_["__"])('No results.'); |
|
debouncedSpeak(message, 'assertive'); |
|
} |
|
} |
|
}, { |
|
key: "renderTokensAndInput", |
|
value: function renderTokensAndInput() { |
|
var components = Object(external_lodash_["map"])(this.props.value, this.renderToken); |
|
components.splice(this.getIndexOfInput(), 0, this.renderInput()); |
|
return components; |
|
} |
|
}, { |
|
key: "renderToken", |
|
value: function renderToken(token, index, tokens) { |
|
var value = this.getTokenValue(token); |
|
var status = token.status ? token.status : undefined; |
|
var termPosition = index + 1; |
|
var termsCount = tokens.length; |
|
return Object(external_this_wp_element_["createElement"])(form_token_field_token, { |
|
key: 'token-' + value, |
|
value: value, |
|
status: status, |
|
title: token.title, |
|
displayTransform: this.props.displayTransform, |
|
onClickRemove: this.onTokenClickRemove, |
|
isBorderless: token.isBorderless || this.props.isBorderless, |
|
onMouseEnter: token.onMouseEnter, |
|
onMouseLeave: token.onMouseLeave, |
|
disabled: 'error' !== status && this.props.disabled, |
|
messages: this.props.messages, |
|
termsCount: termsCount, |
|
termPosition: termPosition |
|
}); |
|
} |
|
}, { |
|
key: "renderInput", |
|
value: function renderInput() { |
|
var _this$props2 = this.props, |
|
autoCapitalize = _this$props2.autoCapitalize, |
|
autoComplete = _this$props2.autoComplete, |
|
maxLength = _this$props2.maxLength, |
|
value = _this$props2.value, |
|
instanceId = _this$props2.instanceId; |
|
var props = { |
|
instanceId: instanceId, |
|
autoCapitalize: autoCapitalize, |
|
autoComplete: autoComplete, |
|
ref: this.bindInput, |
|
key: 'input', |
|
disabled: this.props.disabled, |
|
value: this.state.incompleteTokenValue, |
|
onBlur: this.onBlur, |
|
isExpanded: this.state.isExpanded, |
|
selectedSuggestionIndex: this.state.selectedSuggestionIndex |
|
}; |
|
|
|
if (!(maxLength && value.length >= maxLength)) { |
|
props = Object(objectSpread["a" /* default */])({}, props, { |
|
onChange: this.onInputChange |
|
}); |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])(token_input, props); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props3 = this.props, |
|
disabled = _this$props3.disabled, |
|
_this$props3$label = _this$props3.label, |
|
label = _this$props3$label === void 0 ? Object(external_this_wp_i18n_["__"])('Add item') : _this$props3$label, |
|
instanceId = _this$props3.instanceId, |
|
className = _this$props3.className; |
|
var isExpanded = this.state.isExpanded; |
|
var classes = classnames_default()(className, 'components-form-token-field__input-container', { |
|
'is-active': this.state.isActive, |
|
'is-disabled': disabled |
|
}); |
|
var tokenFieldProps = { |
|
className: 'components-form-token-field', |
|
tabIndex: '-1' |
|
}; |
|
var matchingSuggestions = this.getMatchingSuggestions(); |
|
|
|
if (!disabled) { |
|
tokenFieldProps = Object.assign({}, tokenFieldProps, { |
|
onKeyDown: this.onKeyDown, |
|
onKeyPress: this.onKeyPress, |
|
onFocus: this.onFocus |
|
}); |
|
} // Disable reason: There is no appropriate role which describes the |
|
// input container intended accessible usability. |
|
// TODO: Refactor click detection to use blur to stop propagation. |
|
|
|
/* eslint-disable jsx-a11y/no-static-element-interactions */ |
|
|
|
|
|
return Object(external_this_wp_element_["createElement"])("div", tokenFieldProps, Object(external_this_wp_element_["createElement"])("label", { |
|
htmlFor: "components-form-token-input-".concat(instanceId), |
|
className: "components-form-token-field__label" |
|
}, label), Object(external_this_wp_element_["createElement"])("div", { |
|
ref: this.bindTokensAndInput, |
|
className: classes, |
|
tabIndex: "-1", |
|
onMouseDown: this.onContainerTouched, |
|
onTouchStart: this.onContainerTouched |
|
}, this.renderTokensAndInput(), isExpanded && Object(external_this_wp_element_["createElement"])(suggestions_list, { |
|
instanceId: instanceId, |
|
match: this.props.saveTransform(this.state.incompleteTokenValue), |
|
displayTransform: this.props.displayTransform, |
|
suggestions: matchingSuggestions, |
|
selectedIndex: this.state.selectedSuggestionIndex, |
|
scrollIntoView: this.state.selectedSuggestionScroll, |
|
onHover: this.onSuggestionHovered, |
|
onSelect: this.onSuggestionSelected |
|
})), Object(external_this_wp_element_["createElement"])("p", { |
|
id: "components-form-token-suggestions-howto-".concat(instanceId), |
|
className: "components-form-token-field__help" |
|
}, this.props.tokenizeOnSpace ? Object(external_this_wp_i18n_["__"])('Separate with commas, spaces, or the Enter key.') : Object(external_this_wp_i18n_["__"])('Separate with commas or the Enter key.'))); |
|
/* eslint-enable jsx-a11y/no-static-element-interactions */ |
|
} |
|
}], [{ |
|
key: "getDerivedStateFromProps", |
|
value: function getDerivedStateFromProps(props, state) { |
|
if (!props.disabled || !state.isActive) { |
|
return null; |
|
} |
|
|
|
return { |
|
isActive: false, |
|
incompleteTokenValue: '' |
|
}; |
|
} |
|
}]); |
|
|
|
return FormTokenField; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
form_token_field_FormTokenField.defaultProps = { |
|
suggestions: Object.freeze([]), |
|
maxSuggestions: 100, |
|
value: Object.freeze([]), |
|
displayTransform: external_lodash_["identity"], |
|
saveTransform: function saveTransform(token) { |
|
return token.trim(); |
|
}, |
|
onChange: function onChange() {}, |
|
onInputChange: function onInputChange() {}, |
|
isBorderless: false, |
|
disabled: false, |
|
tokenizeOnSpace: false, |
|
messages: { |
|
added: Object(external_this_wp_i18n_["__"])('Item added.'), |
|
removed: Object(external_this_wp_i18n_["__"])('Item removed.'), |
|
remove: Object(external_this_wp_i18n_["__"])('Remove item') |
|
} |
|
}; |
|
/* harmony default export */ var form_token_field = (with_spoken_messages(Object(external_this_wp_compose_["withInstanceId"])(form_token_field_FormTokenField))); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/menu-group/index.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
function MenuGroup(_ref) { |
|
var children = _ref.children, |
|
_ref$className = _ref.className, |
|
className = _ref$className === void 0 ? '' : _ref$className, |
|
instanceId = _ref.instanceId, |
|
label = _ref.label; |
|
|
|
if (!external_this_wp_element_["Children"].count(children)) { |
|
return null; |
|
} |
|
|
|
var labelId = "components-menu-group-label-".concat(instanceId); |
|
var classNames = classnames_default()(className, 'components-menu-group'); |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: classNames |
|
}, label && Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-menu-group__label", |
|
id: labelId, |
|
"aria-hidden": "true" |
|
}, label), Object(external_this_wp_element_["createElement"])("div", { |
|
role: "group", |
|
"aria-labelledby": label ? labelId : null |
|
}, children)); |
|
} |
|
/* harmony default export */ var menu_group = (Object(external_this_wp_compose_["withInstanceId"])(MenuGroup)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/menu-item/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Renders a generic menu item for use inside the more menu. |
|
* |
|
* @return {WPElement} More menu item. |
|
*/ |
|
|
|
function MenuItem(_ref) { |
|
var children = _ref.children, |
|
info = _ref.info, |
|
className = _ref.className, |
|
icon = _ref.icon, |
|
shortcut = _ref.shortcut, |
|
isSelected = _ref.isSelected, |
|
_ref$role = _ref.role, |
|
role = _ref$role === void 0 ? 'menuitem' : _ref$role, |
|
props = Object(objectWithoutProperties["a" /* default */])(_ref, ["children", "info", "className", "icon", "shortcut", "isSelected", "role"]); |
|
|
|
className = classnames_default()('components-menu-item__button', className, { |
|
'has-icon': icon |
|
}); |
|
|
|
if (info) { |
|
children = Object(external_this_wp_element_["createElement"])("span", { |
|
className: "components-menu-item__info-wrapper" |
|
}, children, Object(external_this_wp_element_["createElement"])("span", { |
|
className: "components-menu-item__info" |
|
}, info)); |
|
} |
|
|
|
if (icon && !Object(external_lodash_["isString"])(icon)) { |
|
icon = Object(external_this_wp_element_["cloneElement"])(icon, { |
|
className: 'components-menu-items__item-icon', |
|
height: 20, |
|
width: 20 |
|
}); |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])(icon_button, Object(esm_extends["a" /* default */])({ |
|
icon: icon // Make sure aria-checked matches spec https://www.w3.org/TR/wai-aria-1.1/#aria-checked |
|
, |
|
"aria-checked": role === 'menuitemcheckbox' || role === 'menuitemradio' ? isSelected : undefined, |
|
role: role, |
|
className: className |
|
}, props), children, Object(external_this_wp_element_["createElement"])(build_module_shortcut, { |
|
className: "components-menu-item__shortcut", |
|
shortcut: shortcut |
|
})); |
|
} |
|
/* harmony default export */ var menu_item = (MenuItem); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/menu-items-choice/index.js |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
function MenuItemsChoice(_ref) { |
|
var _ref$choices = _ref.choices, |
|
choices = _ref$choices === void 0 ? [] : _ref$choices, |
|
onSelect = _ref.onSelect, |
|
value = _ref.value; |
|
return choices.map(function (item) { |
|
var isSelected = value === item.value; |
|
return Object(external_this_wp_element_["createElement"])(menu_item, { |
|
key: item.value, |
|
role: "menuitemradio", |
|
icon: isSelected && 'yes', |
|
isSelected: isSelected, |
|
shortcut: item.shortcut, |
|
onClick: function onClick() { |
|
if (!isSelected) { |
|
onSelect(item.value); |
|
} |
|
} |
|
}, item.label); |
|
}); |
|
} |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/modal/frame.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
var frame_ModalFrame = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(ModalFrame, _Component); |
|
|
|
function ModalFrame() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, ModalFrame); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(ModalFrame).apply(this, arguments)); |
|
_this.containerRef = Object(external_this_wp_element_["createRef"])(); |
|
_this.handleKeyDown = _this.handleKeyDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.handleFocusOutside = _this.handleFocusOutside.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.focusFirstTabbable = _this.focusFirstTabbable.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
/** |
|
* Focuses the first tabbable element when props.focusOnMount is true. |
|
*/ |
|
|
|
|
|
Object(createClass["a" /* default */])(ModalFrame, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
// Focus on mount |
|
if (this.props.focusOnMount) { |
|
this.focusFirstTabbable(); |
|
} |
|
} |
|
/** |
|
* Focuses the first tabbable element. |
|
*/ |
|
|
|
}, { |
|
key: "focusFirstTabbable", |
|
value: function focusFirstTabbable() { |
|
var tabbables = external_this_wp_dom_["focus"].tabbable.find(this.containerRef.current); |
|
|
|
if (tabbables.length) { |
|
tabbables[0].focus(); |
|
} |
|
} |
|
/** |
|
* Callback function called when clicked outside the modal. |
|
* |
|
* @param {Object} event Mouse click event. |
|
*/ |
|
|
|
}, { |
|
key: "handleFocusOutside", |
|
value: function handleFocusOutside(event) { |
|
if (this.props.shouldCloseOnClickOutside) { |
|
this.onRequestClose(event); |
|
} |
|
} |
|
/** |
|
* Callback function called when a key is pressed. |
|
* |
|
* @param {KeyboardEvent} event Key down event. |
|
*/ |
|
|
|
}, { |
|
key: "handleKeyDown", |
|
value: function handleKeyDown(event) { |
|
if (event.keyCode === external_this_wp_keycodes_["ESCAPE"]) { |
|
this.handleEscapeKeyDown(event); |
|
} |
|
} |
|
/** |
|
* Handles a escape key down event. |
|
* |
|
* Calls onRequestClose and prevents propagation of the event outside the modal. |
|
* |
|
* @param {Object} event Key down event. |
|
*/ |
|
|
|
}, { |
|
key: "handleEscapeKeyDown", |
|
value: function handleEscapeKeyDown(event) { |
|
if (this.props.shouldCloseOnEsc) { |
|
event.stopPropagation(); |
|
this.onRequestClose(event); |
|
} |
|
} |
|
/** |
|
* Calls the onRequestClose callback props when it is available. |
|
* |
|
* @param {Object} event Event object. |
|
*/ |
|
|
|
}, { |
|
key: "onRequestClose", |
|
value: function onRequestClose(event) { |
|
var onRequestClose = this.props.onRequestClose; |
|
|
|
if (onRequestClose) { |
|
onRequestClose(event); |
|
} |
|
} |
|
/** |
|
* Renders the modal frame element. |
|
* |
|
* @return {WPElement} The modal frame element. |
|
*/ |
|
|
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
overlayClassName = _this$props.overlayClassName, |
|
contentLabel = _this$props.contentLabel, |
|
_this$props$aria = _this$props.aria, |
|
describedby = _this$props$aria.describedby, |
|
labelledby = _this$props$aria.labelledby, |
|
children = _this$props.children, |
|
className = _this$props.className, |
|
role = _this$props.role, |
|
style = _this$props.style; |
|
return Object(external_this_wp_element_["createElement"])(isolated_event_container, { |
|
className: classnames_default()('components-modal__screen-overlay', overlayClassName), |
|
onKeyDown: this.handleKeyDown |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: classnames_default()('components-modal__frame', className), |
|
style: style, |
|
ref: this.containerRef, |
|
role: role, |
|
"aria-label": contentLabel, |
|
"aria-labelledby": contentLabel ? null : labelledby, |
|
"aria-describedby": describedby, |
|
tabIndex: "-1" |
|
}, children)); |
|
} |
|
}]); |
|
|
|
return ModalFrame; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var modal_frame = (Object(external_this_wp_compose_["compose"])([with_focus_return, with_constrained_tabbing, with_focus_outside])(frame_ModalFrame)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/modal/header.js |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
var header_ModalHeader = function ModalHeader(_ref) { |
|
var icon = _ref.icon, |
|
title = _ref.title, |
|
onClose = _ref.onClose, |
|
closeLabel = _ref.closeLabel, |
|
headingId = _ref.headingId, |
|
isDismissable = _ref.isDismissable; |
|
var label = closeLabel ? closeLabel : Object(external_this_wp_i18n_["__"])('Close dialog'); |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-modal__header" |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-modal__header-heading-container" |
|
}, icon && Object(external_this_wp_element_["createElement"])("span", { |
|
className: "components-modal__icon-container", |
|
"aria-hidden": true |
|
}, icon), title && Object(external_this_wp_element_["createElement"])("h1", { |
|
id: headingId, |
|
className: "components-modal__header-heading" |
|
}, title)), isDismissable && Object(external_this_wp_element_["createElement"])(icon_button, { |
|
onClick: onClose, |
|
icon: "no-alt", |
|
label: label |
|
})); |
|
}; |
|
|
|
/* harmony default export */ var modal_header = (header_ModalHeader); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/modal/aria-helper.js |
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
var LIVE_REGION_ARIA_ROLES = new Set(['alert', 'status', 'log', 'marquee', 'timer']); |
|
var hiddenElements = [], |
|
isHidden = false; |
|
/** |
|
* Hides all elements in the body element from screen-readers except |
|
* the provided element and elements that should not be hidden from |
|
* screen-readers. |
|
* |
|
* The reason we do this is because `aria-modal="true"` currently is bugged |
|
* in Safari, and support is spotty in other browsers overall. In the future |
|
* we should consider removing these helper functions in favor of |
|
* `aria-modal="true"`. |
|
* |
|
* @param {Element} unhiddenElement The element that should not be hidden. |
|
*/ |
|
|
|
function hideApp(unhiddenElement) { |
|
if (isHidden) { |
|
return; |
|
} |
|
|
|
var elements = document.body.children; |
|
Object(external_lodash_["forEach"])(elements, function (element) { |
|
if (element === unhiddenElement) { |
|
return; |
|
} |
|
|
|
if (elementShouldBeHidden(element)) { |
|
element.setAttribute('aria-hidden', 'true'); |
|
hiddenElements.push(element); |
|
} |
|
}); |
|
isHidden = true; |
|
} |
|
/** |
|
* Determines if the passed element should not be hidden from screen readers. |
|
* |
|
* @param {HTMLElement} element The element that should be checked. |
|
* |
|
* @return {boolean} Whether the element should not be hidden from screen-readers. |
|
*/ |
|
|
|
function elementShouldBeHidden(element) { |
|
var role = element.getAttribute('role'); |
|
return !(element.tagName === 'SCRIPT' || element.hasAttribute('aria-hidden') || element.hasAttribute('aria-live') || LIVE_REGION_ARIA_ROLES.has(role)); |
|
} |
|
/** |
|
* Makes all elements in the body that have been hidden by `hideApp` |
|
* visible again to screen-readers. |
|
*/ |
|
|
|
function showApp() { |
|
if (!isHidden) { |
|
return; |
|
} |
|
|
|
Object(external_lodash_["forEach"])(hiddenElements, function (element) { |
|
element.removeAttribute('aria-hidden'); |
|
}); |
|
hiddenElements = []; |
|
isHidden = false; |
|
} |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/modal/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
// Used to count the number of open modals. |
|
|
|
var parentElement, |
|
openModalCount = 0; |
|
|
|
var modal_Modal = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Modal, _Component); |
|
|
|
function Modal(props) { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Modal); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Modal).call(this, props)); |
|
|
|
_this.prepareDOM(); |
|
|
|
return _this; |
|
} |
|
/** |
|
* Appends the modal's node to the DOM, so the portal can render the |
|
* modal in it. Also calls the openFirstModal when this is the first modal to be |
|
* opened. |
|
*/ |
|
|
|
|
|
Object(createClass["a" /* default */])(Modal, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
openModalCount++; |
|
|
|
if (openModalCount === 1) { |
|
this.openFirstModal(); |
|
} |
|
} |
|
/** |
|
* Removes the modal's node from the DOM. Also calls closeLastModal when this is |
|
* the last modal to be closed. |
|
*/ |
|
|
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
openModalCount--; |
|
|
|
if (openModalCount === 0) { |
|
this.closeLastModal(); |
|
} |
|
|
|
this.cleanDOM(); |
|
} |
|
/** |
|
* Prepares the DOM for the modals to be rendered. |
|
* |
|
* Every modal is mounted in a separate div appended to a parent div |
|
* that is appended to the document body. |
|
* |
|
* The parent div will be created if it does not yet exist, and the |
|
* separate div for this specific modal will be appended to that. |
|
*/ |
|
|
|
}, { |
|
key: "prepareDOM", |
|
value: function prepareDOM() { |
|
if (!parentElement) { |
|
parentElement = document.createElement('div'); |
|
document.body.appendChild(parentElement); |
|
} |
|
|
|
this.node = document.createElement('div'); |
|
parentElement.appendChild(this.node); |
|
} |
|
/** |
|
* Removes the specific mounting point for this modal from the DOM. |
|
*/ |
|
|
|
}, { |
|
key: "cleanDOM", |
|
value: function cleanDOM() { |
|
parentElement.removeChild(this.node); |
|
} |
|
/** |
|
* Prepares the DOM for this modal and any additional modal to be mounted. |
|
* |
|
* It appends an additional div to the body for the modals to be rendered in, |
|
* it hides any other elements from screen-readers and adds an additional class |
|
* to the body to prevent scrolling while the modal is open. |
|
*/ |
|
|
|
}, { |
|
key: "openFirstModal", |
|
value: function openFirstModal() { |
|
hideApp(parentElement); |
|
document.body.classList.add(this.props.bodyOpenClassName); |
|
} |
|
/** |
|
* Cleans up the DOM after the last modal is closed and makes the app available |
|
* for screen-readers again. |
|
*/ |
|
|
|
}, { |
|
key: "closeLastModal", |
|
value: function closeLastModal() { |
|
document.body.classList.remove(this.props.bodyOpenClassName); |
|
showApp(); |
|
} |
|
/** |
|
* Renders the modal. |
|
* |
|
* @return {WPElement} The modal element. |
|
*/ |
|
|
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
onRequestClose = _this$props.onRequestClose, |
|
title = _this$props.title, |
|
icon = _this$props.icon, |
|
closeButtonLabel = _this$props.closeButtonLabel, |
|
children = _this$props.children, |
|
aria = _this$props.aria, |
|
instanceId = _this$props.instanceId, |
|
isDismissable = _this$props.isDismissable, |
|
otherProps = Object(objectWithoutProperties["a" /* default */])(_this$props, ["onRequestClose", "title", "icon", "closeButtonLabel", "children", "aria", "instanceId", "isDismissable"]); |
|
|
|
var headingId = aria.labelledby || "components-modal-header-".concat(instanceId); // Disable reason: this stops mouse events from triggering tooltips and |
|
// other elements underneath the modal overlay. |
|
|
|
return Object(external_this_wp_element_["createPortal"])(Object(external_this_wp_element_["createElement"])(modal_frame, Object(esm_extends["a" /* default */])({ |
|
onRequestClose: onRequestClose, |
|
aria: { |
|
labelledby: title ? headingId : null, |
|
describedby: aria.describedby |
|
} |
|
}, otherProps), Object(external_this_wp_element_["createElement"])("div", { |
|
className: 'components-modal__content', |
|
tabIndex: "0" |
|
}, Object(external_this_wp_element_["createElement"])(modal_header, { |
|
closeLabel: closeButtonLabel, |
|
headingId: headingId, |
|
icon: icon, |
|
isDismissable: isDismissable, |
|
onClose: onRequestClose, |
|
title: title |
|
}), children)), this.node); |
|
} |
|
}]); |
|
|
|
return Modal; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
modal_Modal.defaultProps = { |
|
bodyOpenClassName: 'modal-open', |
|
role: 'dialog', |
|
title: null, |
|
focusOnMount: true, |
|
shouldCloseOnEsc: true, |
|
shouldCloseOnClickOutside: true, |
|
isDismissable: true, |
|
|
|
/* accessibility */ |
|
aria: { |
|
labelledby: null, |
|
describedby: null |
|
} |
|
}; |
|
/* harmony default export */ var modal = (Object(external_this_wp_compose_["withInstanceId"])(modal_Modal)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/notice/index.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
function Notice(_ref) { |
|
var className = _ref.className, |
|
status = _ref.status, |
|
children = _ref.children, |
|
_ref$onRemove = _ref.onRemove, |
|
onRemove = _ref$onRemove === void 0 ? external_lodash_["noop"] : _ref$onRemove, |
|
_ref$isDismissible = _ref.isDismissible, |
|
isDismissible = _ref$isDismissible === void 0 ? true : _ref$isDismissible, |
|
_ref$actions = _ref.actions, |
|
actions = _ref$actions === void 0 ? [] : _ref$actions, |
|
__unstableHTML = _ref.__unstableHTML; |
|
var classes = classnames_default()(className, 'components-notice', 'is-' + status, { |
|
'is-dismissible': isDismissible |
|
}); |
|
|
|
if (__unstableHTML) { |
|
children = Object(external_this_wp_element_["createElement"])(external_this_wp_element_["RawHTML"], null, children); |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: classes |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-notice__content" |
|
}, children, actions.map(function (_ref2, index) { |
|
var buttonCustomClasses = _ref2.className, |
|
label = _ref2.label, |
|
_ref2$noDefaultClasse = _ref2.noDefaultClasses, |
|
noDefaultClasses = _ref2$noDefaultClasse === void 0 ? false : _ref2$noDefaultClasse, |
|
onClick = _ref2.onClick, |
|
url = _ref2.url; |
|
return Object(external_this_wp_element_["createElement"])(build_module_button, { |
|
key: index, |
|
href: url, |
|
isDefault: !noDefaultClasses && !url, |
|
isLink: !noDefaultClasses && !!url, |
|
onClick: url ? undefined : onClick, |
|
className: classnames_default()('components-notice__action', buttonCustomClasses) |
|
}, label); |
|
})), isDismissible && Object(external_this_wp_element_["createElement"])(icon_button, { |
|
className: "components-notice__dismiss", |
|
icon: "no-alt", |
|
label: Object(external_this_wp_i18n_["__"])('Dismiss this notice'), |
|
onClick: onRemove, |
|
tooltip: false |
|
})); |
|
} |
|
|
|
/* harmony default export */ var build_module_notice = (Notice); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/notice/list.js |
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Renders a list of notices. |
|
* |
|
* @param {Object} $0 Props passed to the component. |
|
* @param {Array} $0.notices Array of notices to render. |
|
* @param {Function} $0.onRemove Function called when a notice should be removed / dismissed. |
|
* @param {Object} $0.className Name of the class used by the component. |
|
* @param {Object} $0.children Array of children to be rendered inside the notice list. |
|
* @return {Object} The rendered notices list. |
|
*/ |
|
|
|
function NoticeList(_ref) { |
|
var notices = _ref.notices, |
|
_ref$onRemove = _ref.onRemove, |
|
onRemove = _ref$onRemove === void 0 ? external_lodash_["noop"] : _ref$onRemove, |
|
className = _ref.className, |
|
children = _ref.children; |
|
|
|
var removeNotice = function removeNotice(id) { |
|
return function () { |
|
return onRemove(id); |
|
}; |
|
}; |
|
|
|
className = classnames_default()('components-notice-list', className); |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: className |
|
}, children, Object(toConsumableArray["a" /* default */])(notices).reverse().map(function (notice) { |
|
return Object(external_this_wp_element_["createElement"])(build_module_notice, Object(esm_extends["a" /* default */])({}, Object(external_lodash_["omit"])(notice, ['content']), { |
|
key: notice.id, |
|
onRemove: removeNotice(notice.id) |
|
}), notice.content); |
|
})); |
|
} |
|
|
|
/* harmony default export */ var list = (NoticeList); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/panel/header.js |
|
|
|
|
|
function PanelHeader(_ref) { |
|
var label = _ref.label, |
|
children = _ref.children; |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-panel__header" |
|
}, label && Object(external_this_wp_element_["createElement"])("h2", null, label), children); |
|
} |
|
|
|
/* harmony default export */ var panel_header = (PanelHeader); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/panel/index.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
function Panel(_ref) { |
|
var header = _ref.header, |
|
className = _ref.className, |
|
children = _ref.children; |
|
var classNames = classnames_default()(className, 'components-panel'); |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: classNames |
|
}, header && Object(external_this_wp_element_["createElement"])(panel_header, { |
|
label: header |
|
}), children); |
|
} |
|
|
|
/* harmony default export */ var panel = (Panel); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/panel/body.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
var body_PanelBody = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(PanelBody, _Component); |
|
|
|
function PanelBody(props) { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, PanelBody); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PanelBody).apply(this, arguments)); |
|
_this.state = { |
|
opened: props.initialOpen === undefined ? true : props.initialOpen |
|
}; |
|
_this.toggle = _this.toggle.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(PanelBody, [{ |
|
key: "toggle", |
|
value: function toggle(event) { |
|
event.preventDefault(); |
|
|
|
if (this.props.opened === undefined) { |
|
this.setState(function (state) { |
|
return { |
|
opened: !state.opened |
|
}; |
|
}); |
|
} |
|
|
|
if (this.props.onToggle) { |
|
this.props.onToggle(); |
|
} |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
title = _this$props.title, |
|
children = _this$props.children, |
|
opened = _this$props.opened, |
|
className = _this$props.className, |
|
icon = _this$props.icon, |
|
forwardedRef = _this$props.forwardedRef; |
|
var isOpened = opened === undefined ? this.state.opened : opened; |
|
var classes = classnames_default()('components-panel__body', className, { |
|
'is-opened': isOpened |
|
}); |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: classes, |
|
ref: forwardedRef |
|
}, !!title && Object(external_this_wp_element_["createElement"])("h2", { |
|
className: "components-panel__body-title" |
|
}, Object(external_this_wp_element_["createElement"])(build_module_button, { |
|
className: "components-panel__body-toggle", |
|
onClick: this.toggle, |
|
"aria-expanded": isOpened |
|
}, Object(external_this_wp_element_["createElement"])("span", { |
|
"aria-hidden": "true" |
|
}, isOpened ? Object(external_this_wp_element_["createElement"])(svg_SVG, { |
|
className: "components-panel__arrow", |
|
width: "24px", |
|
height: "24px", |
|
viewBox: "0 0 24 24", |
|
xmlns: "http://www.w3.org/2000/svg" |
|
}, Object(external_this_wp_element_["createElement"])(svg_G, null, Object(external_this_wp_element_["createElement"])(svg_Path, { |
|
fill: "none", |
|
d: "M0,0h24v24H0V0z" |
|
})), Object(external_this_wp_element_["createElement"])(svg_G, null, Object(external_this_wp_element_["createElement"])(svg_Path, { |
|
d: "M12,8l-6,6l1.41,1.41L12,10.83l4.59,4.58L18,14L12,8z" |
|
}))) : Object(external_this_wp_element_["createElement"])(svg_SVG, { |
|
className: "components-panel__arrow", |
|
width: "24px", |
|
height: "24px", |
|
viewBox: "0 0 24 24", |
|
xmlns: "http://www.w3.org/2000/svg" |
|
}, Object(external_this_wp_element_["createElement"])(svg_G, null, Object(external_this_wp_element_["createElement"])(svg_Path, { |
|
fill: "none", |
|
d: "M0,0h24v24H0V0z" |
|
})), Object(external_this_wp_element_["createElement"])(svg_G, null, Object(external_this_wp_element_["createElement"])(svg_Path, { |
|
d: "M7.41,8.59L12,13.17l4.59-4.58L18,10l-6,6l-6-6L7.41,8.59z" |
|
})))), title, icon && Object(external_this_wp_element_["createElement"])(build_module_icon, { |
|
icon: icon, |
|
className: "components-panel__icon", |
|
size: 20 |
|
}))), isOpened && children); |
|
} |
|
}]); |
|
|
|
return PanelBody; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
var body_forwardedPanelBody = function forwardedPanelBody(props, ref) { |
|
return Object(external_this_wp_element_["createElement"])(body_PanelBody, Object(esm_extends["a" /* default */])({}, props, { |
|
forwardedRef: ref |
|
})); |
|
}; |
|
|
|
body_forwardedPanelBody.displayName = 'PanelBody'; |
|
/* harmony default export */ var panel_body = (Object(external_this_wp_element_["forwardRef"])(body_forwardedPanelBody)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/panel/row.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
function PanelRow(_ref) { |
|
var className = _ref.className, |
|
children = _ref.children; |
|
var classes = classnames_default()('components-panel__row', className); |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: classes |
|
}, children); |
|
} |
|
|
|
/* harmony default export */ var row = (PanelRow); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/placeholder/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Renders a placeholder. Normally used by blocks to render their empty state. |
|
* |
|
* @param {Object} props The component props. |
|
* @return {Object} The rendered placeholder. |
|
*/ |
|
|
|
function Placeholder(_ref) { |
|
var icon = _ref.icon, |
|
children = _ref.children, |
|
label = _ref.label, |
|
instructions = _ref.instructions, |
|
className = _ref.className, |
|
notices = _ref.notices, |
|
preview = _ref.preview, |
|
isColumnLayout = _ref.isColumnLayout, |
|
additionalProps = Object(objectWithoutProperties["a" /* default */])(_ref, ["icon", "children", "label", "instructions", "className", "notices", "preview", "isColumnLayout"]); |
|
|
|
var classes = classnames_default()('components-placeholder', className); |
|
var fieldsetClasses = classnames_default()('components-placeholder__fieldset', { |
|
'is-column-layout': isColumnLayout |
|
}); |
|
return Object(external_this_wp_element_["createElement"])("div", Object(esm_extends["a" /* default */])({}, additionalProps, { |
|
className: classes |
|
}), notices, preview && Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-placeholder__preview" |
|
}, preview), Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-placeholder__label" |
|
}, Object(external_lodash_["isString"])(icon) ? Object(external_this_wp_element_["createElement"])(dashicon_Dashicon, { |
|
icon: icon |
|
}) : icon, label), !!instructions && Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-placeholder__instructions" |
|
}, instructions), Object(external_this_wp_element_["createElement"])("div", { |
|
className: fieldsetClasses |
|
}, children)); |
|
} |
|
|
|
/* harmony default export */ var placeholder = (Placeholder); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/query-controls/terms.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* Returns terms in a tree form. |
|
* |
|
* @param {Array} flatTerms Array of terms in flat format. |
|
* |
|
* @return {Array} Array of terms in tree format. |
|
*/ |
|
|
|
function buildTermsTree(flatTerms) { |
|
var flatTermsWithParentAndChildren = flatTerms.map(function (term) { |
|
return Object(objectSpread["a" /* default */])({ |
|
children: [], |
|
parent: null |
|
}, term); |
|
}); |
|
var termsByParent = Object(external_lodash_["groupBy"])(flatTermsWithParentAndChildren, 'parent'); |
|
|
|
if (termsByParent.null && termsByParent.null.length) { |
|
return flatTermsWithParentAndChildren; |
|
} |
|
|
|
var fillWithChildren = function fillWithChildren(terms) { |
|
return terms.map(function (term) { |
|
var children = termsByParent[term.id]; |
|
return Object(objectSpread["a" /* default */])({}, term, { |
|
children: children && children.length ? fillWithChildren(children) : [] |
|
}); |
|
}); |
|
}; |
|
|
|
return fillWithChildren(termsByParent['0'] || []); |
|
} |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/tree-select/index.js |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
function tree_select_getSelectOptions(tree) { |
|
var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; |
|
return Object(external_lodash_["flatMap"])(tree, function (treeNode) { |
|
return [{ |
|
value: treeNode.id, |
|
label: Object(external_lodash_["repeat"])("\xA0", level * 3) + Object(external_lodash_["unescape"])(treeNode.name) |
|
}].concat(Object(toConsumableArray["a" /* default */])(tree_select_getSelectOptions(treeNode.children || [], level + 1))); |
|
}); |
|
} |
|
|
|
function TreeSelect(_ref) { |
|
var label = _ref.label, |
|
noOptionLabel = _ref.noOptionLabel, |
|
onChange = _ref.onChange, |
|
selectedId = _ref.selectedId, |
|
tree = _ref.tree, |
|
props = Object(objectWithoutProperties["a" /* default */])(_ref, ["label", "noOptionLabel", "onChange", "selectedId", "tree"]); |
|
|
|
var options = Object(external_lodash_["compact"])([noOptionLabel && { |
|
value: '', |
|
label: noOptionLabel |
|
}].concat(Object(toConsumableArray["a" /* default */])(tree_select_getSelectOptions(tree)))); |
|
return Object(external_this_wp_element_["createElement"])(select_control, Object(esm_extends["a" /* default */])({ |
|
label: label, |
|
options: options, |
|
onChange: onChange |
|
}, { |
|
value: selectedId |
|
}, props)); |
|
} |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/query-controls/category-select.js |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
function CategorySelect(_ref) { |
|
var label = _ref.label, |
|
noOptionLabel = _ref.noOptionLabel, |
|
categoriesList = _ref.categoriesList, |
|
selectedCategoryId = _ref.selectedCategoryId, |
|
onChange = _ref.onChange; |
|
var termsTree = buildTermsTree(categoriesList); |
|
return Object(external_this_wp_element_["createElement"])(TreeSelect, Object(esm_extends["a" /* default */])({ |
|
label: label, |
|
noOptionLabel: noOptionLabel, |
|
onChange: onChange |
|
}, { |
|
tree: termsTree, |
|
selectedId: selectedCategoryId |
|
})); |
|
} |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/query-controls/index.js |
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
var DEFAULT_MIN_ITEMS = 1; |
|
var DEFAULT_MAX_ITEMS = 100; |
|
function QueryControls(_ref) { |
|
var categoriesList = _ref.categoriesList, |
|
selectedCategoryId = _ref.selectedCategoryId, |
|
numberOfItems = _ref.numberOfItems, |
|
order = _ref.order, |
|
orderBy = _ref.orderBy, |
|
_ref$maxItems = _ref.maxItems, |
|
maxItems = _ref$maxItems === void 0 ? DEFAULT_MAX_ITEMS : _ref$maxItems, |
|
_ref$minItems = _ref.minItems, |
|
minItems = _ref$minItems === void 0 ? DEFAULT_MIN_ITEMS : _ref$minItems, |
|
onCategoryChange = _ref.onCategoryChange, |
|
onNumberOfItemsChange = _ref.onNumberOfItemsChange, |
|
onOrderChange = _ref.onOrderChange, |
|
onOrderByChange = _ref.onOrderByChange; |
|
return [onOrderChange && onOrderByChange && Object(external_this_wp_element_["createElement"])(select_control, { |
|
key: "query-controls-order-select", |
|
label: Object(external_this_wp_i18n_["__"])('Order by'), |
|
value: "".concat(orderBy, "/").concat(order), |
|
options: [{ |
|
label: Object(external_this_wp_i18n_["__"])('Newest to Oldest'), |
|
value: 'date/desc' |
|
}, { |
|
label: Object(external_this_wp_i18n_["__"])('Oldest to Newest'), |
|
value: 'date/asc' |
|
}, { |
|
/* translators: label for ordering posts by title in ascending order */ |
|
label: Object(external_this_wp_i18n_["__"])('A → Z'), |
|
value: 'title/asc' |
|
}, { |
|
/* translators: label for ordering posts by title in descending order */ |
|
label: Object(external_this_wp_i18n_["__"])('Z → A'), |
|
value: 'title/desc' |
|
}], |
|
onChange: function onChange(value) { |
|
var _value$split = value.split('/'), |
|
_value$split2 = Object(slicedToArray["a" /* default */])(_value$split, 2), |
|
newOrderBy = _value$split2[0], |
|
newOrder = _value$split2[1]; |
|
|
|
if (newOrder !== order) { |
|
onOrderChange(newOrder); |
|
} |
|
|
|
if (newOrderBy !== orderBy) { |
|
onOrderByChange(newOrderBy); |
|
} |
|
} |
|
}), onCategoryChange && Object(external_this_wp_element_["createElement"])(CategorySelect, { |
|
key: "query-controls-category-select", |
|
categoriesList: categoriesList, |
|
label: Object(external_this_wp_i18n_["__"])('Category'), |
|
noOptionLabel: Object(external_this_wp_i18n_["__"])('All'), |
|
selectedCategoryId: selectedCategoryId, |
|
onChange: onCategoryChange |
|
}), onNumberOfItemsChange && Object(external_this_wp_element_["createElement"])(range_control, { |
|
key: "query-controls-range-control", |
|
label: Object(external_this_wp_i18n_["__"])('Number of items'), |
|
value: numberOfItems, |
|
onChange: onNumberOfItemsChange, |
|
min: minItems, |
|
max: maxItems, |
|
required: true |
|
})]; |
|
} |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/radio-control/index.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
function RadioControl(_ref) { |
|
var label = _ref.label, |
|
className = _ref.className, |
|
selected = _ref.selected, |
|
help = _ref.help, |
|
instanceId = _ref.instanceId, |
|
onChange = _ref.onChange, |
|
_ref$options = _ref.options, |
|
options = _ref$options === void 0 ? [] : _ref$options; |
|
var id = "inspector-radio-control-".concat(instanceId); |
|
|
|
var onChangeValue = function onChangeValue(event) { |
|
return onChange(event.target.value); |
|
}; |
|
|
|
return !Object(external_lodash_["isEmpty"])(options) && Object(external_this_wp_element_["createElement"])(base_control, { |
|
label: label, |
|
id: id, |
|
help: help, |
|
className: classnames_default()(className, 'components-radio-control') |
|
}, options.map(function (option, index) { |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
key: "".concat(id, "-").concat(index), |
|
className: "components-radio-control__option" |
|
}, Object(external_this_wp_element_["createElement"])("input", { |
|
id: "".concat(id, "-").concat(index), |
|
className: "components-radio-control__input", |
|
type: "radio", |
|
name: id, |
|
value: option.value, |
|
onChange: onChangeValue, |
|
checked: option.value === selected, |
|
"aria-describedby": !!help ? "".concat(id, "__help") : undefined |
|
}), Object(external_this_wp_element_["createElement"])("label", { |
|
htmlFor: "".concat(id, "-").concat(index) |
|
}, option.label)); |
|
})); |
|
} |
|
|
|
/* harmony default export */ var radio_control = (Object(external_this_wp_compose_["withInstanceId"])(RadioControl)); |
|
|
|
// EXTERNAL MODULE: ./node_modules/re-resizable/lib/index.js |
|
var re_resizable_lib = __webpack_require__(227); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/resizable-box/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
|
|
function ResizableBox(_ref) { |
|
var className = _ref.className, |
|
props = Object(objectWithoutProperties["a" /* default */])(_ref, ["className"]); |
|
|
|
// Removes the inline styles in the drag handles. |
|
var handleStylesOverrides = { |
|
width: null, |
|
height: null, |
|
top: null, |
|
right: null, |
|
bottom: null, |
|
left: null |
|
}; |
|
var handleClassName = 'components-resizable-box__handle'; |
|
var sideHandleClassName = 'components-resizable-box__side-handle'; |
|
var cornerHandleClassName = 'components-resizable-box__corner-handle'; |
|
return Object(external_this_wp_element_["createElement"])(re_resizable_lib["Resizable"], Object(esm_extends["a" /* default */])({ |
|
className: classnames_default()('components-resizable-box__container', className), |
|
handleClasses: { |
|
top: classnames_default()(handleClassName, sideHandleClassName, 'components-resizable-box__handle-top'), |
|
right: classnames_default()(handleClassName, sideHandleClassName, 'components-resizable-box__handle-right'), |
|
bottom: classnames_default()(handleClassName, sideHandleClassName, 'components-resizable-box__handle-bottom'), |
|
left: classnames_default()(handleClassName, sideHandleClassName, 'components-resizable-box__handle-left'), |
|
topLeft: classnames_default()(handleClassName, cornerHandleClassName, 'components-resizable-box__handle-top', 'components-resizable-box__handle-left'), |
|
topRight: classnames_default()(handleClassName, cornerHandleClassName, 'components-resizable-box__handle-top', 'components-resizable-box__handle-right'), |
|
bottomRight: classnames_default()(handleClassName, cornerHandleClassName, 'components-resizable-box__handle-bottom', 'components-resizable-box__handle-right'), |
|
bottomLeft: classnames_default()(handleClassName, cornerHandleClassName, 'components-resizable-box__handle-bottom', 'components-resizable-box__handle-left') |
|
}, |
|
handleStyles: { |
|
top: handleStylesOverrides, |
|
right: handleStylesOverrides, |
|
bottom: handleStylesOverrides, |
|
left: handleStylesOverrides, |
|
topLeft: handleStylesOverrides, |
|
topRight: handleStylesOverrides, |
|
bottomRight: handleStylesOverrides, |
|
bottomLeft: handleStylesOverrides |
|
} |
|
}, props)); |
|
} |
|
|
|
/* harmony default export */ var resizable_box = (ResizableBox); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/responsive-wrapper/index.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
function ResponsiveWrapper(_ref) { |
|
var naturalWidth = _ref.naturalWidth, |
|
naturalHeight = _ref.naturalHeight, |
|
children = _ref.children, |
|
_ref$isInline = _ref.isInline, |
|
isInline = _ref$isInline === void 0 ? false : _ref$isInline; |
|
|
|
if (external_this_wp_element_["Children"].count(children) !== 1) { |
|
return null; |
|
} |
|
|
|
var imageStyle = { |
|
paddingBottom: naturalHeight / naturalWidth * 100 + '%' |
|
}; |
|
var TagName = isInline ? 'span' : 'div'; |
|
return Object(external_this_wp_element_["createElement"])(TagName, { |
|
className: "components-responsive-wrapper" |
|
}, Object(external_this_wp_element_["createElement"])(TagName, { |
|
style: imageStyle |
|
}), Object(external_this_wp_element_["cloneElement"])(children, { |
|
className: classnames_default()('components-responsive-wrapper__content', children.props.className) |
|
})); |
|
} |
|
|
|
/* harmony default export */ var responsive_wrapper = (ResponsiveWrapper); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/sandbox/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
var sandbox_Sandbox = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Sandbox, _Component); |
|
|
|
function Sandbox() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Sandbox); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Sandbox).apply(this, arguments)); |
|
_this.trySandbox = _this.trySandbox.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.checkMessageForResize = _this.checkMessageForResize.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.iframe = Object(external_this_wp_element_["createRef"])(); |
|
_this.state = { |
|
width: 0, |
|
height: 0 |
|
}; |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(Sandbox, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
this.trySandbox(); |
|
} |
|
}, { |
|
key: "componentDidUpdate", |
|
value: function componentDidUpdate() { |
|
this.trySandbox(); |
|
} |
|
}, { |
|
key: "isFrameAccessible", |
|
value: function isFrameAccessible() { |
|
try { |
|
return !!this.iframe.current.contentDocument.body; |
|
} catch (e) { |
|
return false; |
|
} |
|
} |
|
}, { |
|
key: "checkMessageForResize", |
|
value: function checkMessageForResize(event) { |
|
var iframe = this.iframe.current; // Attempt to parse the message data as JSON if passed as string |
|
|
|
var data = event.data || {}; |
|
|
|
if ('string' === typeof data) { |
|
try { |
|
data = JSON.parse(data); |
|
} catch (e) {} |
|
} // Verify that the mounted element is the source of the message |
|
|
|
|
|
if (!iframe || iframe.contentWindow !== event.source) { |
|
return; |
|
} // Update the state only if the message is formatted as we expect, i.e. |
|
// as an object with a 'resize' action, width, and height |
|
|
|
|
|
var _data = data, |
|
action = _data.action, |
|
width = _data.width, |
|
height = _data.height; |
|
var _this$state = this.state, |
|
oldWidth = _this$state.width, |
|
oldHeight = _this$state.height; |
|
|
|
if ('resize' === action && (oldWidth !== width || oldHeight !== height)) { |
|
this.setState({ |
|
width: width, |
|
height: height |
|
}); |
|
} |
|
} |
|
}, { |
|
key: "trySandbox", |
|
value: function trySandbox() { |
|
if (!this.isFrameAccessible()) { |
|
return; |
|
} |
|
|
|
var body = this.iframe.current.contentDocument.body; |
|
|
|
if (null !== body.getAttribute('data-resizable-iframe-connected')) { |
|
return; |
|
} |
|
|
|
var observeAndResizeJS = "\n\t\t\t( function() {\n\t\t\t\tvar observer;\n\n\t\t\t\tif ( ! window.MutationObserver || ! document.body || ! window.parent ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tfunction sendResize() {\n\t\t\t\t\tvar clientBoundingRect = document.body.getBoundingClientRect();\n\n\t\t\t\t\twindow.parent.postMessage( {\n\t\t\t\t\t\taction: 'resize',\n\t\t\t\t\t\twidth: clientBoundingRect.width,\n\t\t\t\t\t\theight: clientBoundingRect.height,\n\t\t\t\t\t}, '*' );\n\t\t\t\t}\n\n\t\t\t\tobserver = new MutationObserver( sendResize );\n\t\t\t\tobserver.observe( document.body, {\n\t\t\t\t\tattributes: true,\n\t\t\t\t\tattributeOldValue: false,\n\t\t\t\t\tcharacterData: true,\n\t\t\t\t\tcharacterDataOldValue: false,\n\t\t\t\t\tchildList: true,\n\t\t\t\t\tsubtree: true\n\t\t\t\t} );\n\n\t\t\t\twindow.addEventListener( 'load', sendResize, true );\n\n\t\t\t\t// Hack: Remove viewport unit styles, as these are relative\n\t\t\t\t// the iframe root and interfere with our mechanism for\n\t\t\t\t// determining the unconstrained page bounds.\n\t\t\t\tfunction removeViewportStyles( ruleOrNode ) {\n\t\t\t\t\tif( ruleOrNode.style ) {\n\t\t\t\t\t\t[ 'width', 'height', 'minHeight', 'maxHeight' ].forEach( function( style ) {\n\t\t\t\t\t\t\tif ( /^\\d+(vmin|vmax|vh|vw)$/.test( ruleOrNode.style[ style ] ) ) {\n\t\t\t\t\t\t\t\truleOrNode.style[ style ] = '';\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tArray.prototype.forEach.call( document.querySelectorAll( '[style]' ), removeViewportStyles );\n\t\t\t\tArray.prototype.forEach.call( document.styleSheets, function( stylesheet ) {\n\t\t\t\t\tArray.prototype.forEach.call( stylesheet.cssRules || stylesheet.rules, removeViewportStyles );\n\t\t\t\t} );\n\n\t\t\t\tdocument.body.style.position = 'absolute';\n\t\t\t\tdocument.body.style.width = '100%';\n\t\t\t\tdocument.body.setAttribute( 'data-resizable-iframe-connected', '' );\n\n\t\t\t\tsendResize();\n\n\t\t\t\t// Resize events can change the width of elements with 100% width, but we don't\n\t\t\t\t// get an DOM mutations for that, so do the resize when the window is resized, too.\n\t\t\t\twindow.addEventListener( 'resize', sendResize, true );\n\t\t} )();"; |
|
var style = "\n\t\t\tbody {\n\t\t\t\tmargin: 0;\n\t\t\t}\n\t\t\thtml,\n\t\t\tbody,\n\t\t\tbody > div,\n\t\t\tbody > div > iframe {\n\t\t\t\twidth: 100%;\n\t\t\t}\n\t\t\thtml.wp-has-aspect-ratio,\n\t\t\tbody.wp-has-aspect-ratio,\n\t\t\tbody.wp-has-aspect-ratio > div,\n\t\t\tbody.wp-has-aspect-ratio > div > iframe {\n\t\t\t\theight: 100%;\n\t\t\t\toverflow: hidden; /* If it has an aspect ratio, it shouldn't scroll. */\n\t\t\t}\n\t\t\tbody > div > * {\n\t\t\t\tmargin-top: 0 !important; /* Has to have !important to override inline styles. */\n\t\t\t\tmargin-bottom: 0 !important;\n\t\t\t}\n\t\t"; // put the html snippet into a html document, and then write it to the iframe's document |
|
// we can use this in the future to inject custom styles or scripts. |
|
// Scripts go into the body rather than the head, to support embedded content such as Instagram |
|
// that expect the scripts to be part of the body. |
|
|
|
var htmlDoc = Object(external_this_wp_element_["createElement"])("html", { |
|
lang: document.documentElement.lang, |
|
className: this.props.type |
|
}, Object(external_this_wp_element_["createElement"])("head", null, Object(external_this_wp_element_["createElement"])("title", null, this.props.title), Object(external_this_wp_element_["createElement"])("style", { |
|
dangerouslySetInnerHTML: { |
|
__html: style |
|
} |
|
}), this.props.styles && this.props.styles.map(function (rules, i) { |
|
return Object(external_this_wp_element_["createElement"])("style", { |
|
key: i, |
|
dangerouslySetInnerHTML: { |
|
__html: rules |
|
} |
|
}); |
|
})), Object(external_this_wp_element_["createElement"])("body", { |
|
"data-resizable-iframe-connected": "data-resizable-iframe-connected", |
|
className: this.props.type |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
dangerouslySetInnerHTML: { |
|
__html: this.props.html |
|
} |
|
}), Object(external_this_wp_element_["createElement"])("script", { |
|
type: "text/javascript", |
|
dangerouslySetInnerHTML: { |
|
__html: observeAndResizeJS |
|
} |
|
}), this.props.scripts && this.props.scripts.map(function (src) { |
|
return Object(external_this_wp_element_["createElement"])("script", { |
|
key: src, |
|
src: src |
|
}); |
|
}))); // writing the document like this makes it act in the same way as if it was |
|
// loaded over the network, so DOM creation and mutation, script execution, etc. |
|
// all work as expected |
|
|
|
var iframeDocument = this.iframe.current.contentWindow.document; |
|
iframeDocument.open(); |
|
iframeDocument.write('<!DOCTYPE html>' + Object(external_this_wp_element_["renderToString"])(htmlDoc)); |
|
iframeDocument.close(); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
title = _this$props.title, |
|
onFocus = _this$props.onFocus; |
|
return Object(external_this_wp_element_["createElement"])(focusable_iframe, { |
|
iframeRef: this.iframe, |
|
title: title, |
|
className: "components-sandbox", |
|
sandbox: "allow-scripts allow-same-origin allow-presentation", |
|
onLoad: this.trySandbox, |
|
onFocus: onFocus, |
|
width: Math.ceil(this.state.width), |
|
height: Math.ceil(this.state.height) |
|
}); |
|
} |
|
}], [{ |
|
key: "defaultProps", |
|
get: function get() { |
|
return { |
|
html: '', |
|
title: '' |
|
}; |
|
} |
|
}]); |
|
|
|
return Sandbox; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
sandbox_Sandbox = Object(external_this_wp_compose_["withGlobalEvents"])({ |
|
message: 'checkMessageForResize' |
|
})(sandbox_Sandbox); |
|
/* harmony default export */ var sandbox = (sandbox_Sandbox); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/snackbar/index.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
var NOTICE_TIMEOUT = 10000; |
|
|
|
function Snackbar(_ref, ref) { |
|
var className = _ref.className, |
|
children = _ref.children, |
|
_ref$actions = _ref.actions, |
|
actions = _ref$actions === void 0 ? [] : _ref$actions, |
|
_ref$onRemove = _ref.onRemove, |
|
onRemove = _ref$onRemove === void 0 ? external_lodash_["noop"] : _ref$onRemove; |
|
Object(external_this_wp_element_["useEffect"])(function () { |
|
var timeoutHandle = setTimeout(function () { |
|
onRemove(); |
|
}, NOTICE_TIMEOUT); |
|
return function () { |
|
return clearTimeout(timeoutHandle); |
|
}; |
|
}, []); |
|
var classes = classnames_default()(className, 'components-snackbar'); |
|
|
|
if (actions && actions.length > 1) { |
|
// we need to inform developers that snackbar only accepts 1 action |
|
// eslint-disable-next-line no-console |
|
console.warn('Snackbar can only have 1 action, use Notice if your message require many messages'); // return first element only while keeping it inside an array |
|
|
|
actions = [actions[0]]; |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
ref: ref, |
|
className: classes, |
|
onClick: onRemove, |
|
tabIndex: "0", |
|
role: "button", |
|
onKeyPress: onRemove, |
|
label: Object(external_this_wp_i18n_["__"])('Dismiss this notice') |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-snackbar__content" |
|
}, children, actions.map(function (_ref2, index) { |
|
var label = _ref2.label, |
|
_onClick = _ref2.onClick, |
|
url = _ref2.url; |
|
return Object(external_this_wp_element_["createElement"])(build_module_button, { |
|
key: index, |
|
href: url, |
|
isTertiary: true, |
|
onClick: function onClick(event) { |
|
event.stopPropagation(); |
|
|
|
if (_onClick) { |
|
_onClick(event); |
|
} |
|
}, |
|
className: "components-snackbar__action" |
|
}, label); |
|
}))); |
|
} |
|
|
|
/* harmony default export */ var snackbar = (Object(external_this_wp_element_["forwardRef"])(Snackbar)); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/regenerator/index.js |
|
var regenerator = __webpack_require__(20); |
|
var regenerator_default = /*#__PURE__*/__webpack_require__.n(regenerator); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js |
|
var asyncToGenerator = __webpack_require__(43); |
|
|
|
// EXTERNAL MODULE: ./node_modules/react-spring/web.cjs.js |
|
var web_cjs = __webpack_require__(64); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/snackbar/list.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Renders a list of notices. |
|
* |
|
* @param {Object} $0 Props passed to the component. |
|
* @param {Array} $0.notices Array of notices to render. |
|
* @param {Function} $0.onRemove Function called when a notice should be removed / dismissed. |
|
* @param {Object} $0.className Name of the class used by the component. |
|
* @param {Object} $0.children Array of children to be rendered inside the notice list. |
|
* @return {Object} The rendered notices list. |
|
*/ |
|
|
|
function SnackbarList(_ref) { |
|
var notices = _ref.notices, |
|
className = _ref.className, |
|
children = _ref.children, |
|
_ref$onRemove = _ref.onRemove, |
|
onRemove = _ref$onRemove === void 0 ? external_lodash_["noop"] : _ref$onRemove; |
|
var isReducedMotion = Object(external_this_wp_compose_["useReducedMotion"])(); |
|
|
|
var _useState = Object(external_this_wp_element_["useState"])(function () { |
|
return new WeakMap(); |
|
}), |
|
_useState2 = Object(slicedToArray["a" /* default */])(_useState, 1), |
|
refMap = _useState2[0]; |
|
|
|
var transitions = Object(web_cjs["useTransition"])(notices, function (notice) { |
|
return notice.id; |
|
}, { |
|
from: { |
|
opacity: 0, |
|
height: 0 |
|
}, |
|
enter: function enter(item) { |
|
return ( |
|
/*#__PURE__*/ |
|
function () { |
|
var _ref2 = Object(asyncToGenerator["a" /* default */])( |
|
/*#__PURE__*/ |
|
regenerator_default.a.mark(function _callee(next) { |
|
return regenerator_default.a.wrap(function _callee$(_context) { |
|
while (1) { |
|
switch (_context.prev = _context.next) { |
|
case 0: |
|
_context.next = 2; |
|
return next({ |
|
opacity: 1, |
|
height: refMap.get(item).offsetHeight |
|
}); |
|
|
|
case 2: |
|
return _context.abrupt("return", _context.sent); |
|
|
|
case 3: |
|
case "end": |
|
return _context.stop(); |
|
} |
|
} |
|
}, _callee); |
|
})); |
|
|
|
return function (_x) { |
|
return _ref2.apply(this, arguments); |
|
}; |
|
}() |
|
); |
|
}, |
|
leave: function leave() { |
|
return ( |
|
/*#__PURE__*/ |
|
function () { |
|
var _ref3 = Object(asyncToGenerator["a" /* default */])( |
|
/*#__PURE__*/ |
|
regenerator_default.a.mark(function _callee2(next) { |
|
return regenerator_default.a.wrap(function _callee2$(_context2) { |
|
while (1) { |
|
switch (_context2.prev = _context2.next) { |
|
case 0: |
|
_context2.next = 2; |
|
return next({ |
|
opacity: 0 |
|
}); |
|
|
|
case 2: |
|
_context2.next = 4; |
|
return next({ |
|
height: 0 |
|
}); |
|
|
|
case 4: |
|
case "end": |
|
return _context2.stop(); |
|
} |
|
} |
|
}, _callee2); |
|
})); |
|
|
|
return function (_x2) { |
|
return _ref3.apply(this, arguments); |
|
}; |
|
}() |
|
); |
|
}, |
|
immediate: isReducedMotion |
|
}); |
|
className = classnames_default()('components-snackbar-list', className); |
|
|
|
var removeNotice = function removeNotice(notice) { |
|
return function () { |
|
return onRemove(notice.id); |
|
}; |
|
}; |
|
|
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: className |
|
}, children, transitions.map(function (_ref4) { |
|
var notice = _ref4.item, |
|
key = _ref4.key, |
|
style = _ref4.props; |
|
return Object(external_this_wp_element_["createElement"])(web_cjs["animated"].div, { |
|
key: key, |
|
style: style |
|
}, Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-snackbar-list__notice-container", |
|
ref: function ref(_ref5) { |
|
return _ref5 && refMap.set(notice, _ref5); |
|
} |
|
}, Object(external_this_wp_element_["createElement"])(snackbar, Object(esm_extends["a" /* default */])({}, Object(external_lodash_["omit"])(notice, ['content']), { |
|
onRemove: removeNotice(notice) |
|
}), notice.content))); |
|
})); |
|
} |
|
|
|
/* harmony default export */ var snackbar_list = (SnackbarList); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/spinner/index.js |
|
|
|
function Spinner() { |
|
return Object(external_this_wp_element_["createElement"])("span", { |
|
className: "components-spinner" |
|
}); |
|
} |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/tab-panel/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
var tab_panel_TabButton = function TabButton(_ref) { |
|
var tabId = _ref.tabId, |
|
onClick = _ref.onClick, |
|
children = _ref.children, |
|
selected = _ref.selected, |
|
rest = Object(objectWithoutProperties["a" /* default */])(_ref, ["tabId", "onClick", "children", "selected"]); |
|
|
|
return Object(external_this_wp_element_["createElement"])(build_module_button, Object(esm_extends["a" /* default */])({ |
|
role: "tab", |
|
tabIndex: selected ? null : -1, |
|
"aria-selected": selected, |
|
id: tabId, |
|
onClick: onClick |
|
}, rest), children); |
|
}; |
|
|
|
var tab_panel_TabPanel = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(TabPanel, _Component); |
|
|
|
function TabPanel() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, TabPanel); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(TabPanel).apply(this, arguments)); |
|
var _this$props = _this.props, |
|
tabs = _this$props.tabs, |
|
initialTabName = _this$props.initialTabName; |
|
_this.handleClick = _this.handleClick.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.onNavigate = _this.onNavigate.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.state = { |
|
selected: initialTabName || (tabs.length > 0 ? tabs[0].name : null) |
|
}; |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(TabPanel, [{ |
|
key: "handleClick", |
|
value: function handleClick(tabKey) { |
|
var _this$props$onSelect = this.props.onSelect, |
|
onSelect = _this$props$onSelect === void 0 ? external_lodash_["noop"] : _this$props$onSelect; |
|
this.setState({ |
|
selected: tabKey |
|
}); |
|
onSelect(tabKey); |
|
} |
|
}, { |
|
key: "onNavigate", |
|
value: function onNavigate(childIndex, child) { |
|
child.click(); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this2 = this; |
|
|
|
var selected = this.state.selected; |
|
var _this$props2 = this.props, |
|
_this$props2$activeCl = _this$props2.activeClass, |
|
activeClass = _this$props2$activeCl === void 0 ? 'is-active' : _this$props2$activeCl, |
|
className = _this$props2.className, |
|
instanceId = _this$props2.instanceId, |
|
_this$props2$orientat = _this$props2.orientation, |
|
orientation = _this$props2$orientat === void 0 ? 'horizontal' : _this$props2$orientat, |
|
tabs = _this$props2.tabs; |
|
var selectedTab = Object(external_lodash_["find"])(tabs, { |
|
name: selected |
|
}); |
|
var selectedId = instanceId + '-' + selectedTab.name; |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: className |
|
}, Object(external_this_wp_element_["createElement"])(menu, { |
|
role: "tablist", |
|
orientation: orientation, |
|
onNavigate: this.onNavigate, |
|
className: "components-tab-panel__tabs" |
|
}, tabs.map(function (tab) { |
|
return Object(external_this_wp_element_["createElement"])(tab_panel_TabButton, { |
|
className: classnames_default()(tab.className, Object(defineProperty["a" /* default */])({}, activeClass, tab.name === selected)), |
|
tabId: instanceId + '-' + tab.name, |
|
"aria-controls": instanceId + '-' + tab.name + '-view', |
|
selected: tab.name === selected, |
|
key: tab.name, |
|
onClick: Object(external_lodash_["partial"])(_this2.handleClick, tab.name) |
|
}, tab.title); |
|
})), selectedTab && Object(external_this_wp_element_["createElement"])("div", { |
|
"aria-labelledby": selectedId, |
|
role: "tabpanel", |
|
id: selectedId + '-view', |
|
className: "components-tab-panel__tab-content", |
|
tabIndex: "0" |
|
}, this.props.children(selectedTab))); |
|
} |
|
}]); |
|
|
|
return TabPanel; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var tab_panel = (Object(external_this_wp_compose_["withInstanceId"])(tab_panel_TabPanel)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/textarea-control/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
function TextareaControl(_ref) { |
|
var label = _ref.label, |
|
hideLabelFromVision = _ref.hideLabelFromVision, |
|
value = _ref.value, |
|
help = _ref.help, |
|
instanceId = _ref.instanceId, |
|
onChange = _ref.onChange, |
|
_ref$rows = _ref.rows, |
|
rows = _ref$rows === void 0 ? 4 : _ref$rows, |
|
className = _ref.className, |
|
props = Object(objectWithoutProperties["a" /* default */])(_ref, ["label", "hideLabelFromVision", "value", "help", "instanceId", "onChange", "rows", "className"]); |
|
|
|
var id = "inspector-textarea-control-".concat(instanceId); |
|
|
|
var onChangeValue = function onChangeValue(event) { |
|
return onChange(event.target.value); |
|
}; |
|
|
|
return Object(external_this_wp_element_["createElement"])(base_control, { |
|
label: label, |
|
hideLabelFromVision: hideLabelFromVision, |
|
id: id, |
|
help: help, |
|
className: className |
|
}, Object(external_this_wp_element_["createElement"])("textarea", Object(esm_extends["a" /* default */])({ |
|
className: "components-textarea-control__input", |
|
id: id, |
|
rows: rows, |
|
onChange: onChangeValue, |
|
"aria-describedby": !!help ? id + '__help' : undefined, |
|
value: value |
|
}, props))); |
|
} |
|
|
|
/* harmony default export */ var textarea_control = (Object(external_this_wp_compose_["withInstanceId"])(TextareaControl)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/tip/index.js |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
function Tip(props) { |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: "components-tip" |
|
}, Object(external_this_wp_element_["createElement"])(svg_SVG, { |
|
width: "24", |
|
height: "24", |
|
viewBox: "0 0 24 24" |
|
}, Object(external_this_wp_element_["createElement"])(svg_Path, { |
|
d: "M20.45 4.91L19.04 3.5l-1.79 1.8 1.41 1.41 1.79-1.8zM13 4h-2V1h2v3zm10 9h-3v-2h3v2zm-12 6.95v-3.96l-1-.58c-1.24-.72-2-2.04-2-3.46 0-2.21 1.79-4 4-4s4 1.79 4 4c0 1.42-.77 2.74-2 3.46l-1 .58v3.96h-2zm-2 2h6v-4.81c1.79-1.04 3-2.97 3-5.19 0-3.31-2.69-6-6-6s-6 2.69-6 6c0 2.22 1.21 4.15 3 5.19v4.81zM4 13H1v-2h3v2zm2.76-7.71l-1.79-1.8L3.56 4.9l1.8 1.79 1.4-1.4z" |
|
})), Object(external_this_wp_element_["createElement"])("p", null, props.children)); |
|
} |
|
|
|
/* harmony default export */ var tip = (Tip); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/toggle-control/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
var toggle_control_ToggleControl = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(ToggleControl, _Component); |
|
|
|
function ToggleControl() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, ToggleControl); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(ToggleControl).apply(this, arguments)); |
|
_this.onChange = _this.onChange.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(ToggleControl, [{ |
|
key: "onChange", |
|
value: function onChange(event) { |
|
if (this.props.onChange) { |
|
this.props.onChange(event.target.checked); |
|
} |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _this$props = this.props, |
|
label = _this$props.label, |
|
checked = _this$props.checked, |
|
help = _this$props.help, |
|
instanceId = _this$props.instanceId, |
|
className = _this$props.className; |
|
var id = "inspector-toggle-control-".concat(instanceId); |
|
var describedBy, helpLabel; |
|
|
|
if (help) { |
|
describedBy = id + '__help'; |
|
helpLabel = Object(external_lodash_["isFunction"])(help) ? help(checked) : help; |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])(base_control, { |
|
id: id, |
|
help: helpLabel, |
|
className: classnames_default()('components-toggle-control', className) |
|
}, Object(external_this_wp_element_["createElement"])(form_toggle, { |
|
id: id, |
|
checked: checked, |
|
onChange: this.onChange, |
|
"aria-describedby": describedBy |
|
}), Object(external_this_wp_element_["createElement"])("label", { |
|
htmlFor: id, |
|
className: "components-toggle-control__label" |
|
}, label)); |
|
} |
|
}]); |
|
|
|
return ToggleControl; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
/* harmony default export */ var toggle_control = (Object(external_this_wp_compose_["withInstanceId"])(toggle_control_ToggleControl)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/toolbar-button/toolbar-button-container.js |
|
|
|
|
|
var toolbar_button_container_ToolbarButtonContainer = function ToolbarButtonContainer(props) { |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: props.className |
|
}, props.children); |
|
}; |
|
|
|
/* harmony default export */ var toolbar_button_container = (toolbar_button_container_ToolbarButtonContainer); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/toolbar-button/index.js |
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
function ToolbarButton(_ref) { |
|
var containerClassName = _ref.containerClassName, |
|
icon = _ref.icon, |
|
title = _ref.title, |
|
shortcut = _ref.shortcut, |
|
subscript = _ref.subscript, |
|
_onClick = _ref.onClick, |
|
className = _ref.className, |
|
isActive = _ref.isActive, |
|
isDisabled = _ref.isDisabled, |
|
extraProps = _ref.extraProps, |
|
children = _ref.children; |
|
return Object(external_this_wp_element_["createElement"])(toolbar_button_container, { |
|
className: containerClassName |
|
}, Object(external_this_wp_element_["createElement"])(icon_button, Object(esm_extends["a" /* default */])({ |
|
icon: icon, |
|
label: title, |
|
shortcut: shortcut, |
|
"data-subscript": subscript, |
|
onClick: function onClick(event) { |
|
event.stopPropagation(); |
|
|
|
_onClick(); |
|
}, |
|
className: classnames_default()('components-toolbar__control', className, { |
|
'is-active': isActive |
|
}), |
|
"aria-pressed": isActive, |
|
disabled: isDisabled |
|
}, extraProps)), children); |
|
} |
|
|
|
/* harmony default export */ var toolbar_button = (ToolbarButton); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/toolbar/toolbar-container.js |
|
|
|
|
|
var toolbar_container_ToolbarContainer = function ToolbarContainer(props) { |
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
className: props.className |
|
}, props.children); |
|
}; |
|
|
|
/* harmony default export */ var toolbar_container = (toolbar_container_ToolbarContainer); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/toolbar/index.js |
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
/** |
|
* Renders a toolbar with controls. |
|
* |
|
* The `controls` prop accepts an array of sets. A set is an array of controls. |
|
* Controls have the following shape: |
|
* |
|
* ``` |
|
* { |
|
* icon: string, |
|
* title: string, |
|
* subscript: string, |
|
* onClick: Function, |
|
* isActive: boolean, |
|
* isDisabled: boolean |
|
* } |
|
* ``` |
|
* |
|
* For convenience it is also possible to pass only an array of controls. It is |
|
* then assumed this is the only set. |
|
* |
|
* Either `controls` or `children` is required, otherwise this components |
|
* renders nothing. |
|
* |
|
* @param {Object} props |
|
* @param {Array} [props.controls] The controls to render in this toolbar. |
|
* @param {ReactElement} [props.children] Any other things to render inside the |
|
* toolbar besides the controls. |
|
* @param {string} [props.className] Class to set on the container div. |
|
* |
|
* @return {ReactElement} The rendered toolbar. |
|
*/ |
|
|
|
function Toolbar(_ref) { |
|
var _ref$controls = _ref.controls, |
|
controls = _ref$controls === void 0 ? [] : _ref$controls, |
|
children = _ref.children, |
|
className = _ref.className, |
|
isCollapsed = _ref.isCollapsed, |
|
icon = _ref.icon, |
|
label = _ref.label, |
|
otherProps = Object(objectWithoutProperties["a" /* default */])(_ref, ["controls", "children", "className", "isCollapsed", "icon", "label"]); |
|
|
|
if ((!controls || !controls.length) && !children) { |
|
return null; |
|
} // Normalize controls to nested array of objects (sets of controls) |
|
|
|
|
|
var controlSets = controls; |
|
|
|
if (!Array.isArray(controlSets[0])) { |
|
controlSets = [controlSets]; |
|
} |
|
|
|
if (isCollapsed) { |
|
return Object(external_this_wp_element_["createElement"])(dropdown_menu, { |
|
hasArrowIndicator: true, |
|
icon: icon, |
|
label: label, |
|
controls: controlSets, |
|
className: classnames_default()('components-toolbar', className) |
|
}); |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])(toolbar_container, Object(esm_extends["a" /* default */])({ |
|
className: classnames_default()('components-toolbar', className) |
|
}, otherProps), Object(external_lodash_["flatMap"])(controlSets, function (controlSet, indexOfSet) { |
|
return controlSet.map(function (control, indexOfControl) { |
|
return Object(external_this_wp_element_["createElement"])(toolbar_button, Object(esm_extends["a" /* default */])({ |
|
key: [indexOfSet, indexOfControl].join(), |
|
containerClassName: indexOfSet > 0 && indexOfControl === 0 ? 'has-left-divider' : null |
|
}, control)); |
|
}); |
|
}), children); |
|
} |
|
|
|
/* harmony default export */ var toolbar = (Toolbar); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/higher-order/navigate-regions/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
/* harmony default export */ var navigate_regions = (Object(external_this_wp_compose_["createHigherOrderComponent"])(function (WrappedComponent) { |
|
return ( |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(_class, _Component); |
|
|
|
function _class() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, _class); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).apply(this, arguments)); |
|
_this.bindContainer = _this.bindContainer.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.focusNextRegion = _this.focusRegion.bind(Object(assertThisInitialized["a" /* default */])(_this), 1); |
|
_this.focusPreviousRegion = _this.focusRegion.bind(Object(assertThisInitialized["a" /* default */])(_this), -1); |
|
_this.onClick = _this.onClick.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.state = { |
|
isFocusingRegions: false |
|
}; |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(_class, [{ |
|
key: "bindContainer", |
|
value: function bindContainer(ref) { |
|
this.container = ref; |
|
} |
|
}, { |
|
key: "focusRegion", |
|
value: function focusRegion(offset) { |
|
var regions = Object(toConsumableArray["a" /* default */])(this.container.querySelectorAll('[role="region"]')); |
|
|
|
if (!regions.length) { |
|
return; |
|
} |
|
|
|
var nextRegion = regions[0]; |
|
var selectedIndex = regions.indexOf(document.activeElement); |
|
|
|
if (selectedIndex !== -1) { |
|
var nextIndex = selectedIndex + offset; |
|
nextIndex = nextIndex === -1 ? regions.length - 1 : nextIndex; |
|
nextIndex = nextIndex === regions.length ? 0 : nextIndex; |
|
nextRegion = regions[nextIndex]; |
|
} |
|
|
|
nextRegion.focus(); |
|
this.setState({ |
|
isFocusingRegions: true |
|
}); |
|
} |
|
}, { |
|
key: "onClick", |
|
value: function onClick() { |
|
this.setState({ |
|
isFocusingRegions: false |
|
}); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var _ref; |
|
|
|
var className = classnames_default()('components-navigate-regions', { |
|
'is-focusing-regions': this.state.isFocusingRegions |
|
}); // Disable reason: Clicking the editor should dismiss the regions focus style |
|
|
|
/* eslint-disable jsx-a11y/no-static-element-interactions, jsx-a11y/click-events-have-key-events */ |
|
|
|
return Object(external_this_wp_element_["createElement"])("div", { |
|
ref: this.bindContainer, |
|
className: className, |
|
onClick: this.onClick |
|
}, Object(external_this_wp_element_["createElement"])(keyboard_shortcuts, { |
|
bindGlobal: true, |
|
shortcuts: (_ref = { |
|
'ctrl+`': this.focusNextRegion |
|
}, Object(defineProperty["a" /* default */])(_ref, external_this_wp_keycodes_["rawShortcut"].access('n'), this.focusNextRegion), Object(defineProperty["a" /* default */])(_ref, 'ctrl+shift+`', this.focusPreviousRegion), Object(defineProperty["a" /* default */])(_ref, external_this_wp_keycodes_["rawShortcut"].access('p'), this.focusPreviousRegion), _ref) |
|
}), Object(external_this_wp_element_["createElement"])(WrappedComponent, this.props)); |
|
/* eslint-enable jsx-a11y/no-static-element-interactions, jsx-a11y/click-events-have-key-events */ |
|
} |
|
}]); |
|
|
|
return _class; |
|
}(external_this_wp_element_["Component"]) |
|
); |
|
}, 'navigateRegions')); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/higher-order/with-fallback-styles/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/* harmony default export */ var with_fallback_styles = (function (mapNodeToProps) { |
|
return Object(external_this_wp_compose_["createHigherOrderComponent"])(function (WrappedComponent) { |
|
return ( |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(_class, _Component); |
|
|
|
function _class() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, _class); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).apply(this, arguments)); |
|
_this.nodeRef = _this.props.node; |
|
_this.state = { |
|
fallbackStyles: undefined, |
|
grabStylesCompleted: false |
|
}; |
|
_this.bindRef = _this.bindRef.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(_class, [{ |
|
key: "bindRef", |
|
value: function bindRef(node) { |
|
if (!node) { |
|
return; |
|
} |
|
|
|
this.nodeRef = node; |
|
} |
|
}, { |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
this.grabFallbackStyles(); |
|
} |
|
}, { |
|
key: "componentDidUpdate", |
|
value: function componentDidUpdate() { |
|
this.grabFallbackStyles(); |
|
} |
|
}, { |
|
key: "grabFallbackStyles", |
|
value: function grabFallbackStyles() { |
|
var _this$state = this.state, |
|
grabStylesCompleted = _this$state.grabStylesCompleted, |
|
fallbackStyles = _this$state.fallbackStyles; |
|
|
|
if (this.nodeRef && !grabStylesCompleted) { |
|
var newFallbackStyles = mapNodeToProps(this.nodeRef, this.props); |
|
|
|
if (!Object(external_lodash_["isEqual"])(newFallbackStyles, fallbackStyles)) { |
|
this.setState({ |
|
fallbackStyles: newFallbackStyles, |
|
grabStylesCompleted: !!Object(external_lodash_["every"])(newFallbackStyles) |
|
}); |
|
} |
|
} |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
var wrappedComponent = Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props, this.state.fallbackStyles)); |
|
return this.props.node ? wrappedComponent : Object(external_this_wp_element_["createElement"])("div", { |
|
ref: this.bindRef |
|
}, " ", wrappedComponent, " "); |
|
} |
|
}]); |
|
|
|
return _class; |
|
}(external_this_wp_element_["Component"]) |
|
); |
|
}, 'withFallbackStyles'); |
|
}); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","hooks"]} |
|
var external_this_wp_hooks_ = __webpack_require__(27); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/higher-order/with-filters/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
var ANIMATION_FRAME_PERIOD = 16; |
|
/** |
|
* Creates a higher-order component which adds filtering capability to the |
|
* wrapped component. Filters get applied when the original component is about |
|
* to be mounted. When a filter is added or removed that matches the hook name, |
|
* the wrapped component re-renders. |
|
* |
|
* @param {string} hookName Hook name exposed to be used by filters. |
|
* |
|
* @return {Function} Higher-order component factory. |
|
*/ |
|
|
|
function withFilters(hookName) { |
|
return Object(external_this_wp_compose_["createHigherOrderComponent"])(function (OriginalComponent) { |
|
var namespace = 'core/with-filters/' + hookName; |
|
/** |
|
* The component definition with current filters applied. Each instance |
|
* reuse this shared reference as an optimization to avoid excessive |
|
* calls to `applyFilters` when many instances exist. |
|
* |
|
* @type {?Component} |
|
*/ |
|
|
|
var FilteredComponent; |
|
/** |
|
* Initializes the FilteredComponent variable once, if not already |
|
* assigned. Subsequent calls are effectively a noop. |
|
*/ |
|
|
|
function ensureFilteredComponent() { |
|
if (FilteredComponent === undefined) { |
|
FilteredComponent = Object(external_this_wp_hooks_["applyFilters"])(hookName, OriginalComponent); |
|
} |
|
} |
|
|
|
var FilteredComponentRenderer = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(FilteredComponentRenderer, _Component); |
|
|
|
function FilteredComponentRenderer() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, FilteredComponentRenderer); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(FilteredComponentRenderer).apply(this, arguments)); |
|
ensureFilteredComponent(); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(FilteredComponentRenderer, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
FilteredComponentRenderer.instances.push(this); // If there were previously no mounted instances for components |
|
// filtered on this hook, add the hook handler. |
|
|
|
if (FilteredComponentRenderer.instances.length === 1) { |
|
Object(external_this_wp_hooks_["addAction"])('hookRemoved', namespace, onHooksUpdated); |
|
Object(external_this_wp_hooks_["addAction"])('hookAdded', namespace, onHooksUpdated); |
|
} |
|
} |
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
FilteredComponentRenderer.instances = Object(external_lodash_["without"])(FilteredComponentRenderer.instances, this); // If this was the last of the mounted components filtered on |
|
// this hook, remove the hook handler. |
|
|
|
if (FilteredComponentRenderer.instances.length === 0) { |
|
Object(external_this_wp_hooks_["removeAction"])('hookRemoved', namespace); |
|
Object(external_this_wp_hooks_["removeAction"])('hookAdded', namespace); |
|
} |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
return Object(external_this_wp_element_["createElement"])(FilteredComponent, this.props); |
|
} |
|
}]); |
|
|
|
return FilteredComponentRenderer; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
FilteredComponentRenderer.instances = []; |
|
/** |
|
* Updates the FilteredComponent definition, forcing a render for each |
|
* mounted instance. This occurs a maximum of once per animation frame. |
|
*/ |
|
|
|
var throttledForceUpdate = Object(external_lodash_["debounce"])(function () { |
|
// Recreate the filtered component, only after delay so that it's |
|
// computed once, even if many filters added. |
|
FilteredComponent = Object(external_this_wp_hooks_["applyFilters"])(hookName, OriginalComponent); // Force each instance to render. |
|
|
|
FilteredComponentRenderer.instances.forEach(function (instance) { |
|
instance.forceUpdate(); |
|
}); |
|
}, ANIMATION_FRAME_PERIOD); |
|
/** |
|
* When a filter is added or removed for the matching hook name, each |
|
* mounted instance should re-render with the new filters having been |
|
* applied to the original component. |
|
* |
|
* @param {string} updatedHookName Name of the hook that was updated. |
|
*/ |
|
|
|
function onHooksUpdated(updatedHookName) { |
|
if (updatedHookName === hookName) { |
|
throttledForceUpdate(); |
|
} |
|
} |
|
|
|
return FilteredComponentRenderer; |
|
}, 'withFilters'); |
|
} |
|
|
|
// EXTERNAL MODULE: ./node_modules/uuid/v4.js |
|
var v4 = __webpack_require__(67); |
|
var v4_default = /*#__PURE__*/__webpack_require__.n(v4); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/higher-order/with-notices/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Override the default edit UI to include notices if supported. |
|
* |
|
* @param {Function|Component} OriginalComponent Original component. |
|
* @return {Component} Wrapped component. |
|
*/ |
|
|
|
/* harmony default export */ var with_notices = (Object(external_this_wp_compose_["createHigherOrderComponent"])(function (OriginalComponent) { |
|
return ( |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(WrappedBlockEdit, _Component); |
|
|
|
function WrappedBlockEdit() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, WrappedBlockEdit); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(WrappedBlockEdit).apply(this, arguments)); |
|
_this.createNotice = _this.createNotice.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.createErrorNotice = _this.createErrorNotice.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.removeNotice = _this.removeNotice.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.removeAllNotices = _this.removeAllNotices.bind(Object(assertThisInitialized["a" /* default */])(_this)); |
|
_this.state = { |
|
noticeList: [] |
|
}; |
|
_this.noticeOperations = { |
|
createNotice: _this.createNotice, |
|
createErrorNotice: _this.createErrorNotice, |
|
removeAllNotices: _this.removeAllNotices, |
|
removeNotice: _this.removeNotice |
|
}; |
|
return _this; |
|
} |
|
/** |
|
* Function passed down as a prop that adds a new notice. |
|
* |
|
* @param {Object} notice Notice to add. |
|
*/ |
|
|
|
|
|
Object(createClass["a" /* default */])(WrappedBlockEdit, [{ |
|
key: "createNotice", |
|
value: function createNotice(notice) { |
|
var noticeToAdd = notice.id ? notice : Object(objectSpread["a" /* default */])({}, notice, { |
|
id: v4_default()() |
|
}); |
|
this.setState(function (state) { |
|
return { |
|
noticeList: [].concat(Object(toConsumableArray["a" /* default */])(state.noticeList), [noticeToAdd]) |
|
}; |
|
}); |
|
} |
|
/** |
|
* Function passed as a prop that adds a new error notice. |
|
* |
|
* @param {string} msg Error message of the notice. |
|
*/ |
|
|
|
}, { |
|
key: "createErrorNotice", |
|
value: function createErrorNotice(msg) { |
|
this.createNotice({ |
|
status: 'error', |
|
content: msg |
|
}); |
|
} |
|
/** |
|
* Removes a notice by id. |
|
* |
|
* @param {string} id Id of the notice to remove. |
|
*/ |
|
|
|
}, { |
|
key: "removeNotice", |
|
value: function removeNotice(id) { |
|
this.setState(function (state) { |
|
return { |
|
noticeList: state.noticeList.filter(function (notice) { |
|
return notice.id !== id; |
|
}) |
|
}; |
|
}); |
|
} |
|
/** |
|
* Removes all notices |
|
*/ |
|
|
|
}, { |
|
key: "removeAllNotices", |
|
value: function removeAllNotices() { |
|
this.setState({ |
|
noticeList: [] |
|
}); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({ |
|
noticeList: this.state.noticeList, |
|
noticeOperations: this.noticeOperations, |
|
noticeUI: this.state.noticeList.length > 0 && Object(external_this_wp_element_["createElement"])(list, { |
|
className: "components-with-notices-ui", |
|
notices: this.state.noticeList, |
|
onRemove: this.removeNotice |
|
}) |
|
}, this.props)); |
|
} |
|
}]); |
|
|
|
return WrappedBlockEdit; |
|
}(external_this_wp_element_["Component"]) |
|
); |
|
})); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/index.js |
|
/* concated harmony reexport Circle */__webpack_require__.d(__webpack_exports__, "Circle", function() { return svg_Circle; }); |
|
/* concated harmony reexport G */__webpack_require__.d(__webpack_exports__, "G", function() { return svg_G; }); |
|
/* concated harmony reexport Path */__webpack_require__.d(__webpack_exports__, "Path", function() { return svg_Path; }); |
|
/* concated harmony reexport Polygon */__webpack_require__.d(__webpack_exports__, "Polygon", function() { return svg_Polygon; }); |
|
/* concated harmony reexport Rect */__webpack_require__.d(__webpack_exports__, "Rect", function() { return svg_Rect; }); |
|
/* concated harmony reexport SVG */__webpack_require__.d(__webpack_exports__, "SVG", function() { return svg_SVG; }); |
|
/* concated harmony reexport HorizontalRule */__webpack_require__.d(__webpack_exports__, "HorizontalRule", function() { return HorizontalRule; }); |
|
/* concated harmony reexport BlockQuotation */__webpack_require__.d(__webpack_exports__, "BlockQuotation", function() { return BlockQuotation; }); |
|
/* concated harmony reexport Animate */__webpack_require__.d(__webpack_exports__, "Animate", function() { return build_module_animate; }); |
|
/* concated harmony reexport Autocomplete */__webpack_require__.d(__webpack_exports__, "Autocomplete", function() { return autocomplete; }); |
|
/* concated harmony reexport BaseControl */__webpack_require__.d(__webpack_exports__, "BaseControl", function() { return base_control; }); |
|
/* concated harmony reexport Button */__webpack_require__.d(__webpack_exports__, "Button", function() { return build_module_button; }); |
|
/* concated harmony reexport ButtonGroup */__webpack_require__.d(__webpack_exports__, "ButtonGroup", function() { return button_group; }); |
|
/* concated harmony reexport CheckboxControl */__webpack_require__.d(__webpack_exports__, "CheckboxControl", function() { return checkbox_control; }); |
|
/* concated harmony reexport ClipboardButton */__webpack_require__.d(__webpack_exports__, "ClipboardButton", function() { return clipboard_button; }); |
|
/* concated harmony reexport ColorIndicator */__webpack_require__.d(__webpack_exports__, "ColorIndicator", function() { return color_indicator; }); |
|
/* concated harmony reexport ColorPalette */__webpack_require__.d(__webpack_exports__, "ColorPalette", function() { return ColorPalette; }); |
|
/* concated harmony reexport ColorPicker */__webpack_require__.d(__webpack_exports__, "ColorPicker", function() { return color_picker_ColorPicker; }); |
|
/* concated harmony reexport Dashicon */__webpack_require__.d(__webpack_exports__, "Dashicon", function() { return dashicon_Dashicon; }); |
|
/* concated harmony reexport DateTimePicker */__webpack_require__.d(__webpack_exports__, "DateTimePicker", function() { return date_time_DateTimePicker; }); |
|
/* concated harmony reexport DatePicker */__webpack_require__.d(__webpack_exports__, "DatePicker", function() { return date_time_date; }); |
|
/* concated harmony reexport TimePicker */__webpack_require__.d(__webpack_exports__, "TimePicker", function() { return time; }); |
|
/* concated harmony reexport Disabled */__webpack_require__.d(__webpack_exports__, "Disabled", function() { return build_module_disabled; }); |
|
/* concated harmony reexport Draggable */__webpack_require__.d(__webpack_exports__, "Draggable", function() { return draggable; }); |
|
/* concated harmony reexport DropZone */__webpack_require__.d(__webpack_exports__, "DropZone", function() { return drop_zone; }); |
|
/* concated harmony reexport DropZoneProvider */__webpack_require__.d(__webpack_exports__, "DropZoneProvider", function() { return provider; }); |
|
/* concated harmony reexport Dropdown */__webpack_require__.d(__webpack_exports__, "Dropdown", function() { return dropdown; }); |
|
/* concated harmony reexport DropdownMenu */__webpack_require__.d(__webpack_exports__, "DropdownMenu", function() { return dropdown_menu; }); |
|
/* concated harmony reexport ExternalLink */__webpack_require__.d(__webpack_exports__, "ExternalLink", function() { return external_link; }); |
|
/* concated harmony reexport FocalPointPicker */__webpack_require__.d(__webpack_exports__, "FocalPointPicker", function() { return focal_point_picker; }); |
|
/* concated harmony reexport FocusableIframe */__webpack_require__.d(__webpack_exports__, "FocusableIframe", function() { return focusable_iframe; }); |
|
/* concated harmony reexport FontSizePicker */__webpack_require__.d(__webpack_exports__, "FontSizePicker", function() { return font_size_picker; }); |
|
/* concated harmony reexport FormFileUpload */__webpack_require__.d(__webpack_exports__, "FormFileUpload", function() { return form_file_upload; }); |
|
/* concated harmony reexport FormToggle */__webpack_require__.d(__webpack_exports__, "FormToggle", function() { return form_toggle; }); |
|
/* concated harmony reexport FormTokenField */__webpack_require__.d(__webpack_exports__, "FormTokenField", function() { return form_token_field; }); |
|
/* concated harmony reexport Icon */__webpack_require__.d(__webpack_exports__, "Icon", function() { return build_module_icon; }); |
|
/* concated harmony reexport IconButton */__webpack_require__.d(__webpack_exports__, "IconButton", function() { return icon_button; }); |
|
/* concated harmony reexport KeyboardShortcuts */__webpack_require__.d(__webpack_exports__, "KeyboardShortcuts", function() { return keyboard_shortcuts; }); |
|
/* concated harmony reexport MenuGroup */__webpack_require__.d(__webpack_exports__, "MenuGroup", function() { return menu_group; }); |
|
/* concated harmony reexport MenuItem */__webpack_require__.d(__webpack_exports__, "MenuItem", function() { return menu_item; }); |
|
/* concated harmony reexport MenuItemsChoice */__webpack_require__.d(__webpack_exports__, "MenuItemsChoice", function() { return MenuItemsChoice; }); |
|
/* concated harmony reexport Modal */__webpack_require__.d(__webpack_exports__, "Modal", function() { return modal; }); |
|
/* concated harmony reexport ScrollLock */__webpack_require__.d(__webpack_exports__, "ScrollLock", function() { return scroll_lock; }); |
|
/* concated harmony reexport NavigableMenu */__webpack_require__.d(__webpack_exports__, "NavigableMenu", function() { return menu; }); |
|
/* concated harmony reexport TabbableContainer */__webpack_require__.d(__webpack_exports__, "TabbableContainer", function() { return tabbable; }); |
|
/* concated harmony reexport Notice */__webpack_require__.d(__webpack_exports__, "Notice", function() { return build_module_notice; }); |
|
/* concated harmony reexport NoticeList */__webpack_require__.d(__webpack_exports__, "NoticeList", function() { return list; }); |
|
/* concated harmony reexport Panel */__webpack_require__.d(__webpack_exports__, "Panel", function() { return panel; }); |
|
/* concated harmony reexport PanelBody */__webpack_require__.d(__webpack_exports__, "PanelBody", function() { return panel_body; }); |
|
/* concated harmony reexport PanelHeader */__webpack_require__.d(__webpack_exports__, "PanelHeader", function() { return panel_header; }); |
|
/* concated harmony reexport PanelRow */__webpack_require__.d(__webpack_exports__, "PanelRow", function() { return row; }); |
|
/* concated harmony reexport Placeholder */__webpack_require__.d(__webpack_exports__, "Placeholder", function() { return placeholder; }); |
|
/* concated harmony reexport Popover */__webpack_require__.d(__webpack_exports__, "Popover", function() { return popover; }); |
|
/* concated harmony reexport QueryControls */__webpack_require__.d(__webpack_exports__, "QueryControls", function() { return QueryControls; }); |
|
/* concated harmony reexport RadioControl */__webpack_require__.d(__webpack_exports__, "RadioControl", function() { return radio_control; }); |
|
/* concated harmony reexport RangeControl */__webpack_require__.d(__webpack_exports__, "RangeControl", function() { return range_control; }); |
|
/* concated harmony reexport ResizableBox */__webpack_require__.d(__webpack_exports__, "ResizableBox", function() { return resizable_box; }); |
|
/* concated harmony reexport ResponsiveWrapper */__webpack_require__.d(__webpack_exports__, "ResponsiveWrapper", function() { return responsive_wrapper; }); |
|
/* concated harmony reexport SandBox */__webpack_require__.d(__webpack_exports__, "SandBox", function() { return sandbox; }); |
|
/* concated harmony reexport SelectControl */__webpack_require__.d(__webpack_exports__, "SelectControl", function() { return select_control; }); |
|
/* concated harmony reexport Snackbar */__webpack_require__.d(__webpack_exports__, "Snackbar", function() { return snackbar; }); |
|
/* concated harmony reexport SnackbarList */__webpack_require__.d(__webpack_exports__, "SnackbarList", function() { return snackbar_list; }); |
|
/* concated harmony reexport Spinner */__webpack_require__.d(__webpack_exports__, "Spinner", function() { return Spinner; }); |
|
/* concated harmony reexport TabPanel */__webpack_require__.d(__webpack_exports__, "TabPanel", function() { return tab_panel; }); |
|
/* concated harmony reexport TextControl */__webpack_require__.d(__webpack_exports__, "TextControl", function() { return text_control; }); |
|
/* concated harmony reexport TextareaControl */__webpack_require__.d(__webpack_exports__, "TextareaControl", function() { return textarea_control; }); |
|
/* concated harmony reexport Tip */__webpack_require__.d(__webpack_exports__, "Tip", function() { return tip; }); |
|
/* concated harmony reexport ToggleControl */__webpack_require__.d(__webpack_exports__, "ToggleControl", function() { return toggle_control; }); |
|
/* concated harmony reexport Toolbar */__webpack_require__.d(__webpack_exports__, "Toolbar", function() { return toolbar; }); |
|
/* concated harmony reexport ToolbarButton */__webpack_require__.d(__webpack_exports__, "ToolbarButton", function() { return toolbar_button; }); |
|
/* concated harmony reexport Tooltip */__webpack_require__.d(__webpack_exports__, "Tooltip", function() { return build_module_tooltip; }); |
|
/* concated harmony reexport TreeSelect */__webpack_require__.d(__webpack_exports__, "TreeSelect", function() { return TreeSelect; }); |
|
/* concated harmony reexport IsolatedEventContainer */__webpack_require__.d(__webpack_exports__, "IsolatedEventContainer", function() { return isolated_event_container; }); |
|
/* concated harmony reexport createSlotFill */__webpack_require__.d(__webpack_exports__, "createSlotFill", function() { return createSlotFill; }); |
|
/* concated harmony reexport Slot */__webpack_require__.d(__webpack_exports__, "Slot", function() { return slot_fill_slot; }); |
|
/* concated harmony reexport Fill */__webpack_require__.d(__webpack_exports__, "Fill", function() { return slot_fill_fill; }); |
|
/* concated harmony reexport SlotFillProvider */__webpack_require__.d(__webpack_exports__, "SlotFillProvider", function() { return slot_fill_context; }); |
|
/* concated harmony reexport navigateRegions */__webpack_require__.d(__webpack_exports__, "navigateRegions", function() { return navigate_regions; }); |
|
/* concated harmony reexport withConstrainedTabbing */__webpack_require__.d(__webpack_exports__, "withConstrainedTabbing", function() { return with_constrained_tabbing; }); |
|
/* concated harmony reexport withFallbackStyles */__webpack_require__.d(__webpack_exports__, "withFallbackStyles", function() { return with_fallback_styles; }); |
|
/* concated harmony reexport withFilters */__webpack_require__.d(__webpack_exports__, "withFilters", function() { return withFilters; }); |
|
/* concated harmony reexport withFocusOutside */__webpack_require__.d(__webpack_exports__, "withFocusOutside", function() { return with_focus_outside; }); |
|
/* concated harmony reexport withFocusReturn */__webpack_require__.d(__webpack_exports__, "withFocusReturn", function() { return with_focus_return; }); |
|
/* concated harmony reexport FocusReturnProvider */__webpack_require__.d(__webpack_exports__, "FocusReturnProvider", function() { return with_focus_return_context; }); |
|
/* concated harmony reexport withNotices */__webpack_require__.d(__webpack_exports__, "withNotices", function() { return with_notices; }); |
|
/* concated harmony reexport withSpokenMessages */__webpack_require__.d(__webpack_exports__, "withSpokenMessages", function() { return with_spoken_messages; }); |
|
// Components |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Higher-Order Components |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }) |
|
/******/ ]); |