You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
818 lines
24 KiB
818 lines
24 KiB
this["wp"] = this["wp"] || {}; this["wp"]["apiFetch"] = |
|
/******/ (function(modules) { // webpackBootstrap |
|
/******/ // The module cache |
|
/******/ var installedModules = {}; |
|
/******/ |
|
/******/ // The require function |
|
/******/ function __webpack_require__(moduleId) { |
|
/******/ |
|
/******/ // Check if module is in cache |
|
/******/ if(installedModules[moduleId]) { |
|
/******/ return installedModules[moduleId].exports; |
|
/******/ } |
|
/******/ // Create a new module (and put it into the cache) |
|
/******/ var module = installedModules[moduleId] = { |
|
/******/ i: moduleId, |
|
/******/ l: false, |
|
/******/ exports: {} |
|
/******/ }; |
|
/******/ |
|
/******/ // Execute the module function |
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); |
|
/******/ |
|
/******/ // Flag the module as loaded |
|
/******/ module.l = true; |
|
/******/ |
|
/******/ // Return the exports of the module |
|
/******/ return module.exports; |
|
/******/ } |
|
/******/ |
|
/******/ |
|
/******/ // expose the modules object (__webpack_modules__) |
|
/******/ __webpack_require__.m = modules; |
|
/******/ |
|
/******/ // expose the module cache |
|
/******/ __webpack_require__.c = installedModules; |
|
/******/ |
|
/******/ // define getter function for harmony exports |
|
/******/ __webpack_require__.d = function(exports, name, getter) { |
|
/******/ if(!__webpack_require__.o(exports, name)) { |
|
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); |
|
/******/ } |
|
/******/ }; |
|
/******/ |
|
/******/ // define __esModule on exports |
|
/******/ __webpack_require__.r = function(exports) { |
|
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { |
|
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); |
|
/******/ } |
|
/******/ Object.defineProperty(exports, '__esModule', { value: true }); |
|
/******/ }; |
|
/******/ |
|
/******/ // create a fake namespace object |
|
/******/ // mode & 1: value is a module id, require it |
|
/******/ // mode & 2: merge all properties of value into the ns |
|
/******/ // mode & 4: return value when already ns object |
|
/******/ // mode & 8|1: behave like require |
|
/******/ __webpack_require__.t = function(value, mode) { |
|
/******/ if(mode & 1) value = __webpack_require__(value); |
|
/******/ if(mode & 8) return value; |
|
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; |
|
/******/ var ns = Object.create(null); |
|
/******/ __webpack_require__.r(ns); |
|
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); |
|
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); |
|
/******/ return ns; |
|
/******/ }; |
|
/******/ |
|
/******/ // getDefaultExport function for compatibility with non-harmony modules |
|
/******/ __webpack_require__.n = function(module) { |
|
/******/ var getter = module && module.__esModule ? |
|
/******/ function getDefault() { return module['default']; } : |
|
/******/ function getModuleExports() { return module; }; |
|
/******/ __webpack_require__.d(getter, 'a', getter); |
|
/******/ return getter; |
|
/******/ }; |
|
/******/ |
|
/******/ // Object.prototype.hasOwnProperty.call |
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; |
|
/******/ |
|
/******/ // __webpack_public_path__ |
|
/******/ __webpack_require__.p = ""; |
|
/******/ |
|
/******/ |
|
/******/ // Load entry module and return exports |
|
/******/ return __webpack_require__(__webpack_require__.s = 315); |
|
/******/ }) |
|
/************************************************************************/ |
|
/******/ ({ |
|
|
|
/***/ 1: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["i18n"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 15: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; }); |
|
function _defineProperty(obj, key, value) { |
|
if (key in obj) { |
|
Object.defineProperty(obj, key, { |
|
value: value, |
|
enumerable: true, |
|
configurable: true, |
|
writable: true |
|
}); |
|
} else { |
|
obj[key] = value; |
|
} |
|
|
|
return obj; |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 21: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js |
|
function _objectWithoutPropertiesLoose(source, excluded) { |
|
if (source == null) return {}; |
|
var target = {}; |
|
var sourceKeys = Object.keys(source); |
|
var key, i; |
|
|
|
for (i = 0; i < sourceKeys.length; i++) { |
|
key = sourceKeys[i]; |
|
if (excluded.indexOf(key) >= 0) continue; |
|
target[key] = source[key]; |
|
} |
|
|
|
return target; |
|
} |
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutProperties; }); |
|
|
|
function _objectWithoutProperties(source, excluded) { |
|
if (source == null) return {}; |
|
var target = _objectWithoutPropertiesLoose(source, excluded); |
|
var key, i; |
|
|
|
if (Object.getOwnPropertySymbols) { |
|
var sourceSymbolKeys = Object.getOwnPropertySymbols(source); |
|
|
|
for (i = 0; i < sourceSymbolKeys.length; i++) { |
|
key = sourceSymbolKeys[i]; |
|
if (excluded.indexOf(key) >= 0) continue; |
|
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; |
|
target[key] = source[key]; |
|
} |
|
} |
|
|
|
return target; |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 23: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["hooks"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 24: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["url"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 315: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
__webpack_require__.r(__webpack_exports__); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread.js |
|
var objectSpread = __webpack_require__(8); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js + 1 modules |
|
var objectWithoutProperties = __webpack_require__(21); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","i18n"]} |
|
var external_this_wp_i18n_ = __webpack_require__(1); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","hooks"]} |
|
var external_this_wp_hooks_ = __webpack_require__(23); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/nonce.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
var nonce_createNonceMiddleware = function createNonceMiddleware(nonce) { |
|
var usedNonce = nonce; |
|
/** |
|
* This is not ideal but it's fine for now. |
|
* |
|
* Configure heartbeat to refresh the wp-api nonce, keeping the editor |
|
* authorization intact. |
|
*/ |
|
|
|
Object(external_this_wp_hooks_["addAction"])('heartbeat.tick', 'core/api-fetch/create-nonce-middleware', function (response) { |
|
if (response['rest-nonce']) { |
|
usedNonce = response['rest-nonce']; |
|
} |
|
}); |
|
return function (options, next) { |
|
var headers = options.headers || {}; // If an 'X-WP-Nonce' header (or any case-insensitive variation |
|
// thereof) was specified, no need to add a nonce header. |
|
|
|
var addNonceHeader = true; |
|
|
|
for (var headerName in headers) { |
|
if (headers.hasOwnProperty(headerName)) { |
|
if (headerName.toLowerCase() === 'x-wp-nonce') { |
|
addNonceHeader = false; |
|
break; |
|
} |
|
} |
|
} |
|
|
|
if (addNonceHeader) { |
|
// Do not mutate the original headers object, if any. |
|
headers = Object(objectSpread["a" /* default */])({}, headers, { |
|
'X-WP-Nonce': usedNonce |
|
}); |
|
} |
|
|
|
return next(Object(objectSpread["a" /* default */])({}, options, { |
|
headers: headers |
|
})); |
|
}; |
|
}; |
|
|
|
/* harmony default export */ var middlewares_nonce = (nonce_createNonceMiddleware); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/namespace-endpoint.js |
|
|
|
|
|
var namespace_endpoint_namespaceAndEndpointMiddleware = function namespaceAndEndpointMiddleware(options, next) { |
|
var path = options.path; |
|
var namespaceTrimmed, endpointTrimmed; |
|
|
|
if (typeof options.namespace === 'string' && typeof options.endpoint === 'string') { |
|
namespaceTrimmed = options.namespace.replace(/^\/|\/$/g, ''); |
|
endpointTrimmed = options.endpoint.replace(/^\//, ''); |
|
|
|
if (endpointTrimmed) { |
|
path = namespaceTrimmed + '/' + endpointTrimmed; |
|
} else { |
|
path = namespaceTrimmed; |
|
} |
|
} |
|
|
|
delete options.namespace; |
|
delete options.endpoint; |
|
return next(Object(objectSpread["a" /* default */])({}, options, { |
|
path: path |
|
})); |
|
}; |
|
|
|
/* harmony default export */ var namespace_endpoint = (namespace_endpoint_namespaceAndEndpointMiddleware); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/root-url.js |
|
|
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
var root_url_createRootURLMiddleware = function createRootURLMiddleware(rootURL) { |
|
return function (options, next) { |
|
return namespace_endpoint(options, function (optionsWithPath) { |
|
var url = optionsWithPath.url; |
|
var path = optionsWithPath.path; |
|
var apiRoot; |
|
|
|
if (typeof path === 'string') { |
|
apiRoot = rootURL; |
|
|
|
if (-1 !== rootURL.indexOf('?')) { |
|
path = path.replace('?', '&'); |
|
} |
|
|
|
path = path.replace(/^\//, ''); // API root may already include query parameter prefix if site is |
|
// configured to use plain permalinks. |
|
|
|
if ('string' === typeof apiRoot && -1 !== apiRoot.indexOf('?')) { |
|
path = path.replace('?', '&'); |
|
} |
|
|
|
url = apiRoot + path; |
|
} |
|
|
|
return next(Object(objectSpread["a" /* default */])({}, optionsWithPath, { |
|
url: url |
|
})); |
|
}); |
|
}; |
|
}; |
|
|
|
/* harmony default export */ var root_url = (root_url_createRootURLMiddleware); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/preloading.js |
|
var createPreloadingMiddleware = function createPreloadingMiddleware(preloadedData) { |
|
return function (options, next) { |
|
function getStablePath(path) { |
|
var splitted = path.split('?'); |
|
var query = splitted[1]; |
|
var base = splitted[0]; |
|
|
|
if (!query) { |
|
return base; |
|
} // 'b=1&c=2&a=5' |
|
|
|
|
|
return base + '?' + query // [ 'b=1', 'c=2', 'a=5' ] |
|
.split('&') // [ [ 'b, '1' ], [ 'c', '2' ], [ 'a', '5' ] ] |
|
.map(function (entry) { |
|
return entry.split('='); |
|
}) // [ [ 'a', '5' ], [ 'b, '1' ], [ 'c', '2' ] ] |
|
.sort(function (a, b) { |
|
return a[0].localeCompare(b[0]); |
|
}) // [ 'a=5', 'b=1', 'c=2' ] |
|
.map(function (pair) { |
|
return pair.join('='); |
|
}) // 'a=5&b=1&c=2' |
|
.join('&'); |
|
} |
|
|
|
var _options$parse = options.parse, |
|
parse = _options$parse === void 0 ? true : _options$parse; |
|
|
|
if (typeof options.path === 'string') { |
|
var method = options.method || 'GET'; |
|
var path = getStablePath(options.path); |
|
|
|
if (parse && 'GET' === method && preloadedData[path]) { |
|
return Promise.resolve(preloadedData[path].body); |
|
} else if ('OPTIONS' === method && preloadedData[method][path]) { |
|
return Promise.resolve(preloadedData[method][path]); |
|
} |
|
} |
|
|
|
return next(options); |
|
}; |
|
}; |
|
|
|
/* harmony default export */ var preloading = (createPreloadingMiddleware); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js |
|
var asyncToGenerator = __webpack_require__(38); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","url"]} |
|
var external_this_wp_url_ = __webpack_require__(24); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/fetch-all-middleware.js |
|
|
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
// Apply query arguments to both URL and Path, whichever is present. |
|
|
|
var fetch_all_middleware_modifyQuery = function modifyQuery(_ref, queryArgs) { |
|
var path = _ref.path, |
|
url = _ref.url, |
|
options = Object(objectWithoutProperties["a" /* default */])(_ref, ["path", "url"]); |
|
|
|
return Object(objectSpread["a" /* default */])({}, options, { |
|
url: url && Object(external_this_wp_url_["addQueryArgs"])(url, queryArgs), |
|
path: path && Object(external_this_wp_url_["addQueryArgs"])(path, queryArgs) |
|
}); |
|
}; // Duplicates parsing functionality from apiFetch. |
|
|
|
|
|
var fetch_all_middleware_parseResponse = function parseResponse(response) { |
|
return response.json ? response.json() : Promise.reject(response); |
|
}; |
|
|
|
var parseLinkHeader = function parseLinkHeader(linkHeader) { |
|
if (!linkHeader) { |
|
return {}; |
|
} |
|
|
|
var match = linkHeader.match(/<([^>]+)>; rel="next"/); |
|
return match ? { |
|
next: match[1] |
|
} : {}; |
|
}; |
|
|
|
var getNextPageUrl = function getNextPageUrl(response) { |
|
var _parseLinkHeader = parseLinkHeader(response.headers.get('link')), |
|
next = _parseLinkHeader.next; |
|
|
|
return next; |
|
}; |
|
|
|
var requestContainsUnboundedQuery = function requestContainsUnboundedQuery(options) { |
|
var pathIsUnbounded = options.path && options.path.indexOf('per_page=-1') !== -1; |
|
var urlIsUnbounded = options.url && options.url.indexOf('per_page=-1') !== -1; |
|
return pathIsUnbounded || urlIsUnbounded; |
|
}; // The REST API enforces an upper limit on the per_page option. To handle large |
|
// collections, apiFetch consumers can pass `per_page=-1`; this middleware will |
|
// then recursively assemble a full response array from all available pages. |
|
|
|
|
|
var fetchAllMiddleware = |
|
/*#__PURE__*/ |
|
function () { |
|
var _ref2 = Object(asyncToGenerator["a" /* default */])( |
|
/*#__PURE__*/ |
|
regeneratorRuntime.mark(function _callee(options, next) { |
|
var response, results, nextPage, mergedResults, nextResponse, nextResults; |
|
return regeneratorRuntime.wrap(function _callee$(_context) { |
|
while (1) { |
|
switch (_context.prev = _context.next) { |
|
case 0: |
|
if (!(options.parse === false)) { |
|
_context.next = 2; |
|
break; |
|
} |
|
|
|
return _context.abrupt("return", next(options)); |
|
|
|
case 2: |
|
if (requestContainsUnboundedQuery(options)) { |
|
_context.next = 4; |
|
break; |
|
} |
|
|
|
return _context.abrupt("return", next(options)); |
|
|
|
case 4: |
|
_context.next = 6; |
|
return next(Object(objectSpread["a" /* default */])({}, fetch_all_middleware_modifyQuery(options, { |
|
per_page: 100 |
|
}), { |
|
// Ensure headers are returned for page 1. |
|
parse: false |
|
})); |
|
|
|
case 6: |
|
response = _context.sent; |
|
_context.next = 9; |
|
return fetch_all_middleware_parseResponse(response); |
|
|
|
case 9: |
|
results = _context.sent; |
|
|
|
if (Array.isArray(results)) { |
|
_context.next = 12; |
|
break; |
|
} |
|
|
|
return _context.abrupt("return", results); |
|
|
|
case 12: |
|
nextPage = getNextPageUrl(response); |
|
|
|
if (nextPage) { |
|
_context.next = 15; |
|
break; |
|
} |
|
|
|
return _context.abrupt("return", results); |
|
|
|
case 15: |
|
// Iteratively fetch all remaining pages until no "next" header is found. |
|
mergedResults = [].concat(results); |
|
|
|
case 16: |
|
if (!nextPage) { |
|
_context.next = 27; |
|
break; |
|
} |
|
|
|
_context.next = 19; |
|
return next(Object(objectSpread["a" /* default */])({}, options, { |
|
// Ensure the URL for the next page is used instead of any provided path. |
|
path: undefined, |
|
url: nextPage, |
|
// Ensure we still get headers so we can identify the next page. |
|
parse: false |
|
})); |
|
|
|
case 19: |
|
nextResponse = _context.sent; |
|
_context.next = 22; |
|
return fetch_all_middleware_parseResponse(nextResponse); |
|
|
|
case 22: |
|
nextResults = _context.sent; |
|
mergedResults = mergedResults.concat(nextResults); |
|
nextPage = getNextPageUrl(nextResponse); |
|
_context.next = 16; |
|
break; |
|
|
|
case 27: |
|
return _context.abrupt("return", mergedResults); |
|
|
|
case 28: |
|
case "end": |
|
return _context.stop(); |
|
} |
|
} |
|
}, _callee, this); |
|
})); |
|
|
|
return function fetchAllMiddleware(_x, _x2) { |
|
return _ref2.apply(this, arguments); |
|
}; |
|
}(); |
|
|
|
/* harmony default export */ var fetch_all_middleware = (fetchAllMiddleware); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/http-v1.js |
|
|
|
|
|
/** |
|
* Set of HTTP methods which are eligible to be overridden. |
|
* |
|
* @type {Set} |
|
*/ |
|
var OVERRIDE_METHODS = new Set(['PATCH', 'PUT', 'DELETE']); |
|
/** |
|
* Default request method. |
|
* |
|
* "A request has an associated method (a method). Unless stated otherwise it |
|
* is `GET`." |
|
* |
|
* @see https://fetch.spec.whatwg.org/#requests |
|
* |
|
* @type {string} |
|
*/ |
|
|
|
var DEFAULT_METHOD = 'GET'; |
|
/** |
|
* API Fetch middleware which overrides the request method for HTTP v1 |
|
* compatibility leveraging the REST API X-HTTP-Method-Override header. |
|
* |
|
* @param {Object} options Fetch options. |
|
* @param {Function} next [description] |
|
* |
|
* @return {*} The evaluated result of the remaining middleware chain. |
|
*/ |
|
|
|
function httpV1Middleware(options, next) { |
|
var _options = options, |
|
_options$method = _options.method, |
|
method = _options$method === void 0 ? DEFAULT_METHOD : _options$method; |
|
|
|
if (OVERRIDE_METHODS.has(method.toUpperCase())) { |
|
options = Object(objectSpread["a" /* default */])({}, options, { |
|
headers: Object(objectSpread["a" /* default */])({}, options.headers, { |
|
'X-HTTP-Method-Override': method, |
|
'Content-Type': 'application/json' |
|
}), |
|
method: 'POST' |
|
}); |
|
} |
|
|
|
return next(options, next); |
|
} |
|
|
|
/* harmony default export */ var http_v1 = (httpV1Middleware); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/user-locale.js |
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
function userLocaleMiddleware(options, next) { |
|
if (typeof options.url === 'string' && !Object(external_this_wp_url_["hasQueryArg"])(options.url, '_locale')) { |
|
options.url = Object(external_this_wp_url_["addQueryArgs"])(options.url, { |
|
_locale: 'user' |
|
}); |
|
} |
|
|
|
if (typeof options.path === 'string' && !Object(external_this_wp_url_["hasQueryArg"])(options.path, '_locale')) { |
|
options.path = Object(external_this_wp_url_["addQueryArgs"])(options.path, { |
|
_locale: 'user' |
|
}); |
|
} |
|
|
|
return next(options, next); |
|
} |
|
|
|
/* harmony default export */ var user_locale = (userLocaleMiddleware); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/index.js |
|
|
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
* Default set of header values which should be sent with every request unless |
|
* explicitly provided through apiFetch options. |
|
* |
|
* @type {Object} |
|
*/ |
|
|
|
var DEFAULT_HEADERS = { |
|
// The backend uses the Accept header as a condition for considering an |
|
// incoming request as a REST request. |
|
// |
|
// See: https://core.trac.wordpress.org/ticket/44534 |
|
Accept: 'application/json, */*;q=0.1' |
|
}; |
|
/** |
|
* Default set of fetch option values which should be sent with every request |
|
* unless explicitly provided through apiFetch options. |
|
* |
|
* @type {Object} |
|
*/ |
|
|
|
var DEFAULT_OPTIONS = { |
|
credentials: 'include' |
|
}; |
|
var middlewares = []; |
|
|
|
function registerMiddleware(middleware) { |
|
middlewares.push(middleware); |
|
} |
|
|
|
function apiFetch(options) { |
|
var raw = function raw(nextOptions) { |
|
var url = nextOptions.url, |
|
path = nextOptions.path, |
|
data = nextOptions.data, |
|
_nextOptions$parse = nextOptions.parse, |
|
parse = _nextOptions$parse === void 0 ? true : _nextOptions$parse, |
|
remainingOptions = Object(objectWithoutProperties["a" /* default */])(nextOptions, ["url", "path", "data", "parse"]); |
|
|
|
var body = nextOptions.body, |
|
headers = nextOptions.headers; // Merge explicitly-provided headers with default values. |
|
|
|
headers = Object(objectSpread["a" /* default */])({}, DEFAULT_HEADERS, headers); // The `data` property is a shorthand for sending a JSON body. |
|
|
|
if (data) { |
|
body = JSON.stringify(data); |
|
headers['Content-Type'] = 'application/json'; |
|
} |
|
|
|
var responsePromise = window.fetch(url || path, Object(objectSpread["a" /* default */])({}, DEFAULT_OPTIONS, remainingOptions, { |
|
body: body, |
|
headers: headers |
|
})); |
|
|
|
var checkStatus = function checkStatus(response) { |
|
if (response.status >= 200 && response.status < 300) { |
|
return response; |
|
} |
|
|
|
throw response; |
|
}; |
|
|
|
var parseResponse = function parseResponse(response) { |
|
if (parse) { |
|
if (response.status === 204) { |
|
return null; |
|
} |
|
|
|
return response.json ? response.json() : Promise.reject(response); |
|
} |
|
|
|
return response; |
|
}; |
|
|
|
return responsePromise.then(checkStatus).then(parseResponse).catch(function (response) { |
|
if (!parse) { |
|
throw response; |
|
} |
|
|
|
var invalidJsonError = { |
|
code: 'invalid_json', |
|
message: Object(external_this_wp_i18n_["__"])('The response is not a valid JSON response.') |
|
}; |
|
|
|
if (!response || !response.json) { |
|
throw invalidJsonError; |
|
} |
|
|
|
return response.json().catch(function () { |
|
throw invalidJsonError; |
|
}).then(function (error) { |
|
var unknownError = { |
|
code: 'unknown_error', |
|
message: Object(external_this_wp_i18n_["__"])('An unknown error occurred.') |
|
}; |
|
throw error || unknownError; |
|
}); |
|
}); |
|
}; |
|
|
|
var steps = [raw, fetch_all_middleware, http_v1, namespace_endpoint, user_locale].concat(middlewares).reverse(); |
|
|
|
var runMiddleware = function runMiddleware(index) { |
|
return function (nextOptions) { |
|
var nextMiddleware = steps[index]; |
|
var next = runMiddleware(index + 1); |
|
return nextMiddleware(nextOptions, next); |
|
}; |
|
}; |
|
|
|
return runMiddleware(0)(options); |
|
} |
|
|
|
apiFetch.use = registerMiddleware; |
|
apiFetch.createNonceMiddleware = middlewares_nonce; |
|
apiFetch.createPreloadingMiddleware = preloading; |
|
apiFetch.createRootURLMiddleware = root_url; |
|
apiFetch.fetchAllMiddleware = fetch_all_middleware; |
|
/* harmony default export */ var build_module = __webpack_exports__["default"] = (apiFetch); |
|
|
|
|
|
/***/ }), |
|
|
|
/***/ 38: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _asyncToGenerator; }); |
|
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { |
|
try { |
|
var info = gen[key](arg); |
|
var value = info.value; |
|
} catch (error) { |
|
reject(error); |
|
return; |
|
} |
|
|
|
if (info.done) { |
|
resolve(value); |
|
} else { |
|
Promise.resolve(value).then(_next, _throw); |
|
} |
|
} |
|
|
|
function _asyncToGenerator(fn) { |
|
return function () { |
|
var self = this, |
|
args = arguments; |
|
return new Promise(function (resolve, reject) { |
|
var gen = fn.apply(self, args); |
|
|
|
function _next(value) { |
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); |
|
} |
|
|
|
function _throw(err) { |
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); |
|
} |
|
|
|
_next(undefined); |
|
}); |
|
}; |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 8: |
|
/***/ (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; |
|
} |
|
|
|
/***/ }) |
|
|
|
/******/ })["default"]; |