2018-12-13 23:41:57 -05:00
this [ "wp" ] = this [ "wp" ] || { } ; this [ "wp" ] [ "coreData" ] =
/******/ ( 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
2019-03-21 08:48:00 -04:00
/******/ return _ _webpack _require _ _ ( _ _webpack _require _ _ . s = 364 ) ;
2018-12-13 23:41:57 -05:00
/******/ } )
/************************************************************************/
/******/ ( {
2019-03-21 08:48:00 -04:00
/***/ 132 :
2018-12-17 22:14:52 -05:00
/***/ ( function ( module , exports ) {
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
module . exports = function ( originalModule ) {
if ( ! originalModule . webpackPolyfill ) {
var module = Object . create ( originalModule ) ;
// module.parent = undefined by default
if ( ! module . children ) module . children = [ ] ;
Object . defineProperty ( module , "loaded" , {
enumerable : true ,
get : function ( ) {
return module . l ;
}
} ) ;
Object . defineProperty ( module , "id" , {
enumerable : true ,
get : function ( ) {
return module . i ;
}
} ) ;
Object . defineProperty ( module , "exports" , {
enumerable : true
} ) ;
module . webpackPolyfill = 1 ;
}
return module ;
} ;
2018-12-13 23:41:57 -05:00
/***/ } ) ,
2018-12-17 22:14:52 -05:00
/***/ 15 :
2018-12-13 23:41:57 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
2018-12-17 22:14:52 -05:00
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _defineProperty ; } ) ;
2018-12-13 23:41:57 -05:00
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 ;
}
/***/ } ) ,
2019-03-21 08:48:00 -04:00
/***/ 17 :
2018-12-13 23:41:57 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
2018-12-17 22:14:52 -05:00
// 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
2019-03-21 08:48:00 -04:00
var iterableToArray = _ _webpack _require _ _ ( 34 ) ;
2018-12-17 22:14:52 -05:00
// 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 ( ) ;
2018-12-13 23:41:57 -05:00
}
/***/ } ) ,
2018-12-17 22:14:52 -05:00
/***/ 2 :
/***/ ( function ( module , exports ) {
( function ( ) { module . exports = this [ "lodash" ] ; } ( ) ) ;
/***/ } ) ,
2019-03-21 08:48:00 -04:00
/***/ 23 :
2018-12-17 22:14:52 -05:00
/***/ ( function ( module , exports ) {
( function ( ) { module . exports = this [ "wp" ] [ "url" ] ; } ( ) ) ;
/***/ } ) ,
2019-03-21 08:48:00 -04:00
/***/ 26 :
/***/ ( function ( module , exports , _ _webpack _require _ _ ) {
module . exports = _ _webpack _require _ _ ( 54 ) ;
/***/ } ) ,
/***/ 28 :
2018-12-13 23:41:57 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
2019-03-21 08:48:00 -04:00
var arrayWithHoles = _ _webpack _require _ _ ( 37 ) ;
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
2018-12-13 23:41:57 -05:00
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 ;
}
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
2019-03-21 08:48:00 -04:00
var nonIterableRest = _ _webpack _require _ _ ( 38 ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _slicedToArray ; } ) ;
2018-12-13 23:41:57 -05:00
function _slicedToArray ( arr , i ) {
2018-12-17 22:14:52 -05:00
return Object ( arrayWithHoles [ "a" /* default */ ] ) ( arr ) || _iterableToArrayLimit ( arr , i ) || Object ( nonIterableRest [ "a" /* default */ ] ) ( ) ;
2018-12-13 23:41:57 -05:00
}
/***/ } ) ,
2019-03-21 08:48:00 -04:00
/***/ 30 :
2018-12-13 23:41:57 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
2018-12-17 22:14:52 -05:00
var LEAF _KEY , hasWeakMap ;
2018-12-14 06:02:53 -05:00
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Arbitrary value used as key for referencing cache object in WeakMap tree .
*
* @ type { Object }
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
LEAF _KEY = { } ;
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Whether environment supports WeakMap .
*
* @ type { boolean }
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
hasWeakMap = typeof WeakMap !== 'undefined' ;
2018-12-14 06:02:53 -05:00
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Returns the first argument as the sole entry in an array .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { * } value Value to return .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ return { Array } Value returned as entry in array .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function arrayOf ( value ) {
return [ value ] ;
2018-12-13 23:41:57 -05:00
}
2018-12-17 22:14:52 -05:00
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Returns true if the value passed is object - like , or false otherwise . A value
* is object - like if it can support property assignment , e . g . object or array .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { * } value Value to test .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ return { boolean } Whether value is object - like .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function isObjectLike ( value ) {
return ! ! value && 'object' === typeof value ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/ * *
* Creates and returns a new cache object .
*
* @ return { Object } Cache object .
* /
function createCache ( ) {
var cache = {
clear : function ( ) {
cache . head = null ;
} ,
} ;
return cache ;
2018-12-13 23:41:57 -05:00
}
2018-12-17 22:14:52 -05:00
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Returns true if entries within the two arrays are strictly equal by
* reference from a starting index .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { Array } a First array .
* @ param { Array } b Second array .
* @ param { number } fromIndex Index from which to start comparison .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ return { boolean } Whether arrays are shallowly equal .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function isShallowEqual ( a , b , fromIndex ) {
var i ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( a . length !== b . length ) {
return false ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
for ( i = fromIndex ; i < a . length ; i ++ ) {
if ( a [ i ] !== b [ i ] ) {
return false ;
}
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return true ;
2018-12-13 23:41:57 -05:00
}
2018-12-17 22:14:52 -05:00
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Returns a memoized selector function . The getDependants function argument is
* called before the memoized selector and is expected to return an immutable
* reference or array of references on which the selector depends for computing
* its own return value . The memoize cache is preserved only as long as those
* dependant references remain the same . If getDependants returns a different
* reference ( s ) , the cache is cleared and the selector value regenerated .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { Function } selector Selector function .
* @ param { Function } getDependants Dependant getter returning an immutable
* reference or array of reference used in
* cache bust consideration .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ return { Function } Memoized selector .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
/* harmony default export */ _ _webpack _exports _ _ [ "a" ] = ( function ( selector , getDependants ) {
var rootCache , getCache ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// Use object source as dependant if getter not provided
if ( ! getDependants ) {
getDependants = arrayOf ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/ * *
* Returns the root cache . If WeakMap is supported , this is assigned to the
* root WeakMap cache set , otherwise it is a shared instance of the default
* cache object .
*
* @ return { ( WeakMap | Object ) } Root cache object .
* /
function getRootCache ( ) {
return rootCache ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/ * *
* Returns the cache for a given dependants array . When possible , a WeakMap
* will be used to create a unique cache for each set of dependants . This
* is feasible due to the nature of WeakMap in allowing garbage collection
* to occur on entries where the key object is no longer referenced . Since
* WeakMap requires the key to be an object , this is only possible when the
* dependant is object - like . The root cache is created as a hierarchy where
* each top - level key is the first entry in a dependants set , the value a
* WeakMap where each key is the next dependant , and so on . This continues
* so long as the dependants are object - like . If no dependants are object -
* like , then the cache is shared across all invocations .
*
* @ see isObjectLike
*
* @ param { Array } dependants Selector dependants .
*
* @ return { Object } Cache object .
* /
function getWeakMapCache ( dependants ) {
var caches = rootCache ,
isUniqueByDependants = true ,
i , dependant , map , cache ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
for ( i = 0 ; i < dependants . length ; i ++ ) {
dependant = dependants [ i ] ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// Can only compose WeakMap from object-like key.
if ( ! isObjectLike ( dependant ) ) {
isUniqueByDependants = false ;
break ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// Does current segment of cache already have a WeakMap?
if ( caches . has ( dependant ) ) {
// Traverse into nested WeakMap.
caches = caches . get ( dependant ) ;
} else {
// Create, set, and traverse into a new one.
map = new WeakMap ( ) ;
caches . set ( dependant , map ) ;
caches = map ;
}
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// We use an arbitrary (but consistent) object as key for the last item
// in the WeakMap to serve as our running cache.
if ( ! caches . has ( LEAF _KEY ) ) {
cache = createCache ( ) ;
cache . isUniqueByDependants = isUniqueByDependants ;
caches . set ( LEAF _KEY , cache ) ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return caches . get ( LEAF _KEY ) ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// Assign cache handler by availability of WeakMap
getCache = hasWeakMap ? getWeakMapCache : getRootCache ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/ * *
* Resets root memoization cache .
* /
function clear ( ) {
rootCache = hasWeakMap ? new WeakMap ( ) : createCache ( ) ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// eslint-disable-next-line jsdoc/check-param-names
/ * *
* The augmented selector call , considering first whether dependants have
* changed before passing it to underlying memoize function .
*
* @ param { Object } source Source object for derivation .
* @ param { ... * } extraArgs Additional arguments to pass to selector .
*
* @ return { * } Selector result .
* /
function callSelector ( /* source, ...extraArgs */ ) {
var len = arguments . length ,
cache , node , i , args , dependants ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// Create copy of arguments (avoid leaking deoptimization).
args = new Array ( len ) ;
for ( i = 0 ; i < len ; i ++ ) {
args [ i ] = arguments [ i ] ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
dependants = getDependants . apply ( null , args ) ;
cache = getCache ( dependants ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// If not guaranteed uniqueness by dependants (primitive type or lack
// of WeakMap support), shallow compare against last dependants and, if
// references have changed, destroy cache to recalculate result.
if ( ! cache . isUniqueByDependants ) {
if ( cache . lastDependants && ! isShallowEqual ( dependants , cache . lastDependants , 0 ) ) {
cache . clear ( ) ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
cache . lastDependants = dependants ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
node = cache . head ;
while ( node ) {
// Check whether node arguments match arguments
if ( ! isShallowEqual ( node . args , args , 1 ) ) {
node = node . next ;
continue ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// At this point we can assume we've found a match
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// Surface matched node to head if not already
if ( node !== cache . head ) {
// Adjust siblings to point to each other.
node . prev . next = node . next ;
if ( node . next ) {
node . next . prev = node . prev ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
node . next = cache . head ;
node . prev = null ;
cache . head . prev = node ;
cache . head = node ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// Return immediately
return node . val ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// No cached value found. Continue to insertion phase:
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
node = {
// Generate the result from original function
val : selector . apply ( null , args ) ,
} ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// Avoid including the source object in the cache.
args [ 0 ] = null ;
node . args = args ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// Don't need to check whether node is already head, since it would
// have been returned above already if it was
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// Shift existing head down list
if ( cache . head ) {
cache . head . prev = node ;
node . next = cache . head ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
cache . head = node ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return node . val ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
callSelector . getDependants = getDependants ;
callSelector . clear = clear ;
clear ( ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return callSelector ;
} ) ;
2018-12-13 23:41:57 -05:00
/***/ } ) ,
2019-03-21 08:48:00 -04:00
/***/ 33 :
2019-03-07 04:09:59 -05:00
/***/ ( function ( module , exports ) {
( function ( ) { module . exports = this [ "wp" ] [ "apiFetch" ] ; } ( ) ) ;
/***/ } ) ,
2019-03-21 08:48:00 -04:00
/***/ 34 :
/***/ ( 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 ) ;
}
/***/ } ) ,
/***/ 364 :
2018-12-13 23:41:57 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
_ _webpack _require _ _ . r ( _ _webpack _exports _ _ ) ;
2018-12-17 22:14:52 -05:00
var build _module _actions _namespaceObject = { } ;
_ _webpack _require _ _ . r ( build _module _actions _namespaceObject ) ;
_ _webpack _require _ _ . d ( build _module _actions _namespaceObject , "receiveUserQuery" , function ( ) { return receiveUserQuery ; } ) ;
_ _webpack _require _ _ . d ( build _module _actions _namespaceObject , "addEntities" , function ( ) { return addEntities ; } ) ;
_ _webpack _require _ _ . d ( build _module _actions _namespaceObject , "receiveEntityRecords" , function ( ) { return receiveEntityRecords ; } ) ;
_ _webpack _require _ _ . d ( build _module _actions _namespaceObject , "receiveThemeSupports" , function ( ) { return receiveThemeSupports ; } ) ;
_ _webpack _require _ _ . d ( build _module _actions _namespaceObject , "receiveEmbedPreview" , function ( ) { return receiveEmbedPreview ; } ) ;
_ _webpack _require _ _ . d ( build _module _actions _namespaceObject , "saveEntityRecord" , function ( ) { return saveEntityRecord ; } ) ;
_ _webpack _require _ _ . d ( build _module _actions _namespaceObject , "receiveUploadPermissions" , function ( ) { return receiveUploadPermissions ; } ) ;
2019-03-07 04:09:59 -05:00
_ _webpack _require _ _ . d ( build _module _actions _namespaceObject , "receiveUserPermission" , function ( ) { return receiveUserPermission ; } ) ;
2018-12-17 22:14:52 -05:00
var build _module _selectors _namespaceObject = { } ;
_ _webpack _require _ _ . r ( build _module _selectors _namespaceObject ) ;
_ _webpack _require _ _ . d ( build _module _selectors _namespaceObject , "isRequestingEmbedPreview" , function ( ) { return isRequestingEmbedPreview ; } ) ;
_ _webpack _require _ _ . d ( build _module _selectors _namespaceObject , "getAuthors" , function ( ) { return getAuthors ; } ) ;
_ _webpack _require _ _ . d ( build _module _selectors _namespaceObject , "getUserQueryResults" , function ( ) { return getUserQueryResults ; } ) ;
_ _webpack _require _ _ . d ( build _module _selectors _namespaceObject , "getEntitiesByKind" , function ( ) { return getEntitiesByKind ; } ) ;
_ _webpack _require _ _ . d ( build _module _selectors _namespaceObject , "getEntity" , function ( ) { return getEntity ; } ) ;
_ _webpack _require _ _ . d ( build _module _selectors _namespaceObject , "getEntityRecord" , function ( ) { return getEntityRecord ; } ) ;
_ _webpack _require _ _ . d ( build _module _selectors _namespaceObject , "getEntityRecords" , function ( ) { return getEntityRecords ; } ) ;
_ _webpack _require _ _ . d ( build _module _selectors _namespaceObject , "getThemeSupports" , function ( ) { return getThemeSupports ; } ) ;
_ _webpack _require _ _ . d ( build _module _selectors _namespaceObject , "getEmbedPreview" , function ( ) { return getEmbedPreview ; } ) ;
_ _webpack _require _ _ . d ( build _module _selectors _namespaceObject , "isPreviewEmbedFallback" , function ( ) { return isPreviewEmbedFallback ; } ) ;
2019-03-07 04:09:59 -05:00
_ _webpack _require _ _ . d ( build _module _selectors _namespaceObject , "hasUploadPermissions" , function ( ) { return hasUploadPermissions ; } ) ;
_ _webpack _require _ _ . d ( build _module _selectors _namespaceObject , "canUser" , function ( ) { return canUser ; } ) ;
2018-12-17 22:14:52 -05:00
var resolvers _namespaceObject = { } ;
_ _webpack _require _ _ . r ( resolvers _namespaceObject ) ;
_ _webpack _require _ _ . d ( resolvers _namespaceObject , "getAuthors" , function ( ) { return resolvers _getAuthors ; } ) ;
_ _webpack _require _ _ . d ( resolvers _namespaceObject , "getEntityRecord" , function ( ) { return resolvers _getEntityRecord ; } ) ;
_ _webpack _require _ _ . d ( resolvers _namespaceObject , "getEntityRecords" , function ( ) { return resolvers _getEntityRecords ; } ) ;
_ _webpack _require _ _ . d ( resolvers _namespaceObject , "getThemeSupports" , function ( ) { return resolvers _getThemeSupports ; } ) ;
_ _webpack _require _ _ . d ( resolvers _namespaceObject , "getEmbedPreview" , function ( ) { return resolvers _getEmbedPreview ; } ) ;
_ _webpack _require _ _ . d ( resolvers _namespaceObject , "hasUploadPermissions" , function ( ) { return resolvers _hasUploadPermissions ; } ) ;
2019-03-07 04:09:59 -05:00
_ _webpack _require _ _ . d ( resolvers _namespaceObject , "canUser" , function ( ) { return resolvers _canUser ; } ) ;
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread.js
2019-03-21 08:48:00 -04:00
var objectSpread = _ _webpack _require _ _ ( 7 ) ;
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: external {"this":["wp","data"]}
var external _this _wp _data _ = _ _webpack _require _ _ ( 5 ) ;
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
2019-03-21 08:48:00 -04:00
var slicedToArray = _ _webpack _require _ _ ( 28 ) ;
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
2019-03-21 08:48:00 -04:00
var toConsumableArray = _ _webpack _require _ _ ( 17 ) ;
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
var defineProperty = _ _webpack _require _ _ ( 15 ) ;
// EXTERNAL MODULE: external "lodash"
var external _lodash _ = _ _webpack _require _ _ ( 2 ) ;
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/if-matching-action.js
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* A higher - order reducer creator which invokes the original reducer only if
* the dispatching action matches the given predicate , * * OR * * if state is
* initializing ( undefined ) .
*
* @ param { Function } isMatch Function predicate for allowing reducer call .
*
* @ return { Function } Higher - order reducer .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
var ifMatchingAction = function ifMatchingAction ( isMatch ) {
return function ( reducer ) {
return function ( state , action ) {
if ( state === undefined || isMatch ( action ) ) {
return reducer ( state , action ) ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return state ;
} ;
} ;
} ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/* harmony default export */ var if _matching _action = ( ifMatchingAction ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/on-sub-key.js
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/ * *
* Higher - order reducer creator which creates a combined reducer object , keyed
* by a property on the action object .
*
* @ param { string } actionProperty Action property by which to key object .
*
* @ return { Function } Higher - order reducer .
* /
var on _sub _key _onSubKey = function onSubKey ( actionProperty ) {
return function ( reducer ) {
return function ( ) {
var state = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : { } ;
var action = arguments . length > 1 ? arguments [ 1 ] : undefined ;
// Retrieve subkey from action. Do not track if undefined; useful for cases
// where reducer is scoped by action shape.
var key = action [ actionProperty ] ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( key === undefined ) {
return state ;
} // Avoid updating state if unchanged. Note that this also accounts for a
// reducer which returns undefined on a key which is not yet tracked.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var nextKeyState = reducer ( state [ key ] , action ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( nextKeyState === state [ key ] ) {
return state ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return Object ( objectSpread [ "a" /* default */ ] ) ( { } , state , Object ( defineProperty [ "a" /* default */ ] ) ( { } , key , nextKeyState ) ) ;
} ;
2018-12-14 06:02:53 -05:00
} ;
2018-12-17 22:14:52 -05:00
} ;
/* harmony default export */ var on _sub _key = ( on _sub _key _onSubKey ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/replace-action.js
/ * *
* Higher - order reducer creator which substitutes the action object before
* passing to the original reducer .
*
* @ param { Function } replacer Function mapping original action to replacement .
*
* @ return { Function } Higher - order reducer .
* /
var replaceAction = function replaceAction ( replacer ) {
return function ( reducer ) {
return function ( state , action ) {
return reducer ( state , replacer ( action ) ) ;
} ;
2018-12-14 06:02:53 -05:00
} ;
2018-12-17 22:14:52 -05:00
} ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/* harmony default export */ var replace _action = ( replaceAction ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/with-weak-map-cache.js
/ * *
* External dependencies
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/ * *
* Given a function , returns an enhanced function which caches the result and
* tracks in WeakMap . The result is only cached if the original function is
* passed a valid object - like argument ( requirement for WeakMap key ) .
*
* @ param { Function } fn Original function .
*
* @ return { Function } Enhanced caching function .
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
function withWeakMapCache ( fn ) {
var cache = new WeakMap ( ) ;
return function ( key ) {
var value ;
2018-12-14 06:02:53 -05:00
2018-12-17 22:14:52 -05:00
if ( cache . has ( key ) ) {
value = cache . get ( key ) ;
} else {
value = fn ( key ) ; // Can reach here if key is not valid for WeakMap, since `has`
// will return false for invalid key. Since `set` will throw,
// ensure that key is valid before setting into cache.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( Object ( external _lodash _ [ "isObjectLike" ] ) ( key ) ) {
cache . set ( key , value ) ;
}
}
2018-12-14 06:02:53 -05:00
2018-12-17 22:14:52 -05:00
return value ;
2018-12-14 06:02:53 -05:00
} ;
2018-12-17 22:14:52 -05:00
}
2018-12-14 06:02:53 -05:00
2018-12-17 22:14:52 -05:00
/* harmony default export */ var with _weak _map _cache = ( withWeakMapCache ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/index.js
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/actions.js
2018-12-13 23:41:57 -05:00
/ * *
* External dependencies
* /
/ * *
* Returns an action object used in signalling that items have been received .
*
* @ param { Array } items Items received .
*
* @ return { Object } Action object .
* /
function receiveItems ( items ) {
return {
type : 'RECEIVE_ITEMS' ,
2018-12-17 22:14:52 -05:00
items : Object ( external _lodash _ [ "castArray" ] ) ( items )
2018-12-13 23:41:57 -05:00
} ;
}
/ * *
* Returns an action object used in signalling that queried data has been
* received .
*
* @ param { Array } items Queried items received .
* @ param { ? Object } query Optional query object .
*
* @ return { Object } Action object .
* /
function receiveQueriedItems ( items ) {
var query = arguments . length > 1 && arguments [ 1 ] !== undefined ? arguments [ 1 ] : { } ;
2018-12-17 22:14:52 -05:00
return Object ( objectSpread [ "a" /* default */ ] ) ( { } , receiveItems ( items ) , {
2018-12-13 23:41:57 -05:00
query : query
} ) ;
}
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js
2019-03-21 08:48:00 -04:00
var rememo = _ _webpack _require _ _ ( 30 ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/equivalent-key-map/equivalent-key-map.js
2019-03-21 08:48:00 -04:00
var equivalent _key _map = _ _webpack _require _ _ ( 76 ) ;
2018-12-17 22:14:52 -05:00
var equivalent _key _map _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( equivalent _key _map ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: external {"this":["wp","url"]}
2019-03-21 08:48:00 -04:00
var external _this _wp _url _ = _ _webpack _require _ _ ( 23 ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/get-query-parts.js
2018-12-13 23:41:57 -05:00
/ * *
* WordPress dependencies
* /
/ * *
* Internal dependencies
* /
/ * *
* An object of properties describing a specific query .
*
* @ typedef { WPQueriedDataQueryParts }
*
* @ property { number } page The query page ( 1 - based index , default 1 ) .
* @ property { number } perPage Items per page for query ( default 10 ) .
2018-12-17 22:14:52 -05:00
* @ property { string } stableKey An encoded stable string of all non - pagination
* query parameters .
* /
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Given a query object , returns an object of parts , including pagination
* details ( ` page ` and ` perPage ` , or default values ) . All other properties are
* encoded into a stable ( idempotent ) ` stableKey ` value .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { Object } query Optional query object .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ return { WPQueriedDataQueryParts } Query parts .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function getQueryParts ( query ) {
/ * *
* @ type { WPQueriedDataQueryParts }
* /
var parts = {
stableKey : '' ,
page : 1 ,
perPage : 10
} ; // Ensure stable key by sorting keys. Also more efficient for iterating.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var keys = Object . keys ( query ) . sort ( ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
for ( var i = 0 ; i < keys . length ; i ++ ) {
var key = keys [ i ] ;
var value = query [ key ] ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
switch ( key ) {
case 'page' :
parts [ key ] = Number ( value ) ;
break ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 'per_page' :
parts . perPage = Number ( value ) ;
break ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
default :
// While it could be any deterministic string, for simplicity's
// sake mimic querystring encoding for stable key.
//
// TODO: For consistency with PHP implementation, addQueryArgs
// should accept a key value pair, which may optimize its
// implementation for our use here, vs. iterating an object
// with only a single key.
parts . stableKey += ( parts . stableKey ? '&' : '' ) + Object ( external _this _wp _url _ [ "addQueryArgs" ] ) ( '' , Object ( defineProperty [ "a" /* default */ ] ) ( { } , key , value ) ) . slice ( 1 ) ;
}
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return parts ;
}
/* harmony default export */ var get _query _parts = ( with _weak _map _cache ( getQueryParts ) ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/selectors.js
2018-12-13 23:41:57 -05:00
/ * *
* External dependencies
* /
/ * *
* Internal dependencies
* /
/ * *
* Cache of state keys to EquivalentKeyMap where the inner map tracks queries
* to their resulting items set . WeakMap allows garbage collection on expired
* state references .
*
* @ type { WeakMap < Object , EquivalentKeyMap > }
* /
var queriedItemsCacheByState = new WeakMap ( ) ;
/ * *
* Returns items for a given query , or null if the items are not known .
*
* @ param { Object } state State object .
* @ param { ? Object } query Optional query .
*
* @ return { ? Array } Query items .
* /
function getQueriedItemsUncached ( state , query ) {
2018-12-17 22:14:52 -05:00
var _getQueryParts = get _query _parts ( query ) ,
2018-12-13 23:41:57 -05:00
stableKey = _getQueryParts . stableKey ,
page = _getQueryParts . page ,
perPage = _getQueryParts . perPage ;
if ( ! state . queries [ stableKey ] ) {
return null ;
}
var itemIds = state . queries [ stableKey ] ;
if ( ! itemIds ) {
return null ;
}
var startOffset = perPage === - 1 ? 0 : ( page - 1 ) * perPage ;
var endOffset = perPage === - 1 ? itemIds . length : Math . min ( startOffset + perPage , itemIds . length ) ;
var items = [ ] ;
for ( var i = startOffset ; i < endOffset ; i ++ ) {
var itemId = itemIds [ i ] ;
items . push ( state . items [ itemId ] ) ;
}
return items ;
}
/ * *
* Returns items for a given query , or null if the items are not known . Caches
* result both per state ( by reference ) and per query ( by deep equality ) .
* The caching approach is intended to be durable to query objects which are
* deeply but not referentially equal , since otherwise :
*
* ` getQueriedItems( state, {} ) !== getQueriedItems( state, {} ) `
*
* @ param { Object } state State object .
* @ param { ? Object } query Optional query .
*
2018-12-17 22:14:52 -05:00
* @ return { ? Array } Query items .
* /
var getQueriedItems = Object ( rememo [ "a" /* default */ ] ) ( function ( state ) {
var query = arguments . length > 1 && arguments [ 1 ] !== undefined ? arguments [ 1 ] : { } ;
var queriedItemsCache = queriedItemsCacheByState . get ( state ) ;
if ( queriedItemsCache ) {
var queriedItems = queriedItemsCache . get ( query ) ;
if ( queriedItems !== undefined ) {
return queriedItems ;
}
} else {
queriedItemsCache = new equivalent _key _map _default . a ( ) ;
queriedItemsCacheByState . set ( state , queriedItemsCache ) ;
}
var items = getQueriedItemsUncached ( state , query ) ;
queriedItemsCache . set ( query , items ) ;
return items ;
} ) ;
// EXTERNAL MODULE: ./node_modules/redux/es/redux.js
2019-03-21 08:48:00 -04:00
var redux = _ _webpack _require _ _ ( 71 ) ;
// EXTERNAL MODULE: ./node_modules/@babel/runtime/regenerator/index.js
var regenerator = _ _webpack _require _ _ ( 26 ) ;
var regenerator _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( regenerator ) ;
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: external {"this":["wp","apiFetch"]}
2019-03-21 08:48:00 -04:00
var external _this _wp _apiFetch _ = _ _webpack _require _ _ ( 33 ) ;
2018-12-17 22:14:52 -05:00
var external _this _wp _apiFetch _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( external _this _wp _apiFetch _ ) ;
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/controls.js
/ * *
* WordPress dependencies
* /
/ * *
* Trigger an API Fetch request .
*
* @ param { Object } request API Fetch Request Object .
* @ return { Object } control descriptor .
* /
function apiFetch ( request ) {
return {
type : 'API_FETCH' ,
request : request
} ;
}
/ * *
* Calls a selector using the current state .
* @ param { string } selectorName Selector name .
* @ param { Array } args Selector arguments .
*
* @ return { Object } control descriptor .
* /
function controls _select ( selectorName ) {
for ( var _len = arguments . length , args = new Array ( _len > 1 ? _len - 1 : 0 ) , _key = 1 ; _key < _len ; _key ++ ) {
args [ _key - 1 ] = arguments [ _key ] ;
}
return {
type : 'SELECT' ,
selectorName : selectorName ,
args : args
} ;
}
var controls = {
API _FETCH : function API _FETCH ( _ref ) {
var request = _ref . request ;
return external _this _wp _apiFetch _default ( ) ( request ) ;
} ,
2019-03-07 04:09:59 -05:00
SELECT : Object ( external _this _wp _data _ [ "createRegistryControl" ] ) ( function ( registry ) {
return function ( _ref2 ) {
var _registry$select ;
2018-12-17 22:14:52 -05:00
2019-03-07 04:09:59 -05:00
var selectorName = _ref2 . selectorName ,
args = _ref2 . args ;
return ( _registry$select = registry . select ( 'core' ) ) [ selectorName ] . apply ( _registry$select , Object ( toConsumableArray [ "a" /* default */ ] ) ( args ) ) ;
} ;
} )
2018-12-17 22:14:52 -05:00
} ;
/* harmony default export */ var build _module _controls = ( controls ) ;
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/actions.js
2019-03-21 08:48:00 -04:00
2018-12-17 22:14:52 -05:00
var _marked =
/*#__PURE__*/
2019-03-21 08:48:00 -04:00
regenerator _default . a . mark ( saveEntityRecord ) ;
2018-12-17 22:14:52 -05:00
/ * *
* External dependencies
* /
/ * *
* Internal dependencies
* /
/ * *
* Returns an action object used in signalling that authors have been received .
*
* @ param { string } queryID Query ID .
* @ param { Array | Object } users Users received .
*
* @ return { Object } Action object .
* /
function receiveUserQuery ( queryID , users ) {
return {
type : 'RECEIVE_USER_QUERY' ,
users : Object ( external _lodash _ [ "castArray" ] ) ( users ) ,
queryID : queryID
} ;
}
/ * *
* Returns an action object used in adding new entities .
*
* @ param { Array } entities Entities received .
*
* @ return { Object } Action object .
* /
function addEntities ( entities ) {
return {
type : 'ADD_ENTITIES' ,
entities : entities
} ;
}
/ * *
* Returns an action object used in signalling that entity records have been received .
*
* @ param { string } kind Kind of the received entity .
* @ param { string } name Name of the received entity .
* @ param { Array | Object } records Records received .
* @ param { ? Object } query Query Object .
* @ param { ? boolean } invalidateCache Should invalidate query caches
*
* @ return { Object } Action object .
* /
function receiveEntityRecords ( kind , name , records , query ) {
var invalidateCache = arguments . length > 4 && arguments [ 4 ] !== undefined ? arguments [ 4 ] : false ;
var action ;
if ( query ) {
action = receiveQueriedItems ( records , query ) ;
} else {
action = receiveItems ( records ) ;
}
return Object ( objectSpread [ "a" /* default */ ] ) ( { } , action , {
kind : kind ,
name : name ,
invalidateCache : invalidateCache
} ) ;
}
/ * *
* Returns an action object used in signalling that the index has been received .
*
* @ param { Object } themeSupports Theme support for the current theme .
*
* @ return { Object } Action object .
* /
function receiveThemeSupports ( themeSupports ) {
return {
type : 'RECEIVE_THEME_SUPPORTS' ,
themeSupports : themeSupports
} ;
}
/ * *
* Returns an action object used in signalling that the preview data for
* a given URl has been received .
*
* @ param { string } url URL to preview the embed for .
* @ param { Mixed } preview Preview data .
*
* @ return { Object } Action object .
* /
function receiveEmbedPreview ( url , preview ) {
return {
type : 'RECEIVE_EMBED_PREVIEW' ,
url : url ,
preview : preview
} ;
}
/ * *
* Action triggered to save an entity record .
*
* @ param { string } kind Kind of the received entity .
* @ param { string } name Name of the received entity .
* @ param { Object } record Record to be saved .
*
* @ return { Object } Updated record .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function saveEntityRecord ( kind , name , record ) {
var entities , entity , key , recordId , updatedRecord ;
2019-03-21 08:48:00 -04:00
return regenerator _default . a . wrap ( function saveEntityRecord$ ( _context ) {
2018-12-17 22:14:52 -05:00
while ( 1 ) {
switch ( _context . prev = _context . next ) {
case 0 :
_context . next = 2 ;
return getKindEntities ( kind ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 2 :
entities = _context . sent ;
entity = Object ( external _lodash _ [ "find" ] ) ( entities , {
kind : kind ,
name : name
} ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( entity ) {
_context . next = 6 ;
break ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return _context . abrupt ( "return" ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 6 :
key = entity . key || DEFAULT _ENTITY _KEY ;
recordId = record [ key ] ;
_context . next = 10 ;
return apiFetch ( {
path : "" . concat ( entity . baseURL ) . concat ( recordId ? '/' + recordId : '' ) ,
method : recordId ? 'PUT' : 'POST' ,
data : record
} ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 10 :
updatedRecord = _context . sent ;
_context . next = 13 ;
return receiveEntityRecords ( kind , name , updatedRecord , undefined , true ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 13 :
return _context . abrupt ( "return" , updatedRecord ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 14 :
case "end" :
return _context . stop ( ) ;
}
}
} , _marked , this ) ;
}
/ * *
* Returns an action object used in signalling that Upload permissions have been received .
*
* @ param { boolean } hasUploadPermissions Does the user have permission to upload files ?
*
* @ return { Object } Action object .
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
function receiveUploadPermissions ( hasUploadPermissions ) {
return {
2019-03-07 04:09:59 -05:00
type : 'RECEIVE_USER_PERMISSION' ,
key : 'create/media' ,
isAllowed : hasUploadPermissions
} ;
}
/ * *
* Returns an action object used in signalling that the current user has
* permission to perform an action on a REST resource .
*
* @ param { string } key A key that represents the action and REST resource .
* @ param { boolean } isAllowed Whether or not the user can perform the action .
*
* @ return { Object } Action object .
* /
function receiveUserPermission ( key , isAllowed ) {
return {
type : 'RECEIVE_USER_PERMISSION' ,
key : key ,
isAllowed : isAllowed
2018-12-17 22:14:52 -05:00
} ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/entities.js
2019-03-21 08:48:00 -04:00
2018-12-17 22:14:52 -05:00
var entities _marked =
/*#__PURE__*/
2019-03-21 08:48:00 -04:00
regenerator _default . a . mark ( loadPostTypeEntities ) ,
2018-12-17 22:14:52 -05:00
_marked2 =
/*#__PURE__*/
2019-03-21 08:48:00 -04:00
regenerator _default . a . mark ( loadTaxonomyEntities ) ,
2018-12-17 22:14:52 -05:00
_marked3 =
/*#__PURE__*/
2019-03-21 08:48:00 -04:00
regenerator _default . a . mark ( getKindEntities ) ;
2018-12-13 23:41:57 -05:00
/ * *
* External dependencies
* /
/ * *
2018-12-17 22:14:52 -05:00
* Internal dependencies
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
var DEFAULT _ENTITY _KEY = 'id' ;
var defaultEntities = [ {
name : 'postType' ,
kind : 'root' ,
key : 'slug' ,
baseURL : '/wp/v2/types'
} , {
name : 'media' ,
kind : 'root' ,
baseURL : '/wp/v2/media' ,
plural : 'mediaItems'
} , {
name : 'taxonomy' ,
kind : 'root' ,
key : 'slug' ,
baseURL : '/wp/v2/taxonomies' ,
plural : 'taxonomies'
} ] ;
var kinds = [ {
name : 'postType' ,
loadEntities : loadPostTypeEntities
} , {
name : 'taxonomy' ,
loadEntities : loadTaxonomyEntities
} ] ;
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Returns the list of post type entities .
*
* @ return { Promise } Entities promise
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function loadPostTypeEntities ( ) {
var postTypes ;
2019-03-21 08:48:00 -04:00
return regenerator _default . a . wrap ( function loadPostTypeEntities$ ( _context ) {
2018-12-17 22:14:52 -05:00
while ( 1 ) {
switch ( _context . prev = _context . next ) {
case 0 :
_context . next = 2 ;
return apiFetch ( {
path : '/wp/v2/types?context=edit'
} ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 2 :
postTypes = _context . sent ;
return _context . abrupt ( "return" , Object ( external _lodash _ [ "map" ] ) ( postTypes , function ( postType , name ) {
return {
kind : 'postType' ,
baseURL : '/wp/v2/' + postType . rest _base ,
name : name
} ;
} ) ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 4 :
case "end" :
return _context . stop ( ) ;
}
}
} , entities _marked , this ) ;
}
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Returns the list of the taxonomies entities .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ return { Promise } Entities promise
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function loadTaxonomyEntities ( ) {
var taxonomies ;
2019-03-21 08:48:00 -04:00
return regenerator _default . a . wrap ( function loadTaxonomyEntities$ ( _context2 ) {
2018-12-17 22:14:52 -05:00
while ( 1 ) {
switch ( _context2 . prev = _context2 . next ) {
case 0 :
_context2 . next = 2 ;
return apiFetch ( {
path : '/wp/v2/taxonomies?context=edit'
} ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 2 :
taxonomies = _context2 . sent ;
return _context2 . abrupt ( "return" , Object ( external _lodash _ [ "map" ] ) ( taxonomies , function ( taxonomy , name ) {
return {
kind : 'taxonomy' ,
baseURL : '/wp/v2/' + taxonomy . rest _base ,
name : name
} ;
} ) ) ;
case 4 :
case "end" :
return _context2 . stop ( ) ;
}
}
} , _marked2 , this ) ;
2018-12-13 23:41:57 -05:00
}
/ * *
2018-12-17 22:14:52 -05:00
* Returns the entity ' s getter method name given its kind and name .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { string } kind Entity kind .
* @ param { string } name Entity name .
* @ param { string } prefix Function prefix .
* @ param { boolean } usePlural Whether to use the plural form or not .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ return { string } Method name
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
var entities _getMethodName = function getMethodName ( kind , name ) {
var prefix = arguments . length > 2 && arguments [ 2 ] !== undefined ? arguments [ 2 ] : 'get' ;
var usePlural = arguments . length > 3 && arguments [ 3 ] !== undefined ? arguments [ 3 ] : false ;
var entity = Object ( external _lodash _ [ "find" ] ) ( defaultEntities , {
kind : kind ,
name : name
} ) ;
var kindPrefix = kind === 'root' ? '' : Object ( external _lodash _ [ "upperFirst" ] ) ( Object ( external _lodash _ [ "camelCase" ] ) ( kind ) ) ;
var nameSuffix = Object ( external _lodash _ [ "upperFirst" ] ) ( Object ( external _lodash _ [ "camelCase" ] ) ( name ) ) + ( usePlural ? 's' : '' ) ;
var suffix = usePlural && entity . plural ? Object ( external _lodash _ [ "upperFirst" ] ) ( Object ( external _lodash _ [ "camelCase" ] ) ( entity . plural ) ) : nameSuffix ;
return "" . concat ( prefix ) . concat ( kindPrefix ) . concat ( suffix ) ;
} ;
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Loads the kind entities into the store .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { string } kind Kind
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ return { Array } Entities
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function getKindEntities ( kind ) {
var entities , kindConfig ;
2019-03-21 08:48:00 -04:00
return regenerator _default . a . wrap ( function getKindEntities$ ( _context3 ) {
2018-12-17 22:14:52 -05:00
while ( 1 ) {
switch ( _context3 . prev = _context3 . next ) {
case 0 :
_context3 . next = 2 ;
return controls _select ( 'getEntitiesByKind' , kind ) ;
case 2 :
entities = _context3 . sent ;
if ( ! ( entities && entities . length !== 0 ) ) {
_context3 . next = 5 ;
break ;
}
return _context3 . abrupt ( "return" , entities ) ;
case 5 :
kindConfig = Object ( external _lodash _ [ "find" ] ) ( kinds , {
name : kind
} ) ;
if ( kindConfig ) {
_context3 . next = 8 ;
break ;
}
return _context3 . abrupt ( "return" , [ ] ) ;
case 8 :
_context3 . next = 10 ;
return kindConfig . loadEntities ( ) ;
case 10 :
entities = _context3 . sent ;
_context3 . next = 13 ;
return addEntities ( entities ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 13 :
return _context3 . abrupt ( "return" , entities ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 14 :
case "end" :
return _context3 . stop ( ) ;
}
}
} , _marked3 , this ) ;
2018-12-13 23:41:57 -05:00
}
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/reducer.js
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* External dependencies
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Internal dependencies
2018-12-13 23:41:57 -05:00
* /
/ * *
2018-12-17 22:14:52 -05:00
* Returns a merged array of item IDs , given details of the received paginated
* items . The array is sparse - like with ` undefined ` entries where holes exist .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { ? Array < number > } itemIds Original item IDs ( default empty array ) .
* @ param { number [ ] } nextItemIds Item IDs to merge .
* @ param { number } page Page of items merged .
* @ param { number } perPage Number of items per page .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ return { number [ ] } Merged array of item IDs .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function getMergedItemIds ( itemIds , nextItemIds , page , perPage ) {
var nextItemIdsStartIndex = ( page - 1 ) * perPage ; // If later page has already been received, default to the larger known
// size of the existing array, else calculate as extending the existing.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var size = Math . max ( itemIds . length , nextItemIdsStartIndex + nextItemIds . length ) ; // Preallocate array since size is known.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var mergedItemIds = new Array ( size ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
for ( var i = 0 ; i < size ; i ++ ) {
// Preserve existing item ID except for subset of range of next items.
var isInNextItemsRange = i >= nextItemIdsStartIndex && i < nextItemIdsStartIndex + nextItemIds . length ;
mergedItemIds [ i ] = isInNextItemsRange ? nextItemIds [ i - nextItemIdsStartIndex ] : itemIds [ i ] ;
2018-12-13 23:41:57 -05:00
}
2018-12-17 22:14:52 -05:00
return mergedItemIds ;
}
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Reducer tracking items state , keyed by ID . Items are assumed to be normal ,
* where identifiers are common across all queries .
2018-12-13 23:41:57 -05:00
*
* @ param { Object } state Current state .
* @ param { Object } action Dispatched action .
*
2018-12-17 22:14:52 -05:00
* @ return { Object } Next state .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function reducer _items ( ) {
2018-12-13 23:41:57 -05:00
var state = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : { } ;
var action = arguments . length > 1 ? arguments [ 1 ] : undefined ;
switch ( action . type ) {
2018-12-17 22:14:52 -05:00
case 'RECEIVE_ITEMS' :
return Object ( objectSpread [ "a" /* default */ ] ) ( { } , state , Object ( external _lodash _ [ "keyBy" ] ) ( action . items , action . key || DEFAULT _ENTITY _KEY ) ) ;
2018-12-13 23:41:57 -05:00
}
return state ;
}
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Reducer tracking queries state , keyed by stable query key . Each reducer
* query object includes ` itemIds ` and ` requestingPageByPerPage ` .
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { Object } state Current state .
* @ param { Object } action Dispatched action .
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
*
2018-12-17 22:14:52 -05:00
* @ return { Object } Next state .
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
* /
2018-12-17 22:14:52 -05:00
var queries = Object ( external _lodash _ [ "flowRight" ] ) ( [ // Limit to matching action type so we don't attempt to replace action on
// an unhandled action.
if _matching _action ( function ( action ) {
return 'query' in action ;
} ) , // Inject query parts into action for use both in `onSubKey` and reducer.
replace _action ( function ( action ) {
// `ifMatchingAction` still passes on initialization, where state is
// undefined and a query is not assigned. Avoid attempting to parse
// parts. `onSubKey` will omit by lack of `stableKey`.
if ( action . query ) {
return Object ( objectSpread [ "a" /* default */ ] ) ( { } , action , get _query _parts ( action . query ) ) ;
}
return action ;
} ) , // Queries shape is shared, but keyed by query `stableKey` part. Original
// reducer tracks only a single query object.
on _sub _key ( 'stableKey' ) ] ) ( function ( ) {
var state = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : null ;
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
var action = arguments . length > 1 ? arguments [ 1 ] : undefined ;
2018-12-17 22:14:52 -05:00
var type = action . type ,
page = action . page ,
perPage = action . perPage ,
_action$key = action . key ,
key = _action$key === void 0 ? DEFAULT _ENTITY _KEY : _action$key ;
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
2018-12-17 22:14:52 -05:00
if ( type !== 'RECEIVE_ITEMS' ) {
return state ;
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
}
2018-12-17 22:14:52 -05:00
return getMergedItemIds ( state || [ ] , Object ( external _lodash _ [ "map" ] ) ( action . items , key ) , page , perPage ) ;
} ) ;
/* harmony default export */ var queried _data _reducer = ( Object ( redux [ "b" /* combineReducers */ ] ) ( {
items : reducer _items ,
queries : queries
2018-12-13 23:41:57 -05:00
} ) ) ;
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/index.js
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/reducer.js
2018-12-13 23:41:57 -05:00
/ * *
* External dependencies
* /
/ * *
* WordPress dependencies
* /
/ * *
* Internal dependencies
* /
/ * *
2018-12-17 22:14:52 -05:00
* Reducer managing terms state . Keyed by taxonomy slug , the value is either
* undefined ( if no request has been made for given taxonomy ) , null ( if a
* request is in - flight for given taxonomy ) , or the array of terms for the
* taxonomy .
*
* @ param { Object } state Current state .
* @ param { Object } action Dispatched action .
*
* @ return { Object } Updated state .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function terms ( ) {
var state = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : { } ;
var action = arguments . length > 1 ? arguments [ 1 ] : undefined ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
switch ( action . type ) {
case 'RECEIVE_TERMS' :
return Object ( objectSpread [ "a" /* default */ ] ) ( { } , state , Object ( defineProperty [ "a" /* default */ ] ) ( { } , action . taxonomy , action . terms ) ) ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return state ;
2018-12-13 23:41:57 -05:00
}
/ * *
2018-12-17 22:14:52 -05:00
* Reducer managing authors state . Keyed by id .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { Object } state Current state .
* @ param { Object } action Dispatched action .
*
* @ return { Object } Updated state .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function reducer _users ( ) {
var state = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : {
byId : { } ,
queries : { }
} ;
var action = arguments . length > 1 ? arguments [ 1 ] : undefined ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
switch ( action . type ) {
case 'RECEIVE_USER_QUERY' :
return {
byId : Object ( objectSpread [ "a" /* default */ ] ) ( { } , state . byId , Object ( external _lodash _ [ "keyBy" ] ) ( action . users , 'id' ) ) ,
queries : Object ( objectSpread [ "a" /* default */ ] ) ( { } , state . queries , Object ( defineProperty [ "a" /* default */ ] ) ( { } , action . queryID , Object ( external _lodash _ [ "map" ] ) ( action . users , function ( user ) {
return user . id ;
} ) ) )
} ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return state ;
2018-12-13 23:41:57 -05:00
}
/ * *
2018-12-17 22:14:52 -05:00
* Reducer managing taxonomies .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { Object } state Current state .
* @ param { Object } action Dispatched action .
*
* @ return { Object } Updated state .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function reducer _taxonomies ( ) {
var state = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : [ ] ;
var action = arguments . length > 1 ? arguments [ 1 ] : undefined ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
switch ( action . type ) {
case 'RECEIVE_TAXONOMIES' :
return action . taxonomies ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return state ;
}
/ * *
* Reducer managing theme supports data .
*
* @ param { Object } state Current state .
* @ param { Object } action Dispatched action .
*
* @ return { Object } Updated state .
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
function themeSupports ( ) {
var state = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : { } ;
var action = arguments . length > 1 ? arguments [ 1 ] : undefined ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
switch ( action . type ) {
case 'RECEIVE_THEME_SUPPORTS' :
return Object ( objectSpread [ "a" /* default */ ] ) ( { } , state , action . themeSupports ) ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return state ;
2018-12-13 23:41:57 -05:00
}
2018-12-17 22:14:52 -05:00
/ * *
* Higher Order Reducer for a given entity config . It supports :
*
* - Fetching a record by primary key
*
* @ param { Object } entityConfig Entity config .
*
* @ return { Function } Reducer .
* /
2018-12-14 06:02:53 -05:00
2018-12-17 22:14:52 -05:00
function reducer _entity ( entityConfig ) {
return Object ( external _lodash _ [ "flowRight" ] ) ( [ // Limit to matching action type so we don't attempt to replace action on
// an unhandled action.
if _matching _action ( function ( action ) {
return action . name && action . kind && action . name === entityConfig . name && action . kind === entityConfig . kind ;
} ) , // Inject the entity config into the action.
replace _action ( function ( action ) {
return Object ( objectSpread [ "a" /* default */ ] ) ( { } , action , {
key : entityConfig . key || DEFAULT _ENTITY _KEY
} ) ;
} ) ] ) ( queried _data _reducer ) ;
}
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Reducer keeping track of the registered entities .
*
* @ param { Object } state Current state .
* @ param { Object } action Dispatched action .
*
* @ return { Object } Updated state .
2018-12-13 23:41:57 -05:00
* /
2018-12-14 06:02:53 -05:00
2018-12-17 22:14:52 -05:00
function entitiesConfig ( ) {
var state = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : defaultEntities ;
var action = arguments . length > 1 ? arguments [ 1 ] : undefined ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
switch ( action . type ) {
case 'ADD_ENTITIES' :
2019-03-07 04:09:59 -05:00
return [ ] . concat ( Object ( toConsumableArray [ "a" /* default */ ] ) ( state ) , Object ( toConsumableArray [ "a" /* default */ ] ) ( action . entities ) ) ;
2018-12-17 22:14:52 -05:00
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return state ;
2018-12-13 23:41:57 -05:00
}
/ * *
2018-12-17 22:14:52 -05:00
* Reducer keeping track of the registered entities config and data .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { Object } state Current state .
* @ param { Object } action Dispatched action .
*
* @ return { Object } Updated state .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
var reducer _entities = function entities ( ) {
var state = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : { } ;
var action = arguments . length > 1 ? arguments [ 1 ] : undefined ;
var newConfig = entitiesConfig ( state . config , action ) ; // Generates a dynamic reducer for the entities
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var entitiesDataReducer = state . reducer ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( ! entitiesDataReducer || newConfig !== state . config ) {
var entitiesByKind = Object ( external _lodash _ [ "groupBy" ] ) ( newConfig , 'kind' ) ;
entitiesDataReducer = Object ( external _this _wp _data _ [ "combineReducers" ] ) ( Object . entries ( entitiesByKind ) . reduce ( function ( memo , _ref ) {
var _ref2 = Object ( slicedToArray [ "a" /* default */ ] ) ( _ref , 2 ) ,
kind = _ref2 [ 0 ] ,
subEntities = _ref2 [ 1 ] ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var kindReducer = Object ( external _this _wp _data _ [ "combineReducers" ] ) ( subEntities . reduce ( function ( kindMemo , entityConfig ) {
return Object ( objectSpread [ "a" /* default */ ] ) ( { } , kindMemo , Object ( defineProperty [ "a" /* default */ ] ) ( { } , entityConfig . name , reducer _entity ( entityConfig ) ) ) ;
} , { } ) ) ;
memo [ kind ] = kindReducer ;
return memo ;
} , { } ) ) ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var newData = entitiesDataReducer ( state . data , action ) ;
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
2018-12-17 22:14:52 -05:00
if ( newData === state . data && newConfig === state . config && entitiesDataReducer === state . reducer ) {
return state ;
}
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
2018-12-17 22:14:52 -05:00
return {
reducer : entitiesDataReducer ,
data : newData ,
config : newConfig
} ;
} ;
/ * *
* Reducer managing embed preview data .
*
* @ param { Object } state Current state .
* @ param { Object } action Dispatched action .
*
* @ return { Object } Updated state .
* /
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
2018-12-17 22:14:52 -05:00
function embedPreviews ( ) {
var state = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : { } ;
var action = arguments . length > 1 ? arguments [ 1 ] : undefined ;
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
2018-12-17 22:14:52 -05:00
switch ( action . type ) {
case 'RECEIVE_EMBED_PREVIEW' :
var url = action . url ,
preview = action . preview ;
return Object ( objectSpread [ "a" /* default */ ] ) ( { } , state , Object ( defineProperty [ "a" /* default */ ] ) ( { } , url , preview ) ) ;
}
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
2018-12-17 22:14:52 -05:00
return state ;
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
}
2018-12-17 22:14:52 -05:00
/ * *
2019-03-07 04:09:59 -05:00
* State which tracks whether the user can perform an action on a REST
* resource .
2018-12-17 22:14:52 -05:00
*
2019-03-07 04:09:59 -05:00
* @ param { Object } state Current state .
* @ param { Object } action Dispatched action .
2018-12-17 22:14:52 -05:00
*
* @ return { Object } Updated state .
* /
2018-12-13 23:41:57 -05:00
2019-03-07 04:09:59 -05:00
function userPermissions ( ) {
var state = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : { } ;
2018-12-17 22:14:52 -05:00
var action = arguments . length > 1 ? arguments [ 1 ] : undefined ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
switch ( action . type ) {
2019-03-07 04:09:59 -05:00
case 'RECEIVE_USER_PERMISSION' :
return Object ( objectSpread [ "a" /* default */ ] ) ( { } , state , Object ( defineProperty [ "a" /* default */ ] ) ( { } , action . key , action . isAllowed ) ) ;
2018-12-17 22:14:52 -05:00
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return state ;
}
/* harmony default export */ var build _module _reducer = ( Object ( external _this _wp _data _ [ "combineReducers" ] ) ( {
terms : terms ,
users : reducer _users ,
taxonomies : reducer _taxonomies ,
themeSupports : themeSupports ,
entities : reducer _entities ,
embedPreviews : embedPreviews ,
2019-03-07 04:09:59 -05:00
userPermissions : userPermissions
2018-12-17 22:14:52 -05:00
} ) ) ;
2019-03-07 04:09:59 -05:00
// EXTERNAL MODULE: external {"this":["wp","deprecated"]}
var external _this _wp _deprecated _ = _ _webpack _require _ _ ( 49 ) ;
var external _this _wp _deprecated _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( external _this _wp _deprecated _ ) ;
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/name.js
/ * *
* The reducer key used by core data in store registration .
* This is defined in a separate file to avoid cycle - dependency
*
* @ type { string }
* /
var REDUCER _KEY = 'core' ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/selectors.js
2018-12-13 23:41:57 -05:00
/ * *
* External dependencies
* /
/ * *
* WordPress dependencies
* /
2019-03-07 04:09:59 -05:00
2018-12-13 23:41:57 -05:00
/ * *
* Internal dependencies
* /
/ * *
* Returns true if a request is in progress for embed preview data , or false
* otherwise .
*
* @ param { Object } state Data state .
* @ param { string } url URL the preview would be for .
*
* @ return { boolean } Whether a request is in progress for an embed preview .
* /
2019-03-07 04:09:59 -05:00
var isRequestingEmbedPreview = Object ( external _this _wp _data _ [ "createRegistrySelector" ] ) ( function ( select ) {
return function ( state , url ) {
return select ( 'core/data' ) . isResolving ( REDUCER _KEY , 'getEmbedPreview' , [ url ] ) ;
} ;
} ) ;
2018-12-13 23:41:57 -05:00
/ * *
* Returns all available authors .
*
* @ param { Object } state Data state .
*
* @ return { Array } Authors list .
* /
function getAuthors ( state ) {
return getUserQueryResults ( state , 'authors' ) ;
}
/ * *
* Returns all the users returned by a query ID .
*
* @ param { Object } state Data state .
* @ param { string } queryID Query ID .
*
* @ return { Array } Users list .
* /
2018-12-17 22:14:52 -05:00
var getUserQueryResults = Object ( rememo [ "a" /* default */ ] ) ( function ( state , queryID ) {
2018-12-13 23:41:57 -05:00
var queryResults = state . users . queries [ queryID ] ;
2018-12-17 22:14:52 -05:00
return Object ( external _lodash _ [ "map" ] ) ( queryResults , function ( id ) {
2018-12-13 23:41:57 -05:00
return state . users . byId [ id ] ;
} ) ;
} , function ( state , queryID ) {
return [ state . users . queries [ queryID ] , state . users . byId ] ;
} ) ;
/ * *
* Returns whether the entities for the give kind are loaded .
*
* @ param { Object } state Data state .
* @ param { string } kind Entity kind .
*
* @ return { boolean } Whether the entities are loaded
* /
function getEntitiesByKind ( state , kind ) {
2018-12-17 22:14:52 -05:00
return Object ( external _lodash _ [ "filter" ] ) ( state . entities . config , {
2018-12-13 23:41:57 -05:00
kind : kind
} ) ;
}
/ * *
* Returns the entity object given its kind and name .
*
* @ param { Object } state Data state .
* @ param { string } kind Entity kind .
* @ param { string } name Entity name .
*
* @ return { Object } Entity
* /
function getEntity ( state , kind , name ) {
2018-12-17 22:14:52 -05:00
return Object ( external _lodash _ [ "find" ] ) ( state . entities . config , {
2018-12-13 23:41:57 -05:00
kind : kind ,
name : name
} ) ;
}
/ * *
* Returns the Entity ' s record object by key .
*
* @ param { Object } state State tree
* @ param { string } kind Entity kind .
* @ param { string } name Entity name .
* @ param { number } key Record ' s key
*
* @ return { Object ? } Record .
* /
function getEntityRecord ( state , kind , name , key ) {
2018-12-17 22:14:52 -05:00
return Object ( external _lodash _ [ "get" ] ) ( state . entities . data , [ kind , name , 'items' , key ] ) ;
2018-12-13 23:41:57 -05:00
}
/ * *
* Returns the Entity ' s records .
*
* @ param { Object } state State tree
* @ param { string } kind Entity kind .
* @ param { string } name Entity name .
* @ param { ? Object } query Optional terms query .
*
* @ return { Array } Records .
* /
function getEntityRecords ( state , kind , name , query ) {
2018-12-17 22:14:52 -05:00
var queriedState = Object ( external _lodash _ [ "get" ] ) ( state . entities . data , [ kind , name ] ) ;
2018-12-13 23:41:57 -05:00
if ( ! queriedState ) {
return [ ] ;
}
2018-12-17 22:14:52 -05:00
return getQueriedItems ( queriedState , query ) ;
2018-12-13 23:41:57 -05:00
}
/ * *
* Return theme supports data in the index .
*
* @ param { Object } state Data state .
*
* @ return { * } Index data .
* /
function getThemeSupports ( state ) {
return state . themeSupports ;
}
/ * *
* Returns the embed preview for the given URL .
*
* @ param { Object } state Data state .
* @ param { string } url Embedded URL .
*
* @ return { * } Undefined if the preview has not been fetched , otherwise , the preview fetched from the embed preview API .
* /
function getEmbedPreview ( state , url ) {
return state . embedPreviews [ url ] ;
}
/ * *
* Determines if the returned preview is an oEmbed link fallback .
*
* WordPress can be configured to return a simple link to a URL if it is not embeddable .
* We need to be able to determine if a URL is embeddable or not , based on what we
* get back from the oEmbed preview API .
*
* @ param { Object } state Data state .
* @ param { string } url Embedded URL .
*
* @ return { booleans } Is the preview for the URL an oEmbed link fallback .
* /
function isPreviewEmbedFallback ( state , url ) {
var preview = state . embedPreviews [ url ] ;
var oEmbedLinkCheck = '<a href="' + url + '">' + url + '</a>' ;
if ( ! preview ) {
return false ;
}
return preview . html === oEmbedLinkCheck ;
}
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
/ * *
2019-03-07 04:09:59 -05:00
* Returns whether the current user can upload media .
*
* Calling this may trigger an OPTIONS request to the REST API via the
* ` canUser() ` resolver .
*
* https : //developer.wordpress.org/rest-api/reference/
*
* @ deprecated since 5.0 . Callers should use the more generic ` canUser() ` selector instead of
* ` hasUploadPermissions() ` , e . g . ` canUser( 'create', 'media' ) ` .
*
* @ param { Object } state Data state .
*
* @ return { boolean } Whether or not the user can upload media . Defaults to ` true ` if the OPTIONS
* request is being made .
* /
function hasUploadPermissions ( state ) {
external _this _wp _deprecated _default ( ) ( "select( 'core' ).hasUploadPermissions()" , {
alternative : "select( 'core' ).canUser( 'create', 'media' )"
} ) ;
return Object ( external _lodash _ [ "defaultTo" ] ) ( canUser ( state , 'create' , 'media' ) , true ) ;
}
/ * *
* Returns whether the current user can perform the given action on the given
* REST resource .
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
*
2019-03-07 04:09:59 -05:00
* Calling this may trigger an OPTIONS request to the REST API via the
* ` canUser() ` resolver .
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
*
2019-03-07 04:09:59 -05:00
* https : //developer.wordpress.org/rest-api/reference/
*
* @ param { Object } state Data state .
* @ param { string } action Action to check . One of : 'create' , 'read' , 'update' , 'delete' .
* @ param { string } resource REST resource to check , e . g . 'media' or 'posts' .
* @ param { string = } id Optional ID of the rest resource to check .
*
* @ return { boolean | undefined } Whether or not the user can perform the action ,
* or ` undefined ` if the OPTIONS request is still being made .
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
* /
2019-03-07 04:09:59 -05:00
function canUser ( state , action , resource , id ) {
var key = Object ( external _lodash _ [ "compact" ] ) ( [ action , resource , id ] ) . join ( '/' ) ;
return Object ( external _lodash _ [ "get" ] ) ( state , [ 'userPermissions' , key ] ) ;
Block Editor: Update `@wordpress` dependencies to match Gutenberg 4.5.1.
- Update the annotations, api-fetch, block-library, blocks, components, compose, core-data, data, date, dom, edit-post, editor, element, format-library, html-entities, i18n, jest-console, jest-preset-default, keycodes, list-reusable-blocks, notices, nux, plugins, rich-text, scripts, token-lists, url, viewport packages.
- Upgrades React from 16.5.2 to 16.6.3.
- Adds a missing `wp-date` dependency to the editor script.
- Updates changed dependencies in `script-loader.php`.
- Fixes undefined notices in some blocks.
- Removes incorrect `gutenberg` textdomain.
Merges [43891], [43903], and [43919] to trunk.
Props atimmer, aduth, youknowriad, danielbachhuber.
See #45145.
Built from https://develop.svn.wordpress.org/trunk@44262
git-svn-id: http://core.svn.wordpress.org/trunk@44092 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2018-12-17 10:37:00 -05:00
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/resolvers.js
2018-12-13 23:41:57 -05:00
2019-03-21 08:48:00 -04:00
2018-12-17 22:14:52 -05:00
var resolvers _marked =
/*#__PURE__*/
2019-03-21 08:48:00 -04:00
regenerator _default . a . mark ( resolvers _getAuthors ) ,
2018-12-17 22:14:52 -05:00
resolvers _marked2 =
/*#__PURE__*/
2019-03-21 08:48:00 -04:00
regenerator _default . a . mark ( resolvers _getEntityRecord ) ,
2018-12-17 22:14:52 -05:00
resolvers _marked3 =
/*#__PURE__*/
2019-03-21 08:48:00 -04:00
regenerator _default . a . mark ( resolvers _getEntityRecords ) ,
2018-12-17 22:14:52 -05:00
_marked4 =
/*#__PURE__*/
2019-03-21 08:48:00 -04:00
regenerator _default . a . mark ( resolvers _getThemeSupports ) ,
2018-12-17 22:14:52 -05:00
_marked5 =
/*#__PURE__*/
2019-03-21 08:48:00 -04:00
regenerator _default . a . mark ( resolvers _getEmbedPreview ) ,
2018-12-17 22:14:52 -05:00
_marked6 =
/*#__PURE__*/
2019-03-21 08:48:00 -04:00
regenerator _default . a . mark ( resolvers _hasUploadPermissions ) ,
2019-03-07 04:09:59 -05:00
_marked7 =
/*#__PURE__*/
2019-03-21 08:48:00 -04:00
regenerator _default . a . mark ( resolvers _canUser ) ;
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* External dependencies
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
/ * *
* WordPress dependencies
* /
2018-12-13 23:41:57 -05:00
2019-03-07 04:09:59 -05:00
2018-12-17 22:14:52 -05:00
/ * *
* Internal dependencies
* /
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Requests authors from the REST API .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function resolvers _getAuthors ( ) {
var users ;
2019-03-21 08:48:00 -04:00
return regenerator _default . a . wrap ( function getAuthors$ ( _context ) {
2018-12-17 22:14:52 -05:00
while ( 1 ) {
switch ( _context . prev = _context . next ) {
case 0 :
_context . next = 2 ;
return apiFetch ( {
path : '/wp/v2/users/?who=authors&per_page=-1'
} ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 2 :
users = _context . sent ;
_context . next = 5 ;
return receiveUserQuery ( 'authors' , users ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 5 :
case "end" :
return _context . stop ( ) ;
2018-12-13 23:41:57 -05:00
}
2018-12-17 22:14:52 -05:00
}
} , resolvers _marked , this ) ;
}
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Requests an entity ' s record from the REST API .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { string } kind Entity kind .
* @ param { string } name Entity name .
* @ param { number } key Record ' s key
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function resolvers _getEntityRecord ( kind , name , key ) {
var entities , entity , record ;
2019-03-21 08:48:00 -04:00
return regenerator _default . a . wrap ( function getEntityRecord$ ( _context2 ) {
2018-12-17 22:14:52 -05:00
while ( 1 ) {
switch ( _context2 . prev = _context2 . next ) {
case 0 :
_context2 . next = 2 ;
return getKindEntities ( kind ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 2 :
entities = _context2 . sent ;
entity = Object ( external _lodash _ [ "find" ] ) ( entities , {
kind : kind ,
name : name
} ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( entity ) {
_context2 . next = 6 ;
break ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return _context2 . abrupt ( "return" ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 6 :
_context2 . next = 8 ;
return apiFetch ( {
path : "" . concat ( entity . baseURL , "/" ) . concat ( key , "?context=edit" )
} ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 8 :
record = _context2 . sent ;
_context2 . next = 11 ;
return receiveEntityRecords ( kind , name , record ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 11 :
case "end" :
return _context2 . stop ( ) ;
2018-12-13 23:41:57 -05:00
}
}
2018-12-17 22:14:52 -05:00
} , resolvers _marked2 , this ) ;
2018-12-13 23:41:57 -05:00
}
2018-12-17 22:14:52 -05:00
/ * *
* Requests the entity ' s records from the REST API .
*
* @ param { string } kind Entity kind .
* @ param { string } name Entity name .
* @ param { Object ? } query Query Object .
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
function resolvers _getEntityRecords ( kind , name ) {
var query ,
entities ,
entity ,
path ,
records ,
_args3 = arguments ;
2019-03-21 08:48:00 -04:00
return regenerator _default . a . wrap ( function getEntityRecords$ ( _context3 ) {
2018-12-17 22:14:52 -05:00
while ( 1 ) {
switch ( _context3 . prev = _context3 . next ) {
case 0 :
query = _args3 . length > 2 && _args3 [ 2 ] !== undefined ? _args3 [ 2 ] : { } ;
_context3 . next = 3 ;
return getKindEntities ( kind ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 3 :
entities = _context3 . sent ;
entity = Object ( external _lodash _ [ "find" ] ) ( entities , {
kind : kind ,
name : name
} ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( entity ) {
_context3 . next = 7 ;
break ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return _context3 . abrupt ( "return" ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 7 :
path = Object ( external _this _wp _url _ [ "addQueryArgs" ] ) ( entity . baseURL , Object ( objectSpread [ "a" /* default */ ] ) ( { } , query , {
context : 'edit'
} ) ) ;
_context3 . next = 10 ;
return apiFetch ( {
path : path
} ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 10 :
records = _context3 . sent ;
_context3 . next = 13 ;
return receiveEntityRecords ( kind , name , Object . values ( records ) , query ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 13 :
case "end" :
return _context3 . stop ( ) ;
}
}
} , resolvers _marked3 , this ) ;
2018-12-13 23:41:57 -05:00
}
2018-12-17 22:14:52 -05:00
resolvers _getEntityRecords . shouldInvalidate = function ( action , kind , name ) {
return action . type === 'RECEIVE_ITEMS' && action . invalidateCache && kind === action . kind && name === action . name ;
} ;
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Requests theme supports data from the index .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function resolvers _getThemeSupports ( ) {
var activeThemes ;
2019-03-21 08:48:00 -04:00
return regenerator _default . a . wrap ( function getThemeSupports$ ( _context4 ) {
2018-12-17 22:14:52 -05:00
while ( 1 ) {
switch ( _context4 . prev = _context4 . next ) {
case 0 :
_context4 . next = 2 ;
return apiFetch ( {
path : '/wp/v2/themes?status=active'
} ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 2 :
activeThemes = _context4 . sent ;
_context4 . next = 5 ;
return receiveThemeSupports ( activeThemes [ 0 ] . theme _supports ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 5 :
case "end" :
return _context4 . stop ( ) ;
}
}
} , _marked4 , this ) ;
}
/ * *
* Requests a preview from the from the Embed API .
*
* @ param { string } url URL to get the preview for .
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
function resolvers _getEmbedPreview ( url ) {
var embedProxyResponse ;
2019-03-21 08:48:00 -04:00
return regenerator _default . a . wrap ( function getEmbedPreview$ ( _context5 ) {
2018-12-17 22:14:52 -05:00
while ( 1 ) {
switch ( _context5 . prev = _context5 . next ) {
case 0 :
_context5 . prev = 0 ;
_context5 . next = 3 ;
return apiFetch ( {
path : Object ( external _this _wp _url _ [ "addQueryArgs" ] ) ( '/oembed/1.0/proxy' , {
url : url
} )
} ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 3 :
embedProxyResponse = _context5 . sent ;
_context5 . next = 6 ;
return receiveEmbedPreview ( url , embedProxyResponse ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 6 :
_context5 . next = 12 ;
break ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
case 8 :
_context5 . prev = 8 ;
_context5 . t0 = _context5 [ "catch" ] ( 0 ) ;
_context5 . next = 12 ;
return receiveEmbedPreview ( url , false ) ;
case 12 :
case "end" :
return _context5 . stop ( ) ;
}
2018-12-13 23:41:57 -05:00
}
2018-12-17 22:14:52 -05:00
} , _marked5 , this , [ [ 0 , 8 ] ] ) ;
}
/ * *
* Requests Upload Permissions from the REST API .
2019-03-07 04:09:59 -05:00
*
* @ deprecated since 5.0 . Callers should use the more generic ` canUser() ` selector instead of
* ` hasUploadPermissions() ` , e . g . ` canUser( 'create', 'media' ) ` .
2018-12-17 22:14:52 -05:00
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
function resolvers _hasUploadPermissions ( ) {
2019-03-21 08:48:00 -04:00
return regenerator _default . a . wrap ( function hasUploadPermissions$ ( _context6 ) {
2018-12-17 22:14:52 -05:00
while ( 1 ) {
switch ( _context6 . prev = _context6 . next ) {
case 0 :
2019-03-07 04:09:59 -05:00
external _this _wp _deprecated _default ( ) ( "select( 'core' ).hasUploadPermissions()" , {
alternative : "select( 'core' ).canUser( 'create', 'media' )"
} ) ;
return _context6 . delegateYield ( resolvers _canUser ( 'create' , 'media' ) , "t0" , 2 ) ;
case 2 :
case "end" :
return _context6 . stop ( ) ;
}
}
} , _marked6 , this ) ;
}
/ * *
* Checks whether the current user can perform the given action on the given
* REST resource .
*
* @ param { string } action Action to check . One of : 'create' , 'read' , 'update' ,
* 'delete' .
* @ param { string } resource REST resource to check , e . g . 'media' or 'posts' .
* @ param { ? string } id ID of the rest resource to check .
* /
function resolvers _canUser ( action , resource , id ) {
var methods , method , path , response , allowHeader , key , isAllowed ;
2019-03-21 08:48:00 -04:00
return regenerator _default . a . wrap ( function canUser$ ( _context7 ) {
2019-03-07 04:09:59 -05:00
while ( 1 ) {
switch ( _context7 . prev = _context7 . next ) {
case 0 :
methods = {
create : 'POST' ,
read : 'GET' ,
update : 'PUT' ,
delete : 'DELETE'
} ;
method = methods [ action ] ;
if ( method ) {
_context7 . next = 4 ;
break ;
}
throw new Error ( "'" . concat ( action , "' is not a valid action." ) ) ;
case 4 :
path = id ? "/wp/v2/" . concat ( resource , "/" ) . concat ( id ) : "/wp/v2/" . concat ( resource ) ;
_context7 . prev = 5 ;
_context7 . next = 8 ;
2018-12-17 22:14:52 -05:00
return apiFetch ( {
2019-03-07 04:09:59 -05:00
path : path ,
// Ideally this would always be an OPTIONS request, but unfortunately there's
// a bug in the REST API which causes the Allow header to not be sent on
// OPTIONS requests to /posts/:id routes.
// https://core.trac.wordpress.org/ticket/45753
method : id ? 'GET' : 'OPTIONS' ,
2018-12-17 22:14:52 -05:00
parse : false
} ) ;
2018-12-13 23:41:57 -05:00
2019-03-07 04:09:59 -05:00
case 8 :
response = _context7 . sent ;
_context7 . next = 14 ;
break ;
case 11 :
_context7 . prev = 11 ;
_context7 . t0 = _context7 [ "catch" ] ( 5 ) ;
return _context7 . abrupt ( "return" ) ;
2018-12-13 23:41:57 -05:00
2019-03-07 04:09:59 -05:00
case 14 :
2018-12-17 22:14:52 -05:00
if ( Object ( external _lodash _ [ "hasIn" ] ) ( response , [ 'headers' , 'get' ] ) ) {
// If the request is fetched using the fetch api, the header can be
// retrieved using the 'get' method.
allowHeader = response . headers . get ( 'allow' ) ;
} else {
// If the request was preloaded server-side and is returned by the
// preloading middleware, the header will be a simple property.
allowHeader = Object ( external _lodash _ [ "get" ] ) ( response , [ 'headers' , 'Allow' ] , '' ) ;
}
2018-12-13 23:41:57 -05:00
2019-03-07 04:09:59 -05:00
key = Object ( external _lodash _ [ "compact" ] ) ( [ action , resource , id ] ) . join ( '/' ) ;
isAllowed = Object ( external _lodash _ [ "includes" ] ) ( allowHeader , method ) ;
_context7 . next = 19 ;
return receiveUserPermission ( key , isAllowed ) ;
2018-12-13 23:41:57 -05:00
2019-03-07 04:09:59 -05:00
case 19 :
2018-12-17 22:14:52 -05:00
case "end" :
2019-03-07 04:09:59 -05:00
return _context7 . stop ( ) ;
2018-12-17 22:14:52 -05:00
}
}
2019-03-07 04:09:59 -05:00
} , _marked7 , this , [ [ 5 , 11 ] ] ) ;
2018-12-17 22:14:52 -05:00
}
// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/index.js
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* WordPress dependencies
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
/ * *
* Internal dependencies
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// The entity selectors/resolvers and actions are shortcuts to their generic equivalents
// (getEntityRecord, getEntityRecords, updateEntityRecord, updateEntityRecordss)
// Instead of getEntityRecord, the consumer could use more user-frieldly named selector: getPostType, getTaxonomy...
// The "kind" and the "name" of the entity are combined to generate these shortcuts.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var entitySelectors = defaultEntities . reduce ( function ( result , entity ) {
var kind = entity . kind ,
name = entity . name ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
result [ entities _getMethodName ( kind , name ) ] = function ( state , key ) {
return getEntityRecord ( state , kind , name , key ) ;
} ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
result [ entities _getMethodName ( kind , name , 'get' , true ) ] = function ( state ) {
for ( var _len = arguments . length , args = new Array ( _len > 1 ? _len - 1 : 0 ) , _key = 1 ; _key < _len ; _key ++ ) {
args [ _key - 1 ] = arguments [ _key ] ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return getEntityRecords . apply ( build _module _selectors _namespaceObject , [ state , kind , name ] . concat ( args ) ) ;
} ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return result ;
} , { } ) ;
var entityResolvers = defaultEntities . reduce ( function ( result , entity ) {
var kind = entity . kind ,
name = entity . name ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
result [ entities _getMethodName ( kind , name ) ] = function ( key ) {
return resolvers _getEntityRecord ( kind , name , key ) ;
} ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var pluralMethodName = entities _getMethodName ( kind , name , 'get' , true ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
result [ pluralMethodName ] = function ( ) {
for ( var _len2 = arguments . length , args = new Array ( _len2 ) , _key2 = 0 ; _key2 < _len2 ; _key2 ++ ) {
args [ _key2 ] = arguments [ _key2 ] ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return resolvers _getEntityRecords . apply ( resolvers _namespaceObject , [ kind , name ] . concat ( args ) ) ;
} ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
result [ pluralMethodName ] . shouldInvalidate = function ( action ) {
var _resolvers$getEntityR ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
for ( var _len3 = arguments . length , args = new Array ( _len3 > 1 ? _len3 - 1 : 0 ) , _key3 = 1 ; _key3 < _len3 ; _key3 ++ ) {
args [ _key3 - 1 ] = arguments [ _key3 ] ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return ( _resolvers$getEntityR = resolvers _getEntityRecords ) . shouldInvalidate . apply ( _resolvers$getEntityR , [ action , kind , name ] . concat ( args ) ) ;
} ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return result ;
} , { } ) ;
var entityActions = defaultEntities . reduce ( function ( result , entity ) {
var kind = entity . kind ,
name = entity . name ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
result [ entities _getMethodName ( kind , name , 'save' ) ] = function ( key ) {
return saveEntityRecord ( kind , name , key ) ;
} ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return result ;
} , { } ) ;
Object ( external _this _wp _data _ [ "registerStore" ] ) ( REDUCER _KEY , {
reducer : build _module _reducer ,
controls : build _module _controls ,
actions : Object ( objectSpread [ "a" /* default */ ] ) ( { } , build _module _actions _namespaceObject , entityActions ) ,
selectors : Object ( objectSpread [ "a" /* default */ ] ) ( { } , build _module _selectors _namespaceObject , entitySelectors ) ,
resolvers : Object ( objectSpread [ "a" /* default */ ] ) ( { } , resolvers _namespaceObject , entityResolvers )
} ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/***/ } ) ,
2018-12-13 23:41:57 -05:00
2019-03-21 08:48:00 -04:00
/***/ 37 :
2018-12-17 22:14:52 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _arrayWithHoles ; } ) ;
function _arrayWithHoles ( arr ) {
if ( Array . isArray ( arr ) ) return arr ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/***/ } ) ,
2018-12-13 23:41:57 -05:00
2019-03-21 08:48:00 -04:00
/***/ 38 :
2018-12-17 22:14:52 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
"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" ) ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/***/ } ) ,
2018-12-13 23:41:57 -05:00
2019-03-07 04:09:59 -05:00
/***/ 49 :
/***/ ( function ( module , exports ) {
( function ( ) { module . exports = this [ "wp" ] [ "deprecated" ] ; } ( ) ) ;
/***/ } ) ,
2018-12-17 22:14:52 -05:00
/***/ 5 :
/***/ ( function ( module , exports ) {
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
( function ( ) { module . exports = this [ "wp" ] [ "data" ] ; } ( ) ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/***/ } ) ,
2018-12-13 23:41:57 -05:00
2019-03-21 08:48:00 -04:00
/***/ 54 :
/***/ ( 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 .
* /
// This method of obtaining a reference to the global object needs to be
// kept identical to the way it is obtained in runtime.js
var g = ( function ( ) {
return this || ( typeof self === "object" && self ) ;
} ) ( ) || Function ( "return this" ) ( ) ;
// Use `getOwnPropertyNames` because not all browsers support calling
// `hasOwnProperty` on the global `self` object in a worker. See #183.
var hadRuntime = g . regeneratorRuntime &&
Object . getOwnPropertyNames ( g ) . indexOf ( "regeneratorRuntime" ) >= 0 ;
// Save the old regeneratorRuntime in case it needs to be restored later.
var oldRuntime = hadRuntime && g . regeneratorRuntime ;
// Force reevalutation of runtime.js.
g . regeneratorRuntime = undefined ;
module . exports = _ _webpack _require _ _ ( 55 ) ;
if ( hadRuntime ) {
// Restore the original runtime.
g . regeneratorRuntime = oldRuntime ;
} else {
// Remove the global property added by runtime.js.
try {
delete g . regeneratorRuntime ;
} catch ( e ) {
g . regeneratorRuntime = undefined ;
}
}
/***/ } ) ,
/***/ 55 :
/***/ ( function ( module , exports ) {
/ * *
* 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 .
* /
! ( function ( global ) {
"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" ;
var inModule = typeof module === "object" ;
var runtime = global . regeneratorRuntime ;
if ( runtime ) {
if ( inModule ) {
// If regeneratorRuntime is defined globally and we're in a module,
// make the exports object identical to regeneratorRuntime.
module . exports = runtime ;
}
// Don't bother evaluating the rest of this file if the runtime was
// already defined globally.
return ;
}
// Define the runtime globally (as expected by generated code) as either
// module.exports (if we're in a module) or a new, empty object.
runtime = global . regeneratorRuntime = inModule ? module . exports : { } ;
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 ;
}
runtime . 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 ) ;
} ;
} ) ;
}
runtime . 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 ;
} ;
runtime . 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.
runtime . 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 ;
} ;
runtime . 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.
runtime . async = function ( innerFn , outerFn , self , tryLocsList ) {
var iter = new AsyncIterator (
wrap ( innerFn , outerFn , self , tryLocsList )
) ;
return runtime . 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" ) {
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 ) ;
}
runtime . 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 } ;
}
runtime . 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 ;
}
} ;
} ) (
// In sloppy mode, unbound `this` refers to the global object, fallback to
// Function constructor if we're in global strict mode. That is sadly a form
// of indirect eval which violates Content Security Policy.
( function ( ) {
return this || ( typeof self === "object" && self ) ;
} ) ( ) || Function ( "return this" ) ( )
) ;
/***/ } ) ,
/***/ 59 :
2018-12-17 22:14:52 -05:00
/***/ ( function ( module , exports ) {
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
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 ;
2018-12-13 23:41:57 -05:00
/***/ } ) ,
2019-03-21 08:48:00 -04:00
/***/ 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 _ _ ( 15 ) ;
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 ;
}
/***/ } ) ,
/***/ 71 :
2018-12-13 23:41:57 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
2018-12-17 22:14:52 -05:00
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "c" , function ( ) { return createStore ; } ) ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "b" , function ( ) { return combineReducers ; } ) ;
/* unused harmony export bindActionCreators */
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return applyMiddleware ; } ) ;
/* unused harmony export compose */
/* unused harmony export __DO_NOT_USE__ActionTypes */
2019-03-21 08:48:00 -04:00
/* harmony import */ var symbol _observable _ _WEBPACK _IMPORTED _MODULE _0 _ _ = _ _webpack _require _ _ ( 77 ) ;
2018-12-13 23:41:57 -05:00
/ * *
* These are private action types reserved by Redux .
* For any unknown actions , you must return the current state .
* If the current state is undefined , you must return the initial state .
* Do not reference these action types directly in your code .
* /
var randomString = function randomString ( ) {
return Math . random ( ) . toString ( 36 ) . substring ( 7 ) . split ( '' ) . join ( '.' ) ;
} ;
var ActionTypes = {
INIT : "@@redux/INIT" + randomString ( ) ,
REPLACE : "@@redux/REPLACE" + randomString ( ) ,
PROBE _UNKNOWN _ACTION : function PROBE _UNKNOWN _ACTION ( ) {
return "@@redux/PROBE_UNKNOWN_ACTION" + randomString ( ) ;
}
} ;
/ * *
* @ param { any } obj The object to inspect .
* @ returns { boolean } True if the argument appears to be a plain object .
* /
function isPlainObject ( obj ) {
if ( typeof obj !== 'object' || obj === null ) return false ;
var proto = obj ;
while ( Object . getPrototypeOf ( proto ) !== null ) {
proto = Object . getPrototypeOf ( proto ) ;
}
return Object . getPrototypeOf ( obj ) === proto ;
}
/ * *
* Creates a Redux store that holds the state tree .
* The only way to change the data in the store is to call ` dispatch() ` on it .
*
* There should only be a single store in your app . To specify how different
* parts of the state tree respond to actions , you may combine several reducers
* into a single reducer function by using ` combineReducers ` .
*
* @ param { Function } reducer A function that returns the next state tree , given
* the current state tree and the action to handle .
*
* @ param { any } [ preloadedState ] The initial state . You may optionally specify it
* to hydrate the state from the server in universal apps , or to restore a
* previously serialized user session .
* If you use ` combineReducers ` to produce the root reducer function , this must be
* an object with the same shape as ` combineReducers ` keys .
*
* @ param { Function } [ enhancer ] The store enhancer . You may optionally specify it
* to enhance the store with third - party capabilities such as middleware ,
* time travel , persistence , etc . The only store enhancer that ships with Redux
* is ` applyMiddleware() ` .
*
* @ returns { Store } A Redux store that lets you read the state , dispatch actions
* and subscribe to changes .
* /
function createStore ( reducer , preloadedState , enhancer ) {
var _ref2 ;
if ( typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments [ 3 ] === 'function' ) {
throw new Error ( 'It looks like you are passing several store enhancers to ' + 'createStore(). This is not supported. Instead, compose them ' + 'together to a single function' ) ;
}
if ( typeof preloadedState === 'function' && typeof enhancer === 'undefined' ) {
enhancer = preloadedState ;
preloadedState = undefined ;
}
if ( typeof enhancer !== 'undefined' ) {
if ( typeof enhancer !== 'function' ) {
throw new Error ( 'Expected the enhancer to be a function.' ) ;
}
return enhancer ( createStore ) ( reducer , preloadedState ) ;
}
if ( typeof reducer !== 'function' ) {
throw new Error ( 'Expected the reducer to be a function.' ) ;
}
var currentReducer = reducer ;
var currentState = preloadedState ;
var currentListeners = [ ] ;
var nextListeners = currentListeners ;
var isDispatching = false ;
function ensureCanMutateNextListeners ( ) {
if ( nextListeners === currentListeners ) {
nextListeners = currentListeners . slice ( ) ;
}
}
/ * *
* Reads the state tree managed by the store .
*
* @ returns { any } The current state tree of your application .
* /
function getState ( ) {
if ( isDispatching ) {
throw new Error ( 'You may not call store.getState() while the reducer is executing. ' + 'The reducer has already received the state as an argument. ' + 'Pass it down from the top reducer instead of reading it from the store.' ) ;
}
return currentState ;
}
/ * *
* Adds a change listener . It will be called any time an action is dispatched ,
* and some part of the state tree may potentially have changed . You may then
* call ` getState() ` to read the current state tree inside the callback .
*
* You may call ` dispatch() ` from a change listener , with the following
* caveats :
*
* 1. The subscriptions are snapshotted just before every ` dispatch() ` call .
* If you subscribe or unsubscribe while the listeners are being invoked , this
* will not have any effect on the ` dispatch() ` that is currently in progress .
* However , the next ` dispatch() ` call , whether nested or not , will use a more
* recent snapshot of the subscription list .
*
* 2. The listener should not expect to see all state changes , as the state
* might have been updated multiple times during a nested ` dispatch() ` before
* the listener is called . It is , however , guaranteed that all subscribers
* registered before the ` dispatch() ` started will be called with the latest
* state by the time it exits .
*
* @ param { Function } listener A callback to be invoked on every dispatch .
* @ returns { Function } A function to remove this change listener .
* /
function subscribe ( listener ) {
if ( typeof listener !== 'function' ) {
throw new Error ( 'Expected the listener to be a function.' ) ;
}
if ( isDispatching ) {
throw new Error ( 'You may not call store.subscribe() while the reducer is executing. ' + 'If you would like to be notified after the store has been updated, subscribe from a ' + 'component and invoke store.getState() in the callback to access the latest state. ' + 'See https://redux.js.org/api-reference/store#subscribe(listener) for more details.' ) ;
}
var isSubscribed = true ;
ensureCanMutateNextListeners ( ) ;
nextListeners . push ( listener ) ;
return function unsubscribe ( ) {
if ( ! isSubscribed ) {
return ;
}
if ( isDispatching ) {
throw new Error ( 'You may not unsubscribe from a store listener while the reducer is executing. ' + 'See https://redux.js.org/api-reference/store#subscribe(listener) for more details.' ) ;
}
isSubscribed = false ;
ensureCanMutateNextListeners ( ) ;
var index = nextListeners . indexOf ( listener ) ;
nextListeners . splice ( index , 1 ) ;
} ;
}
/ * *
* Dispatches an action . It is the only way to trigger a state change .
*
* The ` reducer ` function , used to create the store , will be called with the
* current state tree and the given ` action ` . Its return value will
* be considered the * * next * * state of the tree , and the change listeners
* will be notified .
*
* The base implementation only supports plain object actions . If you want to
* dispatch a Promise , an Observable , a thunk , or something else , you need to
* wrap your store creating function into the corresponding middleware . For
* example , see the documentation for the ` redux-thunk ` package . Even the
* middleware will eventually dispatch plain object actions using this method .
*
* @ param { Object } action A plain object representing “ what changed ” . It is
* a good idea to keep actions serializable so you can record and replay user
* sessions , or use the time travelling ` redux-devtools ` . An action must have
* a ` type ` property which may not be ` undefined ` . It is a good idea to use
* string constants for action types .
*
* @ returns { Object } For convenience , the same action object you dispatched .
*
* Note that , if you use a custom middleware , it may wrap ` dispatch() ` to
* return something else ( for example , a Promise you can await ) .
* /
function dispatch ( action ) {
if ( ! isPlainObject ( action ) ) {
throw new Error ( 'Actions must be plain objects. ' + 'Use custom middleware for async actions.' ) ;
}
if ( typeof action . type === 'undefined' ) {
throw new Error ( 'Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?' ) ;
}
if ( isDispatching ) {
throw new Error ( 'Reducers may not dispatch actions.' ) ;
}
try {
isDispatching = true ;
currentState = currentReducer ( currentState , action ) ;
} finally {
isDispatching = false ;
}
var listeners = currentListeners = nextListeners ;
for ( var i = 0 ; i < listeners . length ; i ++ ) {
var listener = listeners [ i ] ;
listener ( ) ;
}
return action ;
}
/ * *
* Replaces the reducer currently used by the store to calculate the state .
*
* You might need this if your app implements code splitting and you want to
* load some of the reducers dynamically . You might also need this if you
* implement a hot reloading mechanism for Redux .
*
* @ param { Function } nextReducer The reducer for the store to use instead .
* @ returns { void }
* /
function replaceReducer ( nextReducer ) {
if ( typeof nextReducer !== 'function' ) {
throw new Error ( 'Expected the nextReducer to be a function.' ) ;
}
currentReducer = nextReducer ;
dispatch ( {
type : ActionTypes . REPLACE
} ) ;
}
/ * *
* Interoperability point for observable / reactive libraries .
* @ returns { observable } A minimal observable of state changes .
* For more information , see the observable proposal :
* https : //github.com/tc39/proposal-observable
* /
function observable ( ) {
var _ref ;
var outerSubscribe = subscribe ;
return _ref = {
/ * *
* The minimal observable subscription method .
* @ param { Object } observer Any object that can be used as an observer .
* The observer object should have a ` next ` method .
* @ returns { subscription } An object with an ` unsubscribe ` method that can
* be used to unsubscribe the observable from the store , and prevent further
* emission of values from the observable .
* /
subscribe : function subscribe ( observer ) {
if ( typeof observer !== 'object' || observer === null ) {
throw new TypeError ( 'Expected the observer to be an object.' ) ;
}
function observeState ( ) {
if ( observer . next ) {
observer . next ( getState ( ) ) ;
}
}
observeState ( ) ;
var unsubscribe = outerSubscribe ( observeState ) ;
return {
unsubscribe : unsubscribe
} ;
}
2018-12-17 22:14:52 -05:00
} , _ref [ symbol _observable _ _WEBPACK _IMPORTED _MODULE _0 _ _ [ /* default */ "a" ] ] = function ( ) {
2018-12-13 23:41:57 -05:00
return this ;
} , _ref ;
} // When a store is created, an "INIT" action is dispatched so that every
// reducer returns their initial state. This effectively populates
// the initial state tree.
dispatch ( {
type : ActionTypes . INIT
} ) ;
return _ref2 = {
dispatch : dispatch ,
subscribe : subscribe ,
getState : getState ,
replaceReducer : replaceReducer
2018-12-17 22:14:52 -05:00
} , _ref2 [ symbol _observable _ _WEBPACK _IMPORTED _MODULE _0 _ _ [ /* default */ "a" ] ] = observable , _ref2 ;
2018-12-13 23:41:57 -05:00
}
/ * *
* Prints a warning in the console if it exists .
*
* @ param { String } message The warning message .
* @ returns { void }
* /
function warning ( message ) {
/* eslint-disable no-console */
if ( typeof console !== 'undefined' && typeof console . error === 'function' ) {
console . error ( message ) ;
}
/* eslint-enable no-console */
try {
// This error was thrown as a convenience so that if you enable
// "break on all exceptions" in your console,
// it would pause the execution at this line.
throw new Error ( message ) ;
} catch ( e ) { } // eslint-disable-line no-empty
}
function getUndefinedStateErrorMessage ( key , action ) {
var actionType = action && action . type ;
var actionDescription = actionType && "action \"" + String ( actionType ) + "\"" || 'an action' ;
return "Given " + actionDescription + ", reducer \"" + key + "\" returned undefined. " + "To ignore an action, you must explicitly return the previous state. " + "If you want this reducer to hold no value, you can return null instead of undefined." ;
}
function getUnexpectedStateShapeWarningMessage ( inputState , reducers , action , unexpectedKeyCache ) {
var reducerKeys = Object . keys ( reducers ) ;
var argumentName = action && action . type === ActionTypes . INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer' ;
if ( reducerKeys . length === 0 ) {
return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.' ;
}
if ( ! isPlainObject ( inputState ) ) {
return "The " + argumentName + " has unexpected type of \"" + { } . toString . call ( inputState ) . match ( /\s([a-z|A-Z]+)/ ) [ 1 ] + "\". Expected argument to be an object with the following " + ( "keys: \"" + reducerKeys . join ( '", "' ) + "\"" ) ;
}
var unexpectedKeys = Object . keys ( inputState ) . filter ( function ( key ) {
return ! reducers . hasOwnProperty ( key ) && ! unexpectedKeyCache [ key ] ;
} ) ;
unexpectedKeys . forEach ( function ( key ) {
unexpectedKeyCache [ key ] = true ;
} ) ;
if ( action && action . type === ActionTypes . REPLACE ) return ;
if ( unexpectedKeys . length > 0 ) {
return "Unexpected " + ( unexpectedKeys . length > 1 ? 'keys' : 'key' ) + " " + ( "\"" + unexpectedKeys . join ( '", "' ) + "\" found in " + argumentName + ". " ) + "Expected to find one of the known reducer keys instead: " + ( "\"" + reducerKeys . join ( '", "' ) + "\". Unexpected keys will be ignored." ) ;
}
}
function assertReducerShape ( reducers ) {
Object . keys ( reducers ) . forEach ( function ( key ) {
var reducer = reducers [ key ] ;
var initialState = reducer ( undefined , {
type : ActionTypes . INIT
} ) ;
if ( typeof initialState === 'undefined' ) {
throw new Error ( "Reducer \"" + key + "\" returned undefined during initialization. " + "If the state passed to the reducer is undefined, you must " + "explicitly return the initial state. The initial state may " + "not be undefined. If you don't want to set a value for this reducer, " + "you can use null instead of undefined." ) ;
}
if ( typeof reducer ( undefined , {
type : ActionTypes . PROBE _UNKNOWN _ACTION ( )
} ) === 'undefined' ) {
throw new Error ( "Reducer \"" + key + "\" returned undefined when probed with a random type. " + ( "Don't try to handle " + ActionTypes . INIT + " or other actions in \"redux/*\" " ) + "namespace. They are considered private. Instead, you must return the " + "current state for any unknown actions, unless it is undefined, " + "in which case you must return the initial state, regardless of the " + "action type. The initial state may not be undefined, but can be null." ) ;
}
} ) ;
}
/ * *
* Turns an object whose values are different reducer functions , into a single
* reducer function . It will call every child reducer , and gather their results
* into a single state object , whose keys correspond to the keys of the passed
* reducer functions .
*
* @ param { Object } reducers An object whose values correspond to different
* reducer functions that need to be combined into one . One handy way to obtain
* it is to use ES6 ` import * as reducers ` syntax . The reducers may never return
* undefined for any action . Instead , they should return their initial state
* if the state passed to them was undefined , and the current state for any
* unrecognized action .
*
* @ returns { Function } A reducer function that invokes every reducer inside the
* passed object , and builds a state object with the same shape .
* /
function combineReducers ( reducers ) {
var reducerKeys = Object . keys ( reducers ) ;
var finalReducers = { } ;
for ( var i = 0 ; i < reducerKeys . length ; i ++ ) {
var key = reducerKeys [ i ] ;
2018-12-17 22:14:52 -05:00
if ( false ) { }
2018-12-13 23:41:57 -05:00
if ( typeof reducers [ key ] === 'function' ) {
finalReducers [ key ] = reducers [ key ] ;
}
}
var finalReducerKeys = Object . keys ( finalReducers ) ;
var unexpectedKeyCache ;
2018-12-17 22:14:52 -05:00
if ( false ) { }
2018-12-13 23:41:57 -05:00
var shapeAssertionError ;
try {
assertReducerShape ( finalReducers ) ;
} catch ( e ) {
shapeAssertionError = e ;
}
return function combination ( state , action ) {
if ( state === void 0 ) {
state = { } ;
}
if ( shapeAssertionError ) {
throw shapeAssertionError ;
}
2018-12-17 22:14:52 -05:00
if ( false ) { var warningMessage ; }
2018-12-13 23:41:57 -05:00
var hasChanged = false ;
var nextState = { } ;
for ( var _i = 0 ; _i < finalReducerKeys . length ; _i ++ ) {
var _key = finalReducerKeys [ _i ] ;
var reducer = finalReducers [ _key ] ;
var previousStateForKey = state [ _key ] ;
var nextStateForKey = reducer ( previousStateForKey , action ) ;
if ( typeof nextStateForKey === 'undefined' ) {
var errorMessage = getUndefinedStateErrorMessage ( _key , action ) ;
throw new Error ( errorMessage ) ;
}
nextState [ _key ] = nextStateForKey ;
hasChanged = hasChanged || nextStateForKey !== previousStateForKey ;
}
return hasChanged ? nextState : state ;
} ;
}
function bindActionCreator ( actionCreator , dispatch ) {
return function ( ) {
return dispatch ( actionCreator . apply ( this , arguments ) ) ;
} ;
}
/ * *
* Turns an object whose values are action creators , into an object with the
* same keys , but with every function wrapped into a ` dispatch ` call so they
* may be invoked directly . This is just a convenience method , as you can call
* ` store.dispatch(MyActionCreators.doSomething()) ` yourself just fine .
*
* For convenience , you can also pass a single function as the first argument ,
* and get a function in return .
*
* @ param { Function | Object } actionCreators An object whose values are action
* creator functions . One handy way to obtain it is to use ES6 ` import * as `
* syntax . You may also pass a single function .
*
* @ param { Function } dispatch The ` dispatch ` function available on your Redux
* store .
*
* @ returns { Function | Object } The object mimicking the original object , but with
* every action creator wrapped into the ` dispatch ` call . If you passed a
* function as ` actionCreators ` , the return value will also be a single
* function .
* /
function bindActionCreators ( actionCreators , dispatch ) {
if ( typeof actionCreators === 'function' ) {
return bindActionCreator ( actionCreators , dispatch ) ;
}
if ( typeof actionCreators !== 'object' || actionCreators === null ) {
throw new Error ( "bindActionCreators expected an object or a function, instead received " + ( actionCreators === null ? 'null' : typeof actionCreators ) + ". " + "Did you write \"import ActionCreators from\" instead of \"import * as ActionCreators from\"?" ) ;
}
var keys = Object . keys ( actionCreators ) ;
var boundActionCreators = { } ;
for ( var i = 0 ; i < keys . length ; i ++ ) {
var key = keys [ i ] ;
var actionCreator = actionCreators [ key ] ;
if ( typeof actionCreator === 'function' ) {
boundActionCreators [ key ] = bindActionCreator ( actionCreator , dispatch ) ;
}
}
return boundActionCreators ;
}
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 _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 ) {
_defineProperty ( target , key , source [ key ] ) ;
} ) ;
}
return target ;
}
/ * *
* Composes single - argument functions from right to left . The rightmost
* function can take multiple arguments as it provides the signature for
* the resulting composite function .
*
* @ param { ... Function } funcs The functions to compose .
* @ returns { Function } A function obtained by composing the argument functions
* from right to left . For example , compose ( f , g , h ) is identical to doing
* ( ... args ) => f ( g ( h ( ... args ) ) ) .
* /
function compose ( ) {
for ( var _len = arguments . length , funcs = new Array ( _len ) , _key = 0 ; _key < _len ; _key ++ ) {
funcs [ _key ] = arguments [ _key ] ;
}
if ( funcs . length === 0 ) {
return function ( arg ) {
return arg ;
} ;
}
if ( funcs . length === 1 ) {
return funcs [ 0 ] ;
}
return funcs . reduce ( function ( a , b ) {
return function ( ) {
return a ( b . apply ( void 0 , arguments ) ) ;
} ;
} ) ;
}
/ * *
* Creates a store enhancer that applies middleware to the dispatch method
* of the Redux store . This is handy for a variety of tasks , such as expressing
* asynchronous actions in a concise manner , or logging every action payload .
*
* See ` redux-thunk ` package as an example of the Redux middleware .
*
* Because middleware is potentially asynchronous , this should be the first
* store enhancer in the composition chain .
*
* Note that each middleware will be given the ` dispatch ` and ` getState ` functions
* as named arguments .
*
* @ param { ... Function } middlewares The middleware chain to be applied .
* @ returns { Function } A store enhancer applying the middleware .
* /
function applyMiddleware ( ) {
for ( var _len = arguments . length , middlewares = new Array ( _len ) , _key = 0 ; _key < _len ; _key ++ ) {
middlewares [ _key ] = arguments [ _key ] ;
}
return function ( createStore ) {
return function ( ) {
var store = createStore . apply ( void 0 , arguments ) ;
var _dispatch = function dispatch ( ) {
throw new Error ( "Dispatching while constructing your middleware is not allowed. " + "Other middleware would not be applied to this dispatch." ) ;
} ;
var middlewareAPI = {
getState : store . getState ,
dispatch : function dispatch ( ) {
return _dispatch . apply ( void 0 , arguments ) ;
}
} ;
var chain = middlewares . map ( function ( middleware ) {
return middleware ( middlewareAPI ) ;
} ) ;
_dispatch = compose . apply ( void 0 , chain ) ( store . dispatch ) ;
return _objectSpread ( { } , store , {
dispatch : _dispatch
} ) ;
} ;
} ;
}
/ *
* This is a dummy function to check if the function name has been altered by minification .
* If the function has been minified and NODE _ENV !== 'production' , warn the user .
* /
function isCrushed ( ) { }
2018-12-17 22:14:52 -05:00
if ( false ) { }
2018-12-13 23:41:57 -05:00
/***/ } ) ,
2019-03-21 08:48:00 -04:00
/***/ 76 :
2018-12-17 22:14:52 -05:00
/***/ ( function ( module , exports , _ _webpack _require _ _ ) {
2018-12-13 23:41:57 -05:00
"use strict" ;
2018-12-17 22:14:52 -05:00
function _typeof ( obj ) {
if ( typeof Symbol === "function" && typeof Symbol . iterator === "symbol" ) {
_typeof = function ( obj ) {
return typeof obj ;
} ;
} else {
_typeof = function ( obj ) {
return obj && typeof Symbol === "function" && obj . constructor === Symbol && obj !== Symbol . prototype ? "symbol" : typeof obj ;
} ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return _typeof ( obj ) ;
2018-12-13 23:41:57 -05:00
}
2018-12-17 22:14:52 -05:00
function _classCallCheck ( instance , Constructor ) {
if ( ! ( instance instanceof Constructor ) ) {
throw new TypeError ( "Cannot call a class as a function" ) ;
}
2018-12-13 23:41:57 -05:00
}
2018-12-17 22:14:52 -05:00
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 ) ;
}
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
function _createClass ( Constructor , protoProps , staticProps ) {
if ( protoProps ) _defineProperties ( Constructor . prototype , protoProps ) ;
if ( staticProps ) _defineProperties ( Constructor , staticProps ) ;
return Constructor ;
2018-12-13 23:41:57 -05:00
}
/ * *
2018-12-17 22:14:52 -05:00
* Given an instance of EquivalentKeyMap , returns its internal value pair tuple
* for a key , if one exists . The tuple members consist of the last reference
* value for the key ( used in efficient subsequent lookups ) and the value
* assigned for the key at the leaf node .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ param { EquivalentKeyMap } instance EquivalentKeyMap instance .
* @ param { * } key The key for which to return value pair .
2018-12-13 23:41:57 -05:00
*
2018-12-17 22:14:52 -05:00
* @ return { ? Array } Value pair , if exists .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
function getValuePair ( instance , key ) {
var _map = instance . _map ,
_arrayTreeMap = instance . _arrayTreeMap ,
_objectTreeMap = instance . _objectTreeMap ; // Map keeps a reference to the last object-like key used to set the
// value, which can be used to shortcut immediately to the value.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( _map . has ( key ) ) {
return _map . get ( key ) ;
} // Sort keys to ensure stable retrieval from tree.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var properties = Object . keys ( key ) . sort ( ) ; // Tree by type to avoid conflicts on numeric object keys, empty value.
var map = Array . isArray ( key ) ? _arrayTreeMap : _objectTreeMap ;
for ( var i = 0 ; i < properties . length ; i ++ ) {
var property = properties [ i ] ;
map = map . get ( property ) ;
if ( map === undefined ) {
return ;
}
var propertyValue = key [ property ] ;
map = map . get ( propertyValue ) ;
if ( map === undefined ) {
return ;
}
}
var valuePair = map . get ( '_ekm_value' ) ;
if ( ! valuePair ) {
return ;
} // If reached, it implies that an object-like key was set with another
// reference, so delete the reference and replace with the current.
_map . delete ( valuePair [ 0 ] ) ;
valuePair [ 0 ] = key ;
map . set ( '_ekm_value' , valuePair ) ;
_map . set ( key , valuePair ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return valuePair ;
}
2018-12-13 23:41:57 -05:00
/ * *
2018-12-17 22:14:52 -05:00
* Variant of a Map object which enables lookup by equivalent ( deeply equal )
* object and array keys .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
var EquivalentKeyMap =
/*#__PURE__*/
function ( ) {
/ * *
* Constructs a new instance of EquivalentKeyMap .
*
* @ param { Iterable . < * > } iterable Initial pair of key , value for map .
* /
function EquivalentKeyMap ( iterable ) {
_classCallCheck ( this , EquivalentKeyMap ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
this . clear ( ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( iterable instanceof EquivalentKeyMap ) {
// Map#forEach is only means of iterating with support for IE11.
var iterablePairs = [ ] ;
iterable . forEach ( function ( value , key ) {
iterablePairs . push ( [ key , value ] ) ;
} ) ;
iterable = iterablePairs ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( iterable != null ) {
for ( var i = 0 ; i < iterable . length ; i ++ ) {
this . set ( iterable [ i ] [ 0 ] , iterable [ i ] [ 1 ] ) ;
}
}
}
/ * *
* Accessor property returning the number of elements .
*
* @ return { number } Number of elements .
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
_createClass ( EquivalentKeyMap , [ {
key : "set" ,
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/ * *
* Add or update an element with a specified key and value .
*
* @ param { * } key The key of the element to add .
* @ param { * } value The value of the element to add .
*
* @ return { EquivalentKeyMap } Map instance .
* /
value : function set ( key , value ) {
// Shortcut non-object-like to set on internal Map.
if ( key === null || _typeof ( key ) !== 'object' ) {
this . _map . set ( key , value ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return this ;
} // Sort keys to ensure stable assignment into tree.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var properties = Object . keys ( key ) . sort ( ) ;
var valuePair = [ key , value ] ; // Tree by type to avoid conflicts on numeric object keys, empty value.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var map = Array . isArray ( key ) ? this . _arrayTreeMap : this . _objectTreeMap ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
for ( var i = 0 ; i < properties . length ; i ++ ) {
var property = properties [ i ] ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( ! map . has ( property ) ) {
map . set ( property , new EquivalentKeyMap ( ) ) ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
map = map . get ( property ) ;
var propertyValue = key [ property ] ;
if ( ! map . has ( propertyValue ) ) {
map . set ( propertyValue , new EquivalentKeyMap ( ) ) ;
}
map = map . get ( propertyValue ) ;
} // If an _ekm_value exists, there was already an equivalent key. Before
// overriding, ensure that the old key reference is removed from map to
// avoid memory leak of accumulating equivalent keys. This is, in a
// sense, a poor man's WeakMap, while still enabling iterability.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var previousValuePair = map . get ( '_ekm_value' ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( previousValuePair ) {
this . _map . delete ( previousValuePair [ 0 ] ) ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
map . set ( '_ekm_value' , valuePair ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
this . _map . set ( key , valuePair ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return this ;
}
/ * *
* Returns a specified element .
*
* @ param { * } key The key of the element to return .
*
* @ return { ? * } The element associated with the specified key or undefined
* if the key can ' t be found .
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
} , {
key : "get" ,
value : function get ( key ) {
// Shortcut non-object-like to get from internal Map.
if ( key === null || _typeof ( key ) !== 'object' ) {
return this . _map . get ( key ) ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var valuePair = getValuePair ( this , key ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( valuePair ) {
return valuePair [ 1 ] ;
}
}
/ * *
* Returns a boolean indicating whether an element with the specified key
* exists or not .
*
* @ param { * } key The key of the element to test for presence .
*
* @ return { boolean } Whether an element with the specified key exists .
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
} , {
key : "has" ,
value : function has ( key ) {
if ( key === null || _typeof ( key ) !== 'object' ) {
return this . _map . has ( key ) ;
} // Test on the _presence_ of the pair, not its value, as even undefined
// can be a valid member value for a key.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return getValuePair ( this , key ) !== undefined ;
}
/ * *
* Removes the specified element .
*
* @ param { * } key The key of the element to remove .
*
* @ return { boolean } Returns true if an element existed and has been
* removed , or false if the element does not exist .
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
} , {
key : "delete" ,
value : function _delete ( key ) {
if ( ! this . has ( key ) ) {
return false ;
} // This naive implementation will leave orphaned child trees. A better
// implementation should traverse and remove orphans.
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
this . set ( key , undefined ) ;
return true ;
}
/ * *
* Executes a provided function once per each key / value pair , in insertion
* order .
*
* @ param { Function } callback Function to execute for each element .
* @ param { * } thisArg Value to use as ` this ` when executing
* ` callback ` .
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
} , {
key : "forEach" ,
value : function forEach ( callback ) {
var _this = this ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var thisArg = arguments . length > 1 && arguments [ 1 ] !== undefined ? arguments [ 1 ] : this ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
this . _map . forEach ( function ( value , key ) {
// Unwrap value from object-like value pair.
if ( key !== null && _typeof ( key ) === 'object' ) {
value = value [ 1 ] ;
}
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
callback . call ( thisArg , value , key , _this ) ;
} ) ;
}
/ * *
* Removes all elements .
* /
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
} , {
key : "clear" ,
value : function clear ( ) {
this . _map = new Map ( ) ;
this . _arrayTreeMap = new Map ( ) ;
this . _objectTreeMap = new Map ( ) ;
}
} , {
key : "size" ,
get : function get ( ) {
return this . _map . size ;
}
} ] ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return EquivalentKeyMap ;
} ( ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
module . exports = EquivalentKeyMap ;
2018-12-13 23:41:57 -05:00
/***/ } ) ,
2019-03-21 08:48:00 -04:00
/***/ 77 :
2018-12-17 22:14:52 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
"use strict" ;
2019-03-21 08:48:00 -04:00
/* WEBPACK VAR INJECTION */ ( function ( global , module ) { /* harmony import */ var _ponyfill _js _ _WEBPACK _IMPORTED _MODULE _0 _ _ = _ _webpack _require _ _ ( 99 ) ;
2018-12-17 22:14:52 -05:00
/* global window */
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var root ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
if ( typeof self !== 'undefined' ) {
root = self ;
} else if ( typeof window !== 'undefined' ) {
root = window ;
} else if ( typeof global !== 'undefined' ) {
root = global ;
} else if ( true ) {
root = module ;
} else { }
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
var result = Object ( _ponyfill _js _ _WEBPACK _IMPORTED _MODULE _0 _ _ [ /* default */ "a" ] ) ( root ) ;
/* harmony default export */ _ _webpack _exports _ _ [ "a" ] = ( result ) ;
2019-03-21 08:48:00 -04:00
/* WEBPACK VAR INJECTION */ } . call ( this , _ _webpack _require _ _ ( 59 ) , _ _webpack _require _ _ ( 132 ) ( module ) ) )
2018-12-13 23:41:57 -05:00
/***/ } ) ,
2019-03-21 08:48:00 -04:00
/***/ 99 :
2018-12-17 22:14:52 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return symbolObservablePonyfill ; } ) ;
function symbolObservablePonyfill ( root ) {
var result ;
var Symbol = root . Symbol ;
if ( typeof Symbol === 'function' ) {
if ( Symbol . observable ) {
result = Symbol . observable ;
} else {
result = Symbol ( 'observable' ) ;
Symbol . observable = result ;
}
} else {
result = '@@observable' ;
}
return result ;
} ;
2018-12-13 23:41:57 -05:00
/***/ } )
2018-12-17 22:14:52 -05:00
/******/ } ) ;