[Summary view] [Print] [Text view]

   1  (function() {
   2  "use strict";
   3  var wp;
   4  (wp ||= {}).apiFetch = (() => {
   5    var __create = Object.create;
   6    var __defProp = Object.defineProperty;
   7    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   8    var __getOwnPropNames = Object.getOwnPropertyNames;
   9    var __getProtoOf = Object.getPrototypeOf;
  10    var __hasOwnProp = Object.prototype.hasOwnProperty;
  11    var __commonJS = (cb, mod) => function __require() {
  12      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  13    };
  14    var __export = (target, all) => {
  15      for (var name in all)
  16        __defProp(target, name, { get: all[name], enumerable: true });
  17    };
  18    var __copyProps = (to, from, except, desc) => {
  19      if (from && typeof from === "object" || typeof from === "function") {
  20        for (let key of __getOwnPropNames(from))
  21          if (!__hasOwnProp.call(to, key) && key !== except)
  22            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  23      }
  24      return to;
  25    };
  26    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  27      // If the importer is in node compatibility mode or this is not an ESM
  28      // file that has been converted to a CommonJS file using a Babel-
  29      // compatible transform (i.e. "__esModule" has not been set), then set
  30      // "default" to the CommonJS "module.exports" for node compatibility.
  31      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  32      mod
  33    ));
  34    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  35  
  36    // package-external:@wordpress/i18n
  37    var require_i18n = __commonJS({
  38      "package-external:@wordpress/i18n"(exports, module) {
  39        module.exports = window.wp.i18n;
  40      }
  41    });
  42  
  43    // package-external:@wordpress/private-apis
  44    var require_private_apis = __commonJS({
  45      "package-external:@wordpress/private-apis"(exports, module) {
  46        module.exports = window.wp.privateApis;
  47      }
  48    });
  49  
  50    // package-external:@wordpress/url
  51    var require_url = __commonJS({
  52      "package-external:@wordpress/url"(exports, module) {
  53        module.exports = window.wp.url;
  54      }
  55    });
  56  
  57    // packages/api-fetch/build-module/index.mjs
  58    var index_exports = {};
  59    __export(index_exports, {
  60      default: () => index_default
  61    });
  62    var import_i18n3 = __toESM(require_i18n(), 1);
  63  
  64    // packages/api-fetch/build-module/lock-unlock.mjs
  65    var import_private_apis = __toESM(require_private_apis(), 1);
  66    var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
  67      "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
  68      "@wordpress/api-fetch"
  69    );
  70  
  71    // packages/api-fetch/build-module/middlewares/nonce.mjs
  72    function createNonceMiddleware(nonce) {
  73      const middleware = (options, next) => {
  74        const { headers = {} } = options;
  75        for (const headerName in headers) {
  76          if (headerName.toLowerCase() === "x-wp-nonce" && headers[headerName] === middleware.nonce) {
  77            return next(options);
  78          }
  79        }
  80        return next({
  81          ...options,
  82          headers: {
  83            ...headers,
  84            "X-WP-Nonce": middleware.nonce
  85          }
  86        });
  87      };
  88      middleware.nonce = nonce;
  89      return middleware;
  90    }
  91    var nonce_default = createNonceMiddleware;
  92  
  93    // packages/api-fetch/build-module/middlewares/namespace-endpoint.mjs
  94    var namespaceAndEndpointMiddleware = (options, next) => {
  95      let path = options.path;
  96      let namespaceTrimmed, endpointTrimmed;
  97      if (typeof options.namespace === "string" && typeof options.endpoint === "string") {
  98        namespaceTrimmed = options.namespace.replace(/^\/|\/$/g, "");
  99        endpointTrimmed = options.endpoint.replace(/^\//, "");
 100        if (endpointTrimmed) {
 101          path = namespaceTrimmed + "/" + endpointTrimmed;
 102        } else {
 103          path = namespaceTrimmed;
 104        }
 105      }
 106      delete options.namespace;
 107      delete options.endpoint;
 108      return next({
 109        ...options,
 110        path
 111      });
 112    };
 113    var namespace_endpoint_default = namespaceAndEndpointMiddleware;
 114  
 115    // packages/api-fetch/build-module/middlewares/root-url.mjs
 116    var createRootURLMiddleware = (rootURL) => (options, next) => {
 117      return namespace_endpoint_default(options, (optionsWithPath) => {
 118        let url = optionsWithPath.url;
 119        let path = optionsWithPath.path;
 120        let apiRoot;
 121        if (typeof path === "string") {
 122          apiRoot = rootURL;
 123          if (-1 !== rootURL.indexOf("?")) {
 124            path = path.replace("?", "&");
 125          }
 126          path = path.replace(/^\//, "");
 127          if ("string" === typeof apiRoot && -1 !== apiRoot.indexOf("?")) {
 128            path = path.replace("?", "&");
 129          }
 130          url = apiRoot + path;
 131        }
 132        return next({
 133          ...optionsWithPath,
 134          url
 135        });
 136      });
 137    };
 138    var root_url_default = createRootURLMiddleware;
 139  
 140    // packages/api-fetch/build-module/middlewares/preloading.mjs
 141    var import_url = __toESM(require_url(), 1);
 142    var ENABLE_MULTI_USE = /* @__PURE__ */ Symbol("preloadingEnableMultiUse");
 143    var CLEAR = /* @__PURE__ */ Symbol("preloadingClear");
 144    function createPreloadingMiddleware(preloadedData) {
 145      const { OPTIONS = {}, ...GET } = Object.fromEntries(
 146        Object.entries(preloadedData).map(([path, data]) => [
 147          (0, import_url.normalizePath)(path),
 148          data
 149        ])
 150      );
 151      const unusedGet = new Set(Object.keys(GET));
 152      const unusedOptions = new Set(Object.keys(OPTIONS));
 153      let multiUse = false;
 154      const middleware = (options, next) => {
 155        const { parse = true } = options;
 156        let rawPath = options.path;
 157        if (!rawPath && options.url) {
 158          const { rest_route: pathFromQuery, ...queryArgs } = (0, import_url.getQueryArgs)(
 159            options.url
 160          );
 161          if (typeof pathFromQuery === "string") {
 162            rawPath = (0, import_url.addQueryArgs)(pathFromQuery, queryArgs);
 163          }
 164        }
 165        if (typeof rawPath !== "string") {
 166          return next(options);
 167        }
 168        const method = options.method || "GET";
 169        const path = (0, import_url.normalizePath)(rawPath);
 170        if ("GET" === method && GET[path]) {
 171          const data = GET[path];
 172          if (!multiUse) {
 173            delete GET[path];
 174          }
 175          unusedGet.delete(path);
 176          return prepareResponse(data, !!parse);
 177        } else if ("OPTIONS" === method && OPTIONS[path]) {
 178          const data = OPTIONS[path];
 179          if (!multiUse) {
 180            delete OPTIONS[path];
 181          }
 182          unusedOptions.delete(path);
 183          return prepareResponse(data, !!parse);
 184        }
 185        return next(options);
 186      };
 187      middleware[ENABLE_MULTI_USE] = () => {
 188        multiUse = true;
 189      };
 190      middleware[CLEAR] = () => {
 191        const tags = [
 192          ...Array.from(unusedGet, (p) => `GET $p}`),
 193          ...Array.from(unusedOptions, (p) => `OPTIONS $p}`)
 194        ];
 195        if (tags.length) {
 196          console.warn(
 197            "[api-fetch][preload] Some preloads were never consumed:",
 198            tags
 199          );
 200        } else {
 201          console.log("[api-fetch][preload] All preloads consumed.");
 202        }
 203        unusedGet.clear();
 204        unusedOptions.clear();
 205        for (const key of Object.keys(GET)) {
 206          delete GET[key];
 207        }
 208        for (const key of Object.keys(OPTIONS)) {
 209          delete OPTIONS[key];
 210        }
 211      };
 212      return middleware;
 213    }
 214    function prepareResponse(responseData, parse) {
 215      if (parse) {
 216        return Promise.resolve(responseData.body);
 217      }
 218      try {
 219        return Promise.resolve(
 220          new window.Response(JSON.stringify(responseData.body), {
 221            status: 200,
 222            statusText: "OK",
 223            headers: responseData.headers
 224          })
 225        );
 226      } catch {
 227        Object.entries(
 228          responseData.headers
 229        ).forEach(([key, value]) => {
 230          if (key.toLowerCase() === "link") {
 231            responseData.headers[key] = value.replace(
 232              /<([^>]+)>/,
 233              (_, url) => `<$encodeURI(url)}>`
 234            );
 235          }
 236        });
 237        return Promise.resolve(
 238          parse ? responseData.body : new window.Response(JSON.stringify(responseData.body), {
 239            status: 200,
 240            statusText: "OK",
 241            headers: responseData.headers
 242          })
 243        );
 244      }
 245    }
 246    var preloading_default = createPreloadingMiddleware;
 247  
 248    // packages/api-fetch/build-module/middlewares/fetch-all-middleware.mjs
 249    var import_url2 = __toESM(require_url(), 1);
 250    var modifyQuery = ({ path, url, ...options }, queryArgs) => ({
 251      ...options,
 252      url: url && (0, import_url2.addQueryArgs)(url, queryArgs),
 253      path: path && (0, import_url2.addQueryArgs)(path, queryArgs)
 254    });
 255    var parseResponse = (response) => response.json ? response.json() : Promise.reject(response);
 256    var parseLinkHeader = (linkHeader) => {
 257      if (!linkHeader) {
 258        return {};
 259      }
 260      const match = linkHeader.match(/<([^>]+)>; rel="next"/);
 261      return match ? {
 262        next: match[1]
 263      } : {};
 264    };
 265    var getNextPageUrl = (response) => {
 266      const { next } = parseLinkHeader(response.headers.get("link"));
 267      return next;
 268    };
 269    var requestContainsUnboundedQuery = (options) => {
 270      const pathIsUnbounded = !!options.path && options.path.indexOf("per_page=-1") !== -1;
 271      const urlIsUnbounded = !!options.url && options.url.indexOf("per_page=-1") !== -1;
 272      return pathIsUnbounded || urlIsUnbounded;
 273    };
 274    var fetchAllMiddleware = async (options, next) => {
 275      if (options.parse === false) {
 276        return next(options);
 277      }
 278      if (!requestContainsUnboundedQuery(options)) {
 279        return next(options);
 280      }
 281      const response = await index_default({
 282        ...modifyQuery(options, {
 283          per_page: 100
 284        }),
 285        // Ensure headers are returned for page 1.
 286        parse: false
 287      });
 288      const results = await parseResponse(response);
 289      if (!Array.isArray(results)) {
 290        return results;
 291      }
 292      let nextPage = getNextPageUrl(response);
 293      if (!nextPage) {
 294        return results;
 295      }
 296      let mergedResults = [].concat(results);
 297      while (nextPage) {
 298        const nextResponse = await index_default({
 299          ...options,
 300          // Ensure the URL for the next page is used instead of any provided path.
 301          path: void 0,
 302          url: nextPage,
 303          // Ensure we still get headers so we can identify the next page.
 304          parse: false
 305        });
 306        const nextResults = await parseResponse(nextResponse);
 307        mergedResults = mergedResults.concat(nextResults);
 308        nextPage = getNextPageUrl(nextResponse);
 309      }
 310      return mergedResults;
 311    };
 312    var fetch_all_middleware_default = fetchAllMiddleware;
 313  
 314    // packages/api-fetch/build-module/middlewares/http-v1.mjs
 315    var OVERRIDE_METHODS = /* @__PURE__ */ new Set(["PATCH", "PUT", "DELETE"]);
 316    var DEFAULT_METHOD = "GET";
 317    var httpV1Middleware = (options, next) => {
 318      const { method = DEFAULT_METHOD } = options;
 319      if (OVERRIDE_METHODS.has(method.toUpperCase())) {
 320        options = {
 321          ...options,
 322          headers: {
 323            "Content-Type": "application/json",
 324            ...options.headers,
 325            "X-HTTP-Method-Override": method
 326          },
 327          method: "POST"
 328        };
 329      }
 330      return next(options);
 331    };
 332    var http_v1_default = httpV1Middleware;
 333  
 334    // packages/api-fetch/build-module/middlewares/user-locale.mjs
 335    var import_url3 = __toESM(require_url(), 1);
 336    var userLocaleMiddleware = (options, next) => {
 337      if (typeof options.url === "string" && !(0, import_url3.hasQueryArg)(options.url, "_locale")) {
 338        options.url = (0, import_url3.addQueryArgs)(options.url, { _locale: "user" });
 339      }
 340      if (typeof options.path === "string" && !(0, import_url3.hasQueryArg)(options.path, "_locale")) {
 341        options.path = (0, import_url3.addQueryArgs)(options.path, { _locale: "user" });
 342      }
 343      return next(options);
 344    };
 345    var user_locale_default = userLocaleMiddleware;
 346  
 347    // packages/api-fetch/build-module/middlewares/media-upload.mjs
 348    var import_i18n2 = __toESM(require_i18n(), 1);
 349  
 350    // packages/api-fetch/build-module/utils/response.mjs
 351    var import_i18n = __toESM(require_i18n(), 1);
 352    async function parseJsonAndNormalizeError(response, allowEmptyBody = false) {
 353      try {
 354        if (typeof response.text !== "function") {
 355          return await response.json();
 356        }
 357        const text = await response.text();
 358        if (allowEmptyBody && text === "") {
 359          return null;
 360        }
 361        return JSON.parse(text);
 362      } catch {
 363        throw {
 364          code: "invalid_json",
 365          message: (0, import_i18n.__)("The response is not a valid JSON response."),
 366          data: { status: response.status }
 367        };
 368      }
 369    }
 370    async function parseResponseAndNormalizeError(response, shouldParseResponse = true) {
 371      if (!shouldParseResponse) {
 372        return response;
 373      }
 374      if (response.status === 204) {
 375        return null;
 376      }
 377      return await parseJsonAndNormalizeError(response, true);
 378    }
 379    async function parseAndThrowError(response, shouldParseResponse = true) {
 380      if (!shouldParseResponse) {
 381        throw response;
 382      }
 383      const error = await parseJsonAndNormalizeError(response);
 384      if (error && typeof error === "object" && !Array.isArray(error) && error.data === void 0) {
 385        throw { ...error, data: { status: response.status } };
 386      }
 387      throw error;
 388    }
 389  
 390    // packages/api-fetch/build-module/middlewares/media-upload.mjs
 391    function isMediaUploadRequest(options) {
 392      const isCreateMethod = !!options.method && options.method === "POST";
 393      const isMediaEndpoint = !!options.path && options.path.indexOf("/wp/v2/media") !== -1 || !!options.url && options.url.indexOf("/wp/v2/media") !== -1;
 394      return isMediaEndpoint && isCreateMethod;
 395    }
 396    var mediaUploadMiddleware = (options, next) => {
 397      if (!isMediaUploadRequest(options)) {
 398        return next(options);
 399      }
 400      let retries = 0;
 401      const maxRetries = 5;
 402      const postProcess = (attachmentId) => {
 403        retries++;
 404        return next({
 405          path: `/wp/v2/media/$attachmentId}/post-process`,
 406          method: "POST",
 407          data: { action: "create-image-subsizes" },
 408          parse: false
 409        }).catch(() => {
 410          if (retries < maxRetries) {
 411            return postProcess(attachmentId);
 412          }
 413          next({
 414            path: `/wp/v2/media/$attachmentId}?force=true`,
 415            method: "DELETE"
 416          });
 417          return Promise.reject();
 418        });
 419      };
 420      return next({ ...options, parse: false }).catch((response) => {
 421        if (!(response instanceof globalThis.Response)) {
 422          return Promise.reject(response);
 423        }
 424        const attachmentId = response.headers.get(
 425          "x-wp-upload-attachment-id"
 426        );
 427        if (response.status >= 500 && response.status < 600 && attachmentId) {
 428          return postProcess(attachmentId).catch(() => {
 429            if (options.parse !== false) {
 430              return Promise.reject({
 431                code: "post_process",
 432                message: (0, import_i18n2.__)(
 433                  "Media upload failed. If this is a photo or a large image, please scale it down and try again."
 434                )
 435              });
 436            }
 437            return Promise.reject(response);
 438          });
 439        }
 440        return parseAndThrowError(response, options.parse);
 441      }).then(
 442        (response) => parseResponseAndNormalizeError(response, options.parse)
 443      );
 444    };
 445    var media_upload_default = mediaUploadMiddleware;
 446  
 447    // packages/api-fetch/build-module/middlewares/theme-preview.mjs
 448    var import_url4 = __toESM(require_url(), 1);
 449    var createThemePreviewMiddleware = (themePath) => (options, next) => {
 450      if (typeof options.url === "string") {
 451        const wpThemePreview = (0, import_url4.getQueryArg)(
 452          options.url,
 453          "wp_theme_preview"
 454        );
 455        if (wpThemePreview === void 0) {
 456          options.url = (0, import_url4.addQueryArgs)(options.url, {
 457            wp_theme_preview: themePath
 458          });
 459        } else if (wpThemePreview === "") {
 460          options.url = (0, import_url4.removeQueryArgs)(
 461            options.url,
 462            "wp_theme_preview"
 463          );
 464        }
 465      }
 466      if (typeof options.path === "string") {
 467        const wpThemePreview = (0, import_url4.getQueryArg)(
 468          options.path,
 469          "wp_theme_preview"
 470        );
 471        if (wpThemePreview === void 0) {
 472          options.path = (0, import_url4.addQueryArgs)(options.path, {
 473            wp_theme_preview: themePath
 474          });
 475        } else if (wpThemePreview === "") {
 476          options.path = (0, import_url4.removeQueryArgs)(
 477            options.path,
 478            "wp_theme_preview"
 479          );
 480        }
 481      }
 482      return next(options);
 483    };
 484    var theme_preview_default = createThemePreviewMiddleware;
 485  
 486    // packages/api-fetch/build-module/index.mjs
 487    var DEFAULT_HEADERS = {
 488      // The backend uses the Accept header as a condition for considering an
 489      // incoming request as a REST request.
 490      //
 491      // See: https://core.trac.wordpress.org/ticket/44534
 492      Accept: "application/json, */*;q=0.1"
 493    };
 494    var DEFAULT_OPTIONS = {
 495      credentials: "include"
 496    };
 497    var middlewares = [
 498      user_locale_default,
 499      namespace_endpoint_default,
 500      http_v1_default,
 501      fetch_all_middleware_default
 502    ];
 503    function registerMiddleware(middleware) {
 504      middlewares.unshift(middleware);
 505    }
 506    function unregisterMiddleware(middleware) {
 507      const index = middlewares.indexOf(middleware);
 508      if (index === -1) {
 509        return false;
 510      }
 511      middlewares.splice(index, 1);
 512      return true;
 513    }
 514    function enablePreloadMultiUse() {
 515      for (const middleware of middlewares) {
 516        middleware[ENABLE_MULTI_USE]?.();
 517      }
 518    }
 519    function clearPreloadedData() {
 520      for (const middleware of middlewares) {
 521        middleware[CLEAR]?.();
 522      }
 523    }
 524    var defaultFetchHandler = (options) => {
 525      const { url, path, data, parse = true, ...remainingOptions } = options;
 526      let { body, headers } = options;
 527      headers = { ...DEFAULT_HEADERS, ...headers };
 528      if (data) {
 529        body = JSON.stringify(data);
 530        headers["Content-Type"] = "application/json";
 531      }
 532      const responsePromise = globalThis.fetch(
 533        // Fall back to explicitly passing `window.location` which is the behavior if `undefined` is passed.
 534        url || path || window.location.href,
 535        {
 536          ...DEFAULT_OPTIONS,
 537          ...remainingOptions,
 538          body,
 539          headers
 540        }
 541      );
 542      return responsePromise.then(
 543        (response) => {
 544          if (!response.ok) {
 545            return parseAndThrowError(response, parse);
 546          }
 547          return parseResponseAndNormalizeError(response, parse);
 548        },
 549        (err) => {
 550          if (err && err.name === "AbortError") {
 551            throw err;
 552          }
 553          if (!globalThis.navigator.onLine) {
 554            throw {
 555              code: "offline_error",
 556              message: (0, import_i18n3.__)(
 557                "Unable to connect. Please check your Internet connection."
 558              )
 559            };
 560          }
 561          throw {
 562            code: "fetch_error",
 563            message: (0, import_i18n3.__)(
 564              "Could not get a valid response from the server."
 565            )
 566          };
 567        }
 568      );
 569    };
 570    var fetchHandler = defaultFetchHandler;
 571    function setFetchHandler(newFetchHandler) {
 572      fetchHandler = newFetchHandler;
 573    }
 574    var apiFetch = (options) => {
 575      const enhancedHandler = middlewares.reduceRight(
 576        (next, middleware) => {
 577          return (workingOptions) => middleware(workingOptions, next);
 578        },
 579        fetchHandler
 580      );
 581      return enhancedHandler(options).catch((error) => {
 582        if (error.code !== "rest_cookie_invalid_nonce") {
 583          return Promise.reject(error);
 584        }
 585        return globalThis.fetch(apiFetch.nonceEndpoint).then((response) => {
 586          if (!response.ok) {
 587            return Promise.reject(error);
 588          }
 589          return response.text();
 590        }).then((text) => {
 591          apiFetch.nonceMiddleware.nonce = text;
 592          return apiFetch(options);
 593        });
 594      });
 595    };
 596    apiFetch.use = registerMiddleware;
 597    apiFetch.unregister = unregisterMiddleware;
 598    apiFetch.setFetchHandler = setFetchHandler;
 599    apiFetch.defaultFetchHandler = defaultFetchHandler;
 600    apiFetch.privateApis = {};
 601    lock(apiFetch.privateApis, {
 602      enablePreloadMultiUse,
 603      clearPreloadedData
 604    });
 605    apiFetch.createNonceMiddleware = nonce_default;
 606    apiFetch.createPreloadingMiddleware = preloading_default;
 607    apiFetch.createRootURLMiddleware = root_url_default;
 608    apiFetch.fetchAllMiddleware = fetch_all_middleware_default;
 609    apiFetch.httpV1Middleware = http_v1_default;
 610    apiFetch.mediaUploadMiddleware = media_upload_default;
 611    apiFetch.createThemePreviewMiddleware = theme_preview_default;
 612    var index_default = apiFetch;
 613    return __toCommonJS(index_exports);
 614  })();
 615  if (typeof wp.apiFetch === 'object' && wp.apiFetch.default) { wp.apiFetch = wp.apiFetch.default; }
 616  (window.wp ||= {}).apiFetch = wp.apiFetch;
 617  })();