mirror of
https://github.com/WordPress/WordPress.git
synced 2024-07-24 12:54:50 +02:00
355c05ea71
This patch integrates DependencyExtractionWebpackPlugin which was battle-tested in Gutenberg. This will greatly simplify the process of upgrading npm packages which change after every Gutenberg release. It might even useful during the WordPress release cycle as we might need to publish more often as we discover critical bugs and regressions. Props jonsurrell, adamsilverstein, youknowriad, ocean90, netweb. Fixes #48154. Built from https://develop.svn.wordpress.org/trunk@47035 git-svn-id: http://core.svn.wordpress.org/trunk@46835 1a063a9b-81f0-0310-95a4-ce76da25c4cd
947 lines
28 KiB
JavaScript
947 lines
28 KiB
JavaScript
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 = 354);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ({
|
|
|
|
/***/ 1:
|
|
/***/ (function(module, exports) {
|
|
|
|
(function() { module.exports = this["wp"]["i18n"]; }());
|
|
|
|
/***/ }),
|
|
|
|
/***/ 10:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; });
|
|
function _defineProperty(obj, key, value) {
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, {
|
|
value: value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 20:
|
|
/***/ (function(module, exports) {
|
|
|
|
(function() { module.exports = this["regeneratorRuntime"]; }());
|
|
|
|
/***/ }),
|
|
|
|
/***/ 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;
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 26:
|
|
/***/ (function(module, exports) {
|
|
|
|
(function() { module.exports = this["wp"]["url"]; }());
|
|
|
|
/***/ }),
|
|
|
|
/***/ 354:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread.js
|
|
var objectSpread = __webpack_require__(7);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js + 1 modules
|
|
var objectWithoutProperties = __webpack_require__(21);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/nonce.js
|
|
|
|
|
|
function createNonceMiddleware(nonce) {
|
|
function middleware(options, next) {
|
|
var _options$headers = options.headers,
|
|
headers = _options$headers === void 0 ? {} : _options$headers; // If an 'X-WP-Nonce' header (or any case-insensitive variation
|
|
// thereof) was specified, no need to add a nonce header.
|
|
|
|
for (var headerName in headers) {
|
|
if (headerName.toLowerCase() === 'x-wp-nonce') {
|
|
return next(options);
|
|
}
|
|
}
|
|
|
|
return next(Object(objectSpread["a" /* default */])({}, options, {
|
|
headers: Object(objectSpread["a" /* default */])({}, headers, {
|
|
'X-WP-Nonce': middleware.nonce
|
|
})
|
|
}));
|
|
}
|
|
|
|
middleware.nonce = nonce;
|
|
return middleware;
|
|
}
|
|
|
|
/* harmony default export */ var middlewares_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] && preloadedData[method][path]) {
|
|
return Promise.resolve(preloadedData[method][path]);
|
|
}
|
|
}
|
|
|
|
return next(options);
|
|
};
|
|
};
|
|
|
|
/* harmony default export */ var preloading = (createPreloadingMiddleware);
|
|
|
|
// EXTERNAL MODULE: external {"this":"regeneratorRuntime"}
|
|
var external_this_regeneratorRuntime_ = __webpack_require__(20);
|
|
var external_this_regeneratorRuntime_default = /*#__PURE__*/__webpack_require__.n(external_this_regeneratorRuntime_);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js
|
|
var asyncToGenerator = __webpack_require__(43);
|
|
|
|
// EXTERNAL MODULE: external {"this":["wp","url"]}
|
|
var external_this_wp_url_ = __webpack_require__(26);
|
|
|
|
// 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 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__*/
|
|
external_this_regeneratorRuntime_default.a.mark(function _callee(options, next) {
|
|
var response, results, nextPage, mergedResults, nextResponse, nextResults;
|
|
return external_this_regeneratorRuntime_default.a.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 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 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);
|
|
}));
|
|
|
|
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);
|
|
|
|
// EXTERNAL MODULE: external {"this":["wp","i18n"]}
|
|
var external_this_wp_i18n_ = __webpack_require__(1);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/utils/response.js
|
|
/**
|
|
* WordPress dependencies
|
|
*/
|
|
|
|
/**
|
|
* Parses the apiFetch response.
|
|
*
|
|
* @param {Response} response
|
|
* @param {boolean} shouldParseResponse
|
|
*
|
|
* @return {Promise} Parsed response
|
|
*/
|
|
|
|
var response_parseResponse = function parseResponse(response) {
|
|
var shouldParseResponse = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
|
|
|
|
if (shouldParseResponse) {
|
|
if (response.status === 204) {
|
|
return null;
|
|
}
|
|
|
|
return response.json ? response.json() : Promise.reject(response);
|
|
}
|
|
|
|
return response;
|
|
};
|
|
|
|
var response_parseJsonAndNormalizeError = function parseJsonAndNormalizeError(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;
|
|
});
|
|
};
|
|
/**
|
|
* Parses the apiFetch response properly and normalize response errors.
|
|
*
|
|
* @param {Response} response
|
|
* @param {boolean} shouldParseResponse
|
|
*
|
|
* @return {Promise} Parsed response.
|
|
*/
|
|
|
|
|
|
var parseResponseAndNormalizeError = function parseResponseAndNormalizeError(response) {
|
|
var shouldParseResponse = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
|
|
return Promise.resolve(response_parseResponse(response, shouldParseResponse)).catch(function (res) {
|
|
return parseAndThrowError(res, shouldParseResponse);
|
|
});
|
|
};
|
|
function parseAndThrowError(response) {
|
|
var shouldParseResponse = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
|
|
|
|
if (!shouldParseResponse) {
|
|
throw response;
|
|
}
|
|
|
|
return response_parseJsonAndNormalizeError(response).then(function (error) {
|
|
var unknownError = {
|
|
code: 'unknown_error',
|
|
message: Object(external_this_wp_i18n_["__"])('An unknown error occurred.')
|
|
};
|
|
throw error || unknownError;
|
|
});
|
|
}
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/media-upload.js
|
|
|
|
|
|
/**
|
|
* WordPress dependencies
|
|
*/
|
|
|
|
/**
|
|
* Internal dependencies
|
|
*/
|
|
|
|
|
|
/**
|
|
* Middleware handling media upload failures and retries.
|
|
*
|
|
* @param {Object} options Fetch options.
|
|
* @param {Function} next [description]
|
|
*
|
|
* @return {*} The evaluated result of the remaining middleware chain.
|
|
*/
|
|
|
|
function mediaUploadMiddleware(options, next) {
|
|
var isMediaUploadRequest = options.path && options.path.indexOf('/wp/v2/media') !== -1 || options.url && options.url.indexOf('/wp/v2/media') !== -1;
|
|
|
|
if (!isMediaUploadRequest) {
|
|
return next(options, next);
|
|
}
|
|
|
|
var retries = 0;
|
|
var maxRetries = 5;
|
|
|
|
var postProcess = function postProcess(attachmentId) {
|
|
retries++;
|
|
return next({
|
|
path: "/wp/v2/media/".concat(attachmentId, "/post-process"),
|
|
method: 'POST',
|
|
data: {
|
|
action: 'create-image-subsizes'
|
|
},
|
|
parse: false
|
|
}).catch(function () {
|
|
if (retries < maxRetries) {
|
|
return postProcess(attachmentId);
|
|
}
|
|
|
|
next({
|
|
path: "/wp/v2/media/".concat(attachmentId, "?force=true"),
|
|
method: 'DELETE'
|
|
});
|
|
return Promise.reject();
|
|
});
|
|
};
|
|
|
|
return next(Object(objectSpread["a" /* default */])({}, options, {
|
|
parse: false
|
|
})).catch(function (response) {
|
|
var attachmentId = response.headers.get('x-wp-upload-attachment-id');
|
|
|
|
if (response.status >= 500 && response.status < 600 && attachmentId) {
|
|
return postProcess(attachmentId).catch(function () {
|
|
if (options.parse !== false) {
|
|
return Promise.reject({
|
|
code: 'post_process',
|
|
message: Object(external_this_wp_i18n_["__"])('Media upload failed. If this is a photo or a large image, please scale it down and try again.')
|
|
});
|
|
}
|
|
|
|
return Promise.reject(response);
|
|
});
|
|
}
|
|
|
|
return parseAndThrowError(response, options.parse);
|
|
}).then(function (response) {
|
|
return parseResponseAndNormalizeError(response, options.parse);
|
|
});
|
|
}
|
|
|
|
/* harmony default export */ var media_upload = (mediaUploadMiddleware);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/index.js
|
|
|
|
|
|
|
|
/**
|
|
* 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 = [user_locale, namespace_endpoint, http_v1, fetch_all_middleware];
|
|
|
|
function registerMiddleware(middleware) {
|
|
middlewares.unshift(middleware);
|
|
}
|
|
|
|
var checkStatus = function checkStatus(response) {
|
|
if (response.status >= 200 && response.status < 300) {
|
|
return response;
|
|
}
|
|
|
|
throw response;
|
|
};
|
|
|
|
var build_module_defaultFetchHandler = function defaultFetchHandler(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
|
|
}));
|
|
return responsePromise.then(checkStatus).catch(function (response) {
|
|
return parseAndThrowError(response, parse);
|
|
}).then(function (response) {
|
|
return parseResponseAndNormalizeError(response, parse);
|
|
});
|
|
};
|
|
|
|
var fetchHandler = build_module_defaultFetchHandler;
|
|
/**
|
|
* Defines a custom fetch handler for making the requests that will override
|
|
* the default one using window.fetch
|
|
*
|
|
* @param {Function} newFetchHandler The new fetch handler
|
|
*/
|
|
|
|
function setFetchHandler(newFetchHandler) {
|
|
fetchHandler = newFetchHandler;
|
|
}
|
|
|
|
function apiFetch(options) {
|
|
var steps = [].concat(middlewares, [fetchHandler]);
|
|
|
|
var createRunStep = function createRunStep(index) {
|
|
return function (workingOptions) {
|
|
var step = steps[index];
|
|
|
|
if (index === steps.length - 1) {
|
|
return step(workingOptions);
|
|
}
|
|
|
|
var next = createRunStep(index + 1);
|
|
return step(workingOptions, next);
|
|
};
|
|
};
|
|
|
|
return new Promise(function (resolve, reject) {
|
|
createRunStep(0)(options).then(resolve).catch(function (error) {
|
|
if (error.code !== 'rest_cookie_invalid_nonce') {
|
|
return reject(error);
|
|
} // If the nonce is invalid, refresh it and try again.
|
|
|
|
|
|
window.fetch(apiFetch.nonceEndpoint).then(checkStatus).then(function (data) {
|
|
return data.text();
|
|
}).then(function (text) {
|
|
apiFetch.nonceMiddleware.nonce = text;
|
|
apiFetch(options).then(resolve).catch(reject);
|
|
}).catch(reject);
|
|
});
|
|
});
|
|
}
|
|
|
|
apiFetch.use = registerMiddleware;
|
|
apiFetch.setFetchHandler = setFetchHandler;
|
|
apiFetch.createNonceMiddleware = middlewares_nonce;
|
|
apiFetch.createPreloadingMiddleware = preloading;
|
|
apiFetch.createRootURLMiddleware = root_url;
|
|
apiFetch.fetchAllMiddleware = fetch_all_middleware;
|
|
apiFetch.mediaUploadMiddleware = media_upload;
|
|
/* harmony default export */ var build_module = __webpack_exports__["default"] = (apiFetch);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 43:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _asyncToGenerator; });
|
|
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
|
|
try {
|
|
var info = gen[key](arg);
|
|
var value = info.value;
|
|
} catch (error) {
|
|
reject(error);
|
|
return;
|
|
}
|
|
|
|
if (info.done) {
|
|
resolve(value);
|
|
} else {
|
|
Promise.resolve(value).then(_next, _throw);
|
|
}
|
|
}
|
|
|
|
function _asyncToGenerator(fn) {
|
|
return function () {
|
|
var self = this,
|
|
args = arguments;
|
|
return new Promise(function (resolve, reject) {
|
|
var gen = fn.apply(self, args);
|
|
|
|
function _next(value) {
|
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
|
|
}
|
|
|
|
function _throw(err) {
|
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
|
|
}
|
|
|
|
_next(undefined);
|
|
});
|
|
};
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectSpread; });
|
|
/* harmony import */ var _defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(10);
|
|
|
|
function _objectSpread(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i] != null ? arguments[i] : {};
|
|
var ownKeys = Object.keys(source);
|
|
|
|
if (typeof Object.getOwnPropertySymbols === 'function') {
|
|
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
|
|
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
|
|
}));
|
|
}
|
|
|
|
ownKeys.forEach(function (key) {
|
|
Object(_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(target, key, source[key]);
|
|
});
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
/***/ })
|
|
|
|
/******/ })["default"]; |