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.
894 lines
28 KiB
894 lines
28 KiB
this["wp"] = this["wp"] || {}; this["wp"]["compose"] = |
|
/******/ (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 = 313); |
|
/******/ }) |
|
/************************************************************************/ |
|
/******/ ({ |
|
|
|
/***/ 0: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["element"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 10: |
|
/***/ (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"); |
|
} |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 12: |
|
/***/ (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__(28); |
|
/* harmony import */ var _assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3); |
|
|
|
|
|
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); |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 13: |
|
/***/ (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); |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 14: |
|
/***/ (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); |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 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); |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 2: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["lodash"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 28: |
|
/***/ (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); |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 3: |
|
/***/ (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; |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 313: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
__webpack_require__.r(__webpack_exports__); |
|
|
|
// EXTERNAL MODULE: external "lodash" |
|
var external_lodash_ = __webpack_require__(2); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/create-higher-order-component/index.js |
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* Given a function mapping a component to an enhanced component and modifier |
|
* name, returns the enhanced component augmented with a generated displayName. |
|
* |
|
* @param {Function} mapComponentToEnhancedComponent Function mapping component |
|
* to enhanced component. |
|
* @param {string} modifierName Seed name from which to |
|
* generated display name. |
|
* |
|
* @return {WPComponent} Component class with generated display name assigned. |
|
*/ |
|
|
|
function createHigherOrderComponent(mapComponentToEnhancedComponent, modifierName) { |
|
return function (OriginalComponent) { |
|
var EnhancedComponent = mapComponentToEnhancedComponent(OriginalComponent); |
|
var _OriginalComponent$di = OriginalComponent.displayName, |
|
displayName = _OriginalComponent$di === void 0 ? OriginalComponent.name || 'Component' : _OriginalComponent$di; |
|
EnhancedComponent.displayName = "".concat(Object(external_lodash_["upperFirst"])(Object(external_lodash_["camelCase"])(modifierName)), "(").concat(displayName, ")"); |
|
return EnhancedComponent; |
|
}; |
|
} |
|
|
|
/* harmony default export */ var create_higher_order_component = (createHigherOrderComponent); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","element"]} |
|
var external_this_wp_element_ = __webpack_require__(0); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/if-condition/index.js |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
/** |
|
* Higher-order component creator, creating a new component which renders if |
|
* the given condition is satisfied or with the given optional prop name. |
|
* |
|
* @param {Function} predicate Function to test condition. |
|
* |
|
* @return {Function} Higher-order component. |
|
*/ |
|
|
|
var if_condition_ifCondition = function ifCondition(predicate) { |
|
return create_higher_order_component(function (WrappedComponent) { |
|
return function (props) { |
|
if (!predicate(props)) { |
|
return null; |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])(WrappedComponent, props); |
|
}; |
|
}, 'ifCondition'); |
|
}; |
|
|
|
/* harmony default export */ var if_condition = (if_condition_ifCondition); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js |
|
var classCallCheck = __webpack_require__(10); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js |
|
var createClass = __webpack_require__(9); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js |
|
var possibleConstructorReturn = __webpack_require__(12); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js |
|
var getPrototypeOf = __webpack_require__(13); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js + 1 modules |
|
var inherits = __webpack_require__(14); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","isShallowEqual"]} |
|
var external_this_wp_isShallowEqual_ = __webpack_require__(40); |
|
var external_this_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_isShallowEqual_); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/pure/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Given a component returns the enhanced component augmented with a component |
|
* only rerendering when its props/state change |
|
* |
|
* @param {Function} mapComponentToEnhancedComponent Function mapping component |
|
* to enhanced component. |
|
* @param {string} modifierName Seed name from which to |
|
* generated display name. |
|
* |
|
* @return {WPComponent} Component class with generated display name assigned. |
|
*/ |
|
|
|
var pure = create_higher_order_component(function (Wrapped) { |
|
if (Wrapped.prototype instanceof external_this_wp_element_["Component"]) { |
|
return ( |
|
/*#__PURE__*/ |
|
function (_Wrapped) { |
|
Object(inherits["a" /* default */])(_class, _Wrapped); |
|
|
|
function _class() { |
|
Object(classCallCheck["a" /* default */])(this, _class); |
|
|
|
return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).apply(this, arguments)); |
|
} |
|
|
|
Object(createClass["a" /* default */])(_class, [{ |
|
key: "shouldComponentUpdate", |
|
value: function shouldComponentUpdate(nextProps, nextState) { |
|
return !external_this_wp_isShallowEqual_default()(nextProps, this.props) || !external_this_wp_isShallowEqual_default()(nextState, this.state); |
|
} |
|
}]); |
|
|
|
return _class; |
|
}(Wrapped) |
|
); |
|
} |
|
|
|
return ( |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(_class2, _Component); |
|
|
|
function _class2() { |
|
Object(classCallCheck["a" /* default */])(this, _class2); |
|
|
|
return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class2).apply(this, arguments)); |
|
} |
|
|
|
Object(createClass["a" /* default */])(_class2, [{ |
|
key: "shouldComponentUpdate", |
|
value: function shouldComponentUpdate(nextProps) { |
|
return !external_this_wp_isShallowEqual_default()(nextProps, this.props); |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
return Object(external_this_wp_element_["createElement"])(Wrapped, this.props); |
|
} |
|
}]); |
|
|
|
return _class2; |
|
}(external_this_wp_element_["Component"]) |
|
); |
|
}, 'pure'); |
|
/* harmony default export */ var build_module_pure = (pure); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js |
|
var esm_extends = __webpack_require__(18); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js |
|
var assertThisInitialized = __webpack_require__(3); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-global-events/listener.js |
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* Class responsible for orchestrating event handling on the global window, |
|
* binding a single event to be shared across all handling instances, and |
|
* removing the handler when no instances are listening for the event. |
|
*/ |
|
|
|
var listener_Listener = |
|
/*#__PURE__*/ |
|
function () { |
|
function Listener() { |
|
Object(classCallCheck["a" /* default */])(this, Listener); |
|
|
|
this.listeners = {}; |
|
this.handleEvent = this.handleEvent.bind(this); |
|
} |
|
|
|
Object(createClass["a" /* default */])(Listener, [{ |
|
key: "add", |
|
value: function add(eventType, instance) { |
|
if (!this.listeners[eventType]) { |
|
// Adding first listener for this type, so bind event. |
|
window.addEventListener(eventType, this.handleEvent); |
|
this.listeners[eventType] = []; |
|
} |
|
|
|
this.listeners[eventType].push(instance); |
|
} |
|
}, { |
|
key: "remove", |
|
value: function remove(eventType, instance) { |
|
this.listeners[eventType] = Object(external_lodash_["without"])(this.listeners[eventType], instance); |
|
|
|
if (!this.listeners[eventType].length) { |
|
// Removing last listener for this type, so unbind event. |
|
window.removeEventListener(eventType, this.handleEvent); |
|
delete this.listeners[eventType]; |
|
} |
|
} |
|
}, { |
|
key: "handleEvent", |
|
value: function handleEvent(event) { |
|
Object(external_lodash_["forEach"])(this.listeners[event.type], function (instance) { |
|
instance.handleEvent(event); |
|
}); |
|
} |
|
}]); |
|
|
|
return Listener; |
|
}(); |
|
|
|
/* harmony default export */ var listener = (listener_Listener); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-global-events/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Listener instance responsible for managing document event handling. |
|
* |
|
* @type {Listener} |
|
*/ |
|
|
|
var with_global_events_listener = new listener(); |
|
|
|
function withGlobalEvents(eventTypesToHandlers) { |
|
return create_higher_order_component(function (WrappedComponent) { |
|
var Wrapper = |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(Wrapper, _Component); |
|
|
|
function Wrapper() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, Wrapper); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Wrapper).apply(this, arguments)); |
|
_this.handleEvent = _this.handleEvent.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); |
|
_this.handleRef = _this.handleRef.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(Wrapper, [{ |
|
key: "componentDidMount", |
|
value: function componentDidMount() { |
|
var _this2 = this; |
|
|
|
Object(external_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) { |
|
with_global_events_listener.add(eventType, _this2); |
|
}); |
|
} |
|
}, { |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
var _this3 = this; |
|
|
|
Object(external_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) { |
|
with_global_events_listener.remove(eventType, _this3); |
|
}); |
|
} |
|
}, { |
|
key: "handleEvent", |
|
value: function handleEvent(event) { |
|
var handler = eventTypesToHandlers[event.type]; |
|
|
|
if (typeof this.wrappedRef[handler] === 'function') { |
|
this.wrappedRef[handler](event); |
|
} |
|
} |
|
}, { |
|
key: "handleRef", |
|
value: function handleRef(el) { |
|
this.wrappedRef = el; // Any component using `withGlobalEvents` that is not setting a `ref` |
|
// will cause `this.props.forwardedRef` to be `null`, so we need this |
|
// check. |
|
|
|
if (this.props.forwardedRef) { |
|
this.props.forwardedRef(el); |
|
} |
|
} |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props.ownProps, { |
|
ref: this.handleRef |
|
})); |
|
} |
|
}]); |
|
|
|
return Wrapper; |
|
}(external_this_wp_element_["Component"]); |
|
|
|
return Object(external_this_wp_element_["forwardRef"])(function (props, ref) { |
|
return Object(external_this_wp_element_["createElement"])(Wrapper, { |
|
ownProps: props, |
|
forwardedRef: ref |
|
}); |
|
}); |
|
}, 'withGlobalEvents'); |
|
} |
|
|
|
/* harmony default export */ var with_global_events = (withGlobalEvents); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-instance-id/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal 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_instance_id = (create_higher_order_component(function (WrappedComponent) { |
|
var instances = 0; |
|
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.instanceId = instances++; |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(_class, [{ |
|
key: "render", |
|
value: function render() { |
|
return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props, { |
|
instanceId: this.instanceId |
|
})); |
|
} |
|
}]); |
|
|
|
return _class; |
|
}(external_this_wp_element_["Component"]) |
|
); |
|
}, 'withInstanceId')); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-safe-timeout/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* A higher-order component used to provide and manage delayed function calls |
|
* that ought to be bound to a component's lifecycle. |
|
* |
|
* @param {Component} OriginalComponent Component requiring setTimeout |
|
* |
|
* @return {Component} Wrapped component. |
|
*/ |
|
|
|
var withSafeTimeout = create_higher_order_component(function (OriginalComponent) { |
|
return ( |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(WrappedComponent, _Component); |
|
|
|
function WrappedComponent() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, WrappedComponent); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(WrappedComponent).apply(this, arguments)); |
|
_this.timeouts = []; |
|
_this.setTimeout = _this.setTimeout.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); |
|
_this.clearTimeout = _this.clearTimeout.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(WrappedComponent, [{ |
|
key: "componentWillUnmount", |
|
value: function componentWillUnmount() { |
|
this.timeouts.forEach(clearTimeout); |
|
} |
|
}, { |
|
key: "setTimeout", |
|
value: function (_setTimeout) { |
|
function setTimeout(_x, _x2) { |
|
return _setTimeout.apply(this, arguments); |
|
} |
|
|
|
setTimeout.toString = function () { |
|
return _setTimeout.toString(); |
|
}; |
|
|
|
return setTimeout; |
|
}(function (fn, delay) { |
|
var _this2 = this; |
|
|
|
var id = setTimeout(function () { |
|
fn(); |
|
|
|
_this2.clearTimeout(id); |
|
}, delay); |
|
this.timeouts.push(id); |
|
return id; |
|
}) |
|
}, { |
|
key: "clearTimeout", |
|
value: function (_clearTimeout) { |
|
function clearTimeout(_x3) { |
|
return _clearTimeout.apply(this, arguments); |
|
} |
|
|
|
clearTimeout.toString = function () { |
|
return _clearTimeout.toString(); |
|
}; |
|
|
|
return clearTimeout; |
|
}(function (id) { |
|
clearTimeout(id); |
|
this.timeouts = Object(external_lodash_["without"])(this.timeouts, id); |
|
}) |
|
}, { |
|
key: "render", |
|
value: function render() { |
|
return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, { |
|
setTimeout: this.setTimeout, |
|
clearTimeout: this.clearTimeout |
|
})); |
|
} |
|
}]); |
|
|
|
return WrappedComponent; |
|
}(external_this_wp_element_["Component"]) |
|
); |
|
}, 'withSafeTimeout'); |
|
/* harmony default export */ var with_safe_timeout = (withSafeTimeout); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-state/index.js |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* A Higher Order Component used to provide and manage internal component state |
|
* via props. |
|
* |
|
* @param {?Object} initialState Optional initial state of the component. |
|
* |
|
* @return {Component} Wrapped component. |
|
*/ |
|
|
|
function withState() { |
|
var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; |
|
return create_higher_order_component(function (OriginalComponent) { |
|
return ( |
|
/*#__PURE__*/ |
|
function (_Component) { |
|
Object(inherits["a" /* default */])(WrappedComponent, _Component); |
|
|
|
function WrappedComponent() { |
|
var _this; |
|
|
|
Object(classCallCheck["a" /* default */])(this, WrappedComponent); |
|
|
|
_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(WrappedComponent).apply(this, arguments)); |
|
_this.setState = _this.setState.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); |
|
_this.state = initialState; |
|
return _this; |
|
} |
|
|
|
Object(createClass["a" /* default */])(WrappedComponent, [{ |
|
key: "render", |
|
value: function render() { |
|
return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, this.state, { |
|
setState: this.setState |
|
})); |
|
} |
|
}]); |
|
|
|
return WrappedComponent; |
|
}(external_this_wp_element_["Component"]) |
|
); |
|
}, 'withState'); |
|
} |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/index.js |
|
/* concated harmony reexport createHigherOrderComponent */__webpack_require__.d(__webpack_exports__, "createHigherOrderComponent", function() { return create_higher_order_component; }); |
|
/* concated harmony reexport ifCondition */__webpack_require__.d(__webpack_exports__, "ifCondition", function() { return if_condition; }); |
|
/* concated harmony reexport pure */__webpack_require__.d(__webpack_exports__, "pure", function() { return build_module_pure; }); |
|
/* concated harmony reexport withGlobalEvents */__webpack_require__.d(__webpack_exports__, "withGlobalEvents", function() { return with_global_events; }); |
|
/* concated harmony reexport withInstanceId */__webpack_require__.d(__webpack_exports__, "withInstanceId", function() { return with_instance_id; }); |
|
/* concated harmony reexport withSafeTimeout */__webpack_require__.d(__webpack_exports__, "withSafeTimeout", function() { return with_safe_timeout; }); |
|
/* concated harmony reexport withState */__webpack_require__.d(__webpack_exports__, "withState", function() { return withState; }); |
|
/* concated harmony reexport compose */__webpack_require__.d(__webpack_exports__, "compose", function() { return external_lodash_["flowRight"]; }); |
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Composes multiple higher-order components into a single higher-order component. Performs right-to-left function |
|
* composition, where each successive invocation is supplied the return value of the previous. |
|
* |
|
* @param {...Function} hocs The HOC functions to invoke. |
|
* |
|
* @return {Function} Returns the new composite function. |
|
*/ |
|
|
|
|
|
|
|
|
|
/***/ }), |
|
|
|
/***/ 40: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["isShallowEqual"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 9: |
|
/***/ (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; |
|
} |
|
|
|
/***/ }) |
|
|
|
/******/ }); |