[ Index ] |
PHP Cross Reference of WordPress Trunk (Updated Daily) |
[Summary view] [Print] [Text view]
1 /******/ (() => { // webpackBootstrap 2 /******/ "use strict"; 3 /******/ // The require scope 4 /******/ var __webpack_require__ = {}; 5 /******/ 6 /************************************************************************/ 7 /******/ /* webpack/runtime/define property getters */ 8 /******/ (() => { 9 /******/ // define getter functions for harmony exports 10 /******/ __webpack_require__.d = (exports, definition) => { 11 /******/ for(var key in definition) { 12 /******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 13 /******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 14 /******/ } 15 /******/ } 16 /******/ }; 17 /******/ })(); 18 /******/ 19 /******/ /* webpack/runtime/hasOwnProperty shorthand */ 20 /******/ (() => { 21 /******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) 22 /******/ })(); 23 /******/ 24 /************************************************************************/ 25 var __webpack_exports__ = {}; 26 27 // EXPORTS 28 __webpack_require__.d(__webpack_exports__, { 29 "default": () => (/* binding */ build_module) 30 }); 31 32 ;// CONCATENATED MODULE: external ["wp","i18n"] 33 const external_wp_i18n_namespaceObject = window["wp"]["i18n"]; 34 ;// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/nonce.js 35 /** 36 * @param {string} nonce 37 * @return {import('../types').APIFetchMiddleware & { nonce: string }} A middleware to enhance a request with a nonce. 38 */ 39 function createNonceMiddleware(nonce) { 40 /** 41 * @type {import('../types').APIFetchMiddleware & { nonce: string }} 42 */ 43 const middleware = (options, next) => { 44 const { 45 headers = {} 46 } = options; 47 48 // If an 'X-WP-Nonce' header (or any case-insensitive variation 49 // thereof) was specified, no need to add a nonce header. 50 for (const headerName in headers) { 51 if (headerName.toLowerCase() === 'x-wp-nonce' && headers[headerName] === middleware.nonce) { 52 return next(options); 53 } 54 } 55 return next({ 56 ...options, 57 headers: { 58 ...headers, 59 'X-WP-Nonce': middleware.nonce 60 } 61 }); 62 }; 63 middleware.nonce = nonce; 64 return middleware; 65 } 66 /* harmony default export */ const nonce = (createNonceMiddleware); 67 68 ;// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/namespace-endpoint.js 69 /** 70 * @type {import('../types').APIFetchMiddleware} 71 */ 72 const namespaceAndEndpointMiddleware = (options, next) => { 73 let path = options.path; 74 let namespaceTrimmed, endpointTrimmed; 75 if (typeof options.namespace === 'string' && typeof options.endpoint === 'string') { 76 namespaceTrimmed = options.namespace.replace(/^\/|\/$/g, ''); 77 endpointTrimmed = options.endpoint.replace(/^\//, ''); 78 if (endpointTrimmed) { 79 path = namespaceTrimmed + '/' + endpointTrimmed; 80 } else { 81 path = namespaceTrimmed; 82 } 83 } 84 delete options.namespace; 85 delete options.endpoint; 86 return next({ 87 ...options, 88 path 89 }); 90 }; 91 /* harmony default export */ const namespace_endpoint = (namespaceAndEndpointMiddleware); 92 93 ;// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/root-url.js 94 /** 95 * Internal dependencies 96 */ 97 98 99 /** 100 * @param {string} rootURL 101 * @return {import('../types').APIFetchMiddleware} Root URL middleware. 102 */ 103 const createRootURLMiddleware = rootURL => (options, next) => { 104 return namespace_endpoint(options, optionsWithPath => { 105 let url = optionsWithPath.url; 106 let path = optionsWithPath.path; 107 let apiRoot; 108 if (typeof path === 'string') { 109 apiRoot = rootURL; 110 if (-1 !== rootURL.indexOf('?')) { 111 path = path.replace('?', '&'); 112 } 113 path = path.replace(/^\//, ''); 114 115 // API root may already include query parameter prefix if site is 116 // configured to use plain permalinks. 117 if ('string' === typeof apiRoot && -1 !== apiRoot.indexOf('?')) { 118 path = path.replace('?', '&'); 119 } 120 url = apiRoot + path; 121 } 122 return next({ 123 ...optionsWithPath, 124 url 125 }); 126 }); 127 }; 128 /* harmony default export */ const root_url = (createRootURLMiddleware); 129 130 ;// CONCATENATED MODULE: external ["wp","url"] 131 const external_wp_url_namespaceObject = window["wp"]["url"]; 132 ;// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/preloading.js 133 /** 134 * WordPress dependencies 135 */ 136 137 138 /** 139 * @param {Record<string, any>} preloadedData 140 * @return {import('../types').APIFetchMiddleware} Preloading middleware. 141 */ 142 function createPreloadingMiddleware(preloadedData) { 143 const cache = Object.fromEntries(Object.entries(preloadedData).map(([path, data]) => [(0,external_wp_url_namespaceObject.normalizePath)(path), data])); 144 return (options, next) => { 145 const { 146 parse = true 147 } = options; 148 /** @type {string | void} */ 149 let rawPath = options.path; 150 if (!rawPath && options.url) { 151 const { 152 rest_route: pathFromQuery, 153 ...queryArgs 154 } = (0,external_wp_url_namespaceObject.getQueryArgs)(options.url); 155 if (typeof pathFromQuery === 'string') { 156 rawPath = (0,external_wp_url_namespaceObject.addQueryArgs)(pathFromQuery, queryArgs); 157 } 158 } 159 if (typeof rawPath !== 'string') { 160 return next(options); 161 } 162 const method = options.method || 'GET'; 163 const path = (0,external_wp_url_namespaceObject.normalizePath)(rawPath); 164 if ('GET' === method && cache[path]) { 165 const cacheData = cache[path]; 166 167 // Unsetting the cache key ensures that the data is only used a single time. 168 delete cache[path]; 169 return prepareResponse(cacheData, !!parse); 170 } else if ('OPTIONS' === method && cache[method] && cache[method][path]) { 171 const cacheData = cache[method][path]; 172 173 // Unsetting the cache key ensures that the data is only used a single time. 174 delete cache[method][path]; 175 return prepareResponse(cacheData, !!parse); 176 } 177 return next(options); 178 }; 179 } 180 181 /** 182 * This is a helper function that sends a success response. 183 * 184 * @param {Record<string, any>} responseData 185 * @param {boolean} parse 186 * @return {Promise<any>} Promise with the response. 187 */ 188 function prepareResponse(responseData, parse) { 189 return Promise.resolve(parse ? responseData.body : new window.Response(JSON.stringify(responseData.body), { 190 status: 200, 191 statusText: 'OK', 192 headers: responseData.headers 193 })); 194 } 195 /* harmony default export */ const preloading = (createPreloadingMiddleware); 196 197 ;// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/fetch-all-middleware.js 198 /** 199 * WordPress dependencies 200 */ 201 202 203 /** 204 * Internal dependencies 205 */ 206 207 208 /** 209 * Apply query arguments to both URL and Path, whichever is present. 210 * 211 * @param {import('../types').APIFetchOptions} props 212 * @param {Record<string, string | number>} queryArgs 213 * @return {import('../types').APIFetchOptions} The request with the modified query args 214 */ 215 const modifyQuery = ({ 216 path, 217 url, 218 ...options 219 }, queryArgs) => ({ 220 ...options, 221 url: url && (0,external_wp_url_namespaceObject.addQueryArgs)(url, queryArgs), 222 path: path && (0,external_wp_url_namespaceObject.addQueryArgs)(path, queryArgs) 223 }); 224 225 /** 226 * Duplicates parsing functionality from apiFetch. 227 * 228 * @param {Response} response 229 * @return {Promise<any>} Parsed response json. 230 */ 231 const parseResponse = response => response.json ? response.json() : Promise.reject(response); 232 233 /** 234 * @param {string | null} linkHeader 235 * @return {{ next?: string }} The parsed link header. 236 */ 237 const parseLinkHeader = linkHeader => { 238 if (!linkHeader) { 239 return {}; 240 } 241 const match = linkHeader.match(/<([^>]+)>; rel="next"/); 242 return match ? { 243 next: match[1] 244 } : {}; 245 }; 246 247 /** 248 * @param {Response} response 249 * @return {string | undefined} The next page URL. 250 */ 251 const getNextPageUrl = response => { 252 const { 253 next 254 } = parseLinkHeader(response.headers.get('link')); 255 return next; 256 }; 257 258 /** 259 * @param {import('../types').APIFetchOptions} options 260 * @return {boolean} True if the request contains an unbounded query. 261 */ 262 const requestContainsUnboundedQuery = options => { 263 const pathIsUnbounded = !!options.path && options.path.indexOf('per_page=-1') !== -1; 264 const urlIsUnbounded = !!options.url && options.url.indexOf('per_page=-1') !== -1; 265 return pathIsUnbounded || urlIsUnbounded; 266 }; 267 268 /** 269 * The REST API enforces an upper limit on the per_page option. To handle large 270 * collections, apiFetch consumers can pass `per_page=-1`; this middleware will 271 * then recursively assemble a full response array from all available pages. 272 * 273 * @type {import('../types').APIFetchMiddleware} 274 */ 275 const fetchAllMiddleware = async (options, next) => { 276 if (options.parse === false) { 277 // If a consumer has opted out of parsing, do not apply middleware. 278 return next(options); 279 } 280 if (!requestContainsUnboundedQuery(options)) { 281 // If neither url nor path is requesting all items, do not apply middleware. 282 return next(options); 283 } 284 285 // Retrieve requested page of results. 286 const response = await build_module({ 287 ...modifyQuery(options, { 288 per_page: 100 289 }), 290 // Ensure headers are returned for page 1. 291 parse: false 292 }); 293 const results = await parseResponse(response); 294 if (!Array.isArray(results)) { 295 // We have no reliable way of merging non-array results. 296 return results; 297 } 298 let nextPage = getNextPageUrl(response); 299 if (!nextPage) { 300 // There are no further pages to request. 301 return results; 302 } 303 304 // Iteratively fetch all remaining pages until no "next" header is found. 305 let mergedResults = /** @type {any[]} */[].concat(results); 306 while (nextPage) { 307 const nextResponse = await build_module({ 308 ...options, 309 // Ensure the URL for the next page is used instead of any provided path. 310 path: undefined, 311 url: nextPage, 312 // Ensure we still get headers so we can identify the next page. 313 parse: false 314 }); 315 const nextResults = await parseResponse(nextResponse); 316 mergedResults = mergedResults.concat(nextResults); 317 nextPage = getNextPageUrl(nextResponse); 318 } 319 return mergedResults; 320 }; 321 /* harmony default export */ const fetch_all_middleware = (fetchAllMiddleware); 322 323 ;// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/http-v1.js 324 /** 325 * Set of HTTP methods which are eligible to be overridden. 326 * 327 * @type {Set<string>} 328 */ 329 const OVERRIDE_METHODS = new Set(['PATCH', 'PUT', 'DELETE']); 330 331 /** 332 * Default request method. 333 * 334 * "A request has an associated method (a method). Unless stated otherwise it 335 * is `GET`." 336 * 337 * @see https://fetch.spec.whatwg.org/#requests 338 * 339 * @type {string} 340 */ 341 const DEFAULT_METHOD = 'GET'; 342 343 /** 344 * API Fetch middleware which overrides the request method for HTTP v1 345 * compatibility leveraging the REST API X-HTTP-Method-Override header. 346 * 347 * @type {import('../types').APIFetchMiddleware} 348 */ 349 const httpV1Middleware = (options, next) => { 350 const { 351 method = DEFAULT_METHOD 352 } = options; 353 if (OVERRIDE_METHODS.has(method.toUpperCase())) { 354 options = { 355 ...options, 356 headers: { 357 ...options.headers, 358 'X-HTTP-Method-Override': method, 359 'Content-Type': 'application/json' 360 }, 361 method: 'POST' 362 }; 363 } 364 return next(options); 365 }; 366 /* harmony default export */ const http_v1 = (httpV1Middleware); 367 368 ;// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/user-locale.js 369 /** 370 * WordPress dependencies 371 */ 372 373 374 /** 375 * @type {import('../types').APIFetchMiddleware} 376 */ 377 const userLocaleMiddleware = (options, next) => { 378 if (typeof options.url === 'string' && !(0,external_wp_url_namespaceObject.hasQueryArg)(options.url, '_locale')) { 379 options.url = (0,external_wp_url_namespaceObject.addQueryArgs)(options.url, { 380 _locale: 'user' 381 }); 382 } 383 if (typeof options.path === 'string' && !(0,external_wp_url_namespaceObject.hasQueryArg)(options.path, '_locale')) { 384 options.path = (0,external_wp_url_namespaceObject.addQueryArgs)(options.path, { 385 _locale: 'user' 386 }); 387 } 388 return next(options); 389 }; 390 /* harmony default export */ const user_locale = (userLocaleMiddleware); 391 392 ;// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/utils/response.js 393 /** 394 * WordPress dependencies 395 */ 396 397 398 /** 399 * Parses the apiFetch response. 400 * 401 * @param {Response} response 402 * @param {boolean} shouldParseResponse 403 * 404 * @return {Promise<any> | null | Response} Parsed response. 405 */ 406 const response_parseResponse = (response, shouldParseResponse = true) => { 407 if (shouldParseResponse) { 408 if (response.status === 204) { 409 return null; 410 } 411 return response.json ? response.json() : Promise.reject(response); 412 } 413 return response; 414 }; 415 416 /** 417 * Calls the `json` function on the Response, throwing an error if the response 418 * doesn't have a json function or if parsing the json itself fails. 419 * 420 * @param {Response} response 421 * @return {Promise<any>} Parsed response. 422 */ 423 const parseJsonAndNormalizeError = response => { 424 const invalidJsonError = { 425 code: 'invalid_json', 426 message: (0,external_wp_i18n_namespaceObject.__)('The response is not a valid JSON response.') 427 }; 428 if (!response || !response.json) { 429 throw invalidJsonError; 430 } 431 return response.json().catch(() => { 432 throw invalidJsonError; 433 }); 434 }; 435 436 /** 437 * Parses the apiFetch response properly and normalize response errors. 438 * 439 * @param {Response} response 440 * @param {boolean} shouldParseResponse 441 * 442 * @return {Promise<any>} Parsed response. 443 */ 444 const parseResponseAndNormalizeError = (response, shouldParseResponse = true) => { 445 return Promise.resolve(response_parseResponse(response, shouldParseResponse)).catch(res => parseAndThrowError(res, shouldParseResponse)); 446 }; 447 448 /** 449 * Parses a response, throwing an error if parsing the response fails. 450 * 451 * @param {Response} response 452 * @param {boolean} shouldParseResponse 453 * @return {Promise<any>} Parsed response. 454 */ 455 function parseAndThrowError(response, shouldParseResponse = true) { 456 if (!shouldParseResponse) { 457 throw response; 458 } 459 return parseJsonAndNormalizeError(response).then(error => { 460 const unknownError = { 461 code: 'unknown_error', 462 message: (0,external_wp_i18n_namespaceObject.__)('An unknown error occurred.') 463 }; 464 throw error || unknownError; 465 }); 466 } 467 468 ;// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/media-upload.js 469 /** 470 * WordPress dependencies 471 */ 472 473 474 /** 475 * Internal dependencies 476 */ 477 478 479 /** 480 * @param {import('../types').APIFetchOptions} options 481 * @return {boolean} True if the request is for media upload. 482 */ 483 function isMediaUploadRequest(options) { 484 const isCreateMethod = !!options.method && options.method === 'POST'; 485 const isMediaEndpoint = !!options.path && options.path.indexOf('/wp/v2/media') !== -1 || !!options.url && options.url.indexOf('/wp/v2/media') !== -1; 486 return isMediaEndpoint && isCreateMethod; 487 } 488 489 /** 490 * Middleware handling media upload failures and retries. 491 * 492 * @type {import('../types').APIFetchMiddleware} 493 */ 494 const mediaUploadMiddleware = (options, next) => { 495 if (!isMediaUploadRequest(options)) { 496 return next(options); 497 } 498 let retries = 0; 499 const maxRetries = 5; 500 501 /** 502 * @param {string} attachmentId 503 * @return {Promise<any>} Processed post response. 504 */ 505 const postProcess = attachmentId => { 506 retries++; 507 return next({ 508 path: `/wp/v2/media/$attachmentId}/post-process`, 509 method: 'POST', 510 data: { 511 action: 'create-image-subsizes' 512 }, 513 parse: false 514 }).catch(() => { 515 if (retries < maxRetries) { 516 return postProcess(attachmentId); 517 } 518 next({ 519 path: `/wp/v2/media/$attachmentId}?force=true`, 520 method: 'DELETE' 521 }); 522 return Promise.reject(); 523 }); 524 }; 525 return next({ 526 ...options, 527 parse: false 528 }).catch(response => { 529 const attachmentId = response.headers.get('x-wp-upload-attachment-id'); 530 if (response.status >= 500 && response.status < 600 && attachmentId) { 531 return postProcess(attachmentId).catch(() => { 532 if (options.parse !== false) { 533 return Promise.reject({ 534 code: 'post_process', 535 message: (0,external_wp_i18n_namespaceObject.__)('Media upload failed. If this is a photo or a large image, please scale it down and try again.') 536 }); 537 } 538 return Promise.reject(response); 539 }); 540 } 541 return parseAndThrowError(response, options.parse); 542 }).then(response => parseResponseAndNormalizeError(response, options.parse)); 543 }; 544 /* harmony default export */ const media_upload = (mediaUploadMiddleware); 545 546 ;// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/theme-preview.js 547 /** 548 * WordPress dependencies 549 */ 550 551 552 /** 553 * This appends a `wp_theme_preview` parameter to the REST API request URL if 554 * the admin URL contains a `theme` GET parameter. 555 * 556 * If the REST API request URL has contained the `wp_theme_preview` parameter as `''`, 557 * then bypass this middleware. 558 * 559 * @param {Record<string, any>} themePath 560 * @return {import('../types').APIFetchMiddleware} Preloading middleware. 561 */ 562 const createThemePreviewMiddleware = themePath => (options, next) => { 563 if (typeof options.url === 'string') { 564 const wpThemePreview = (0,external_wp_url_namespaceObject.getQueryArg)(options.url, 'wp_theme_preview'); 565 if (wpThemePreview === undefined) { 566 options.url = (0,external_wp_url_namespaceObject.addQueryArgs)(options.url, { 567 wp_theme_preview: themePath 568 }); 569 } else if (wpThemePreview === '') { 570 options.url = (0,external_wp_url_namespaceObject.removeQueryArgs)(options.url, 'wp_theme_preview'); 571 } 572 } 573 if (typeof options.path === 'string') { 574 const wpThemePreview = (0,external_wp_url_namespaceObject.getQueryArg)(options.path, 'wp_theme_preview'); 575 if (wpThemePreview === undefined) { 576 options.path = (0,external_wp_url_namespaceObject.addQueryArgs)(options.path, { 577 wp_theme_preview: themePath 578 }); 579 } else if (wpThemePreview === '') { 580 options.path = (0,external_wp_url_namespaceObject.removeQueryArgs)(options.path, 'wp_theme_preview'); 581 } 582 } 583 return next(options); 584 }; 585 /* harmony default export */ const theme_preview = (createThemePreviewMiddleware); 586 587 ;// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/index.js 588 /** 589 * WordPress dependencies 590 */ 591 592 593 /** 594 * Internal dependencies 595 */ 596 597 598 599 600 601 602 603 604 605 606 607 /** 608 * Default set of header values which should be sent with every request unless 609 * explicitly provided through apiFetch options. 610 * 611 * @type {Record<string, string>} 612 */ 613 const DEFAULT_HEADERS = { 614 // The backend uses the Accept header as a condition for considering an 615 // incoming request as a REST request. 616 // 617 // See: https://core.trac.wordpress.org/ticket/44534 618 Accept: 'application/json, */*;q=0.1' 619 }; 620 621 /** 622 * Default set of fetch option values which should be sent with every request 623 * unless explicitly provided through apiFetch options. 624 * 625 * @type {Object} 626 */ 627 const DEFAULT_OPTIONS = { 628 credentials: 'include' 629 }; 630 631 /** @typedef {import('./types').APIFetchMiddleware} APIFetchMiddleware */ 632 /** @typedef {import('./types').APIFetchOptions} APIFetchOptions */ 633 634 /** 635 * @type {import('./types').APIFetchMiddleware[]} 636 */ 637 const middlewares = [user_locale, namespace_endpoint, http_v1, fetch_all_middleware]; 638 639 /** 640 * Register a middleware 641 * 642 * @param {import('./types').APIFetchMiddleware} middleware 643 */ 644 function registerMiddleware(middleware) { 645 middlewares.unshift(middleware); 646 } 647 648 /** 649 * Checks the status of a response, throwing the Response as an error if 650 * it is outside the 200 range. 651 * 652 * @param {Response} response 653 * @return {Response} The response if the status is in the 200 range. 654 */ 655 const checkStatus = response => { 656 if (response.status >= 200 && response.status < 300) { 657 return response; 658 } 659 throw response; 660 }; 661 662 /** @typedef {(options: import('./types').APIFetchOptions) => Promise<any>} FetchHandler*/ 663 664 /** 665 * @type {FetchHandler} 666 */ 667 const defaultFetchHandler = nextOptions => { 668 const { 669 url, 670 path, 671 data, 672 parse = true, 673 ...remainingOptions 674 } = nextOptions; 675 let { 676 body, 677 headers 678 } = nextOptions; 679 680 // Merge explicitly-provided headers with default values. 681 headers = { 682 ...DEFAULT_HEADERS, 683 ...headers 684 }; 685 686 // The `data` property is a shorthand for sending a JSON body. 687 if (data) { 688 body = JSON.stringify(data); 689 headers['Content-Type'] = 'application/json'; 690 } 691 const responsePromise = window.fetch( 692 // Fall back to explicitly passing `window.location` which is the behavior if `undefined` is passed. 693 url || path || window.location.href, { 694 ...DEFAULT_OPTIONS, 695 ...remainingOptions, 696 body, 697 headers 698 }); 699 return responsePromise.then(value => Promise.resolve(value).then(checkStatus).catch(response => parseAndThrowError(response, parse)).then(response => parseResponseAndNormalizeError(response, parse)), err => { 700 // Re-throw AbortError for the users to handle it themselves. 701 if (err && err.name === 'AbortError') { 702 throw err; 703 } 704 705 // Otherwise, there is most likely no network connection. 706 // Unfortunately the message might depend on the browser. 707 throw { 708 code: 'fetch_error', 709 message: (0,external_wp_i18n_namespaceObject.__)('You are probably offline.') 710 }; 711 }); 712 }; 713 714 /** @type {FetchHandler} */ 715 let fetchHandler = defaultFetchHandler; 716 717 /** 718 * Defines a custom fetch handler for making the requests that will override 719 * the default one using window.fetch 720 * 721 * @param {FetchHandler} newFetchHandler The new fetch handler 722 */ 723 function setFetchHandler(newFetchHandler) { 724 fetchHandler = newFetchHandler; 725 } 726 727 /** 728 * @template T 729 * @param {import('./types').APIFetchOptions} options 730 * @return {Promise<T>} A promise representing the request processed via the registered middlewares. 731 */ 732 function apiFetch(options) { 733 // creates a nested function chain that calls all middlewares and finally the `fetchHandler`, 734 // converting `middlewares = [ m1, m2, m3 ]` into: 735 // ``` 736 // opts1 => m1( opts1, opts2 => m2( opts2, opts3 => m3( opts3, fetchHandler ) ) ); 737 // ``` 738 const enhancedHandler = middlewares.reduceRight(( /** @type {FetchHandler} */next, middleware) => { 739 return workingOptions => middleware(workingOptions, next); 740 }, fetchHandler); 741 return enhancedHandler(options).catch(error => { 742 if (error.code !== 'rest_cookie_invalid_nonce') { 743 return Promise.reject(error); 744 } 745 746 // If the nonce is invalid, refresh it and try again. 747 return window 748 // @ts-ignore 749 .fetch(apiFetch.nonceEndpoint).then(checkStatus).then(data => data.text()).then(text => { 750 // @ts-ignore 751 apiFetch.nonceMiddleware.nonce = text; 752 return apiFetch(options); 753 }); 754 }); 755 } 756 apiFetch.use = registerMiddleware; 757 apiFetch.setFetchHandler = setFetchHandler; 758 apiFetch.createNonceMiddleware = nonce; 759 apiFetch.createPreloadingMiddleware = preloading; 760 apiFetch.createRootURLMiddleware = root_url; 761 apiFetch.fetchAllMiddleware = fetch_all_middleware; 762 apiFetch.mediaUploadMiddleware = media_upload; 763 apiFetch.createThemePreviewMiddleware = theme_preview; 764 /* harmony default export */ const build_module = (apiFetch); 765 766 (window.wp = window.wp || {}).apiFetch = __webpack_exports__["default"]; 767 /******/ })() 768 ;
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
Generated : Mon Mar 18 08:20:01 2024 | Cross-referenced by PHPXref |