@prezly/theme-kit-nextjs 10.9.0 → 10.9.2

package/build/adapters/prezly/requests.mjs

@@ -0,0 +1,144 @@
+var _registry$key;
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function abortReason(signal) {
+  if (signal.reason instanceof Error) return signal.reason;
+  var error = new Error('Content request aborted.');
+  error.name = 'AbortError';
+  return error;
+}
+
+/** Limit actual HTTP requests, not aggregate ContentDelivery methods. */
+export class FetchScheduler {
+  constructor() {
+    var limits = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _defineProperty(this, "active", 0);
+    _defineProperty(this, "queue", []);
+    _defineProperty(this, "limits", void 0);
+    this.limits = _objectSpread({
+      concurrency: 32,
+      queueLimit: 256,
+      queueTimeout: 1000,
+      requestTimeout: 30000
+    }, limits);
+    for (var _ref3 of Object.entries(this.limits)) {
+      var _ref2 = _slicedToArray(_ref3, 2);
+      var name = _ref2[0];
+      var value = _ref2[1];
+      if (!Number.isInteger(value) || value < (name === 'queueLimit' ? 0 : 1)) {
+        throw new RangeError('Invalid content request limits.');
+      }
+    }
+  }
+  run(invoke, signal) {
+    if (signal !== null && signal !== void 0 && signal.aborted) return Promise.reject(abortReason(signal));
+    return new Promise((_resolve, reject) => {
+      var task = {
+        invoke,
+        resolve: value => _resolve(value),
+        reject,
+        signal,
+        clearQueueWait: () => {}
+      };
+      if (this.active < this.limits.concurrency) {
+        this.start(task);
+        return;
+      }
+      if (this.queue.length >= this.limits.queueLimit) {
+        reject(new Error('Content request queue is full.'));
+        return;
+      }
+      var cancel = error => {
+        var index = this.queue.indexOf(task);
+        if (index < 0) return;
+        this.queue.splice(index, 1);
+        task.clearQueueWait();
+        reject(error);
+      };
+      var onAbort = () => cancel(abortReason(signal));
+      var timer = setTimeout(() => cancel(new Error('Content request queue wait timed out.')), this.limits.queueTimeout);
+      task.clearQueueWait = () => {
+        clearTimeout(timer);
+        signal === null || signal === void 0 || signal.removeEventListener('abort', onAbort);
+      };
+      signal === null || signal === void 0 || signal.addEventListener('abort', onAbort, {
+        once: true
+      });
+      this.queue.push(task);
+    });
+  }
+  start(task) {
+    var _task$signal2;
+    task.clearQueueWait();
+    this.active += 1;
+    var controller = new AbortController();
+    var rejectAbort = () => task.reject(abortReason(controller.signal));
+    var forwardAbort = () => {
+      var _task$signal;
+      return controller.abort((_task$signal = task.signal) === null || _task$signal === void 0 ? void 0 : _task$signal.reason);
+    };
+    controller.signal.addEventListener('abort', rejectAbort, {
+      once: true
+    });
+    (_task$signal2 = task.signal) === null || _task$signal2 === void 0 || _task$signal2.addEventListener('abort', forwardAbort, {
+      once: true
+    });
+    var timer = setTimeout(() => controller.abort(new Error('Content request timed out.')), this.limits.requestTimeout);
+    void Promise.resolve().then(() => {
+      if (controller.signal.aborted) throw abortReason(controller.signal);
+      return task.invoke(controller.signal);
+    }).then(value => {
+      if (!controller.signal.aborted) task.resolve(value);
+    }, task.reject).finally(() => {
+      var _task$signal3;
+      clearTimeout(timer);
+      controller.signal.removeEventListener('abort', rejectAbort);
+      (_task$signal3 = task.signal) === null || _task$signal3 === void 0 || _task$signal3.removeEventListener('abort', forwardAbort);
+      // A custom fetch that ignores abort keeps its slot until it really
+      // settles. Timeouts must not create unlimited overlapping requests.
+      this.active -= 1;
+      while (this.active < this.limits.concurrency && this.queue.length > 0) {
+        this.start(this.queue.shift());
+      }
+    });
+  }
+}
+var key = Symbol.for('@prezly/theme-kit-nextjs/content-fetch-scheduler/v1');
+var registry = globalThis;
+var sharedContentFetches = (_registry$key = registry[key]) !== null && _registry$key !== void 0 ? _registry$key : registry[key] = new FetchScheduler();
+export function createBoundedFetch(fetchImpl) {
+  var scheduler = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : sharedContentFetches;
+  return (input, init) => {
+    var _init$signal;
+    var signal = (_init$signal = init === null || init === void 0 ? void 0 : init.signal) !== null && _init$signal !== void 0 ? _init$signal : input instanceof Request ? input.signal : undefined;
+    return scheduler.run(/*#__PURE__*/function () {
+      var _ref4 = _asyncToGenerator(function* (requestSignal) {
+        var response = yield fetchImpl(input, _objectSpread(_objectSpread({}, init), {}, {
+          signal: requestSignal
+        }));
+        // Keep the deadline and slot through body consumption, not just headers.
+        // Only the internal content SDK uses this wrapper; the raw SDK is unchanged.
+        var body = response.body === null ? null : yield response.arrayBuffer();
+        return new Response(body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers
+        });
+      });
+      return function (_x) {
+        return _ref4.apply(this, arguments);
+      };
+    }(), signal);
+  };
+}

package/build/adapters/prezly/requests.test.cjs

@@ -0,0 +1,201 @@
+"use strict";
+
+var _nodeEvents = require("node:events");
+var _nodeHttp = require("node:http");
+var _requests = require("./requests.cjs");
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+function deferred() {
+  var resolve;
+  var promise = new Promise(yes => {
+    resolve = yes;
+  });
+  return {
+    promise,
+    resolve
+  };
+}
+var tick = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* () {
+    for (var i = 0; i < 10; i++) yield Promise.resolve();
+  });
+  return function tick() {
+    return _ref.apply(this, arguments);
+  };
+}();
+describe('Content HTTP admission', () => {
+  beforeEach(() => jest.useFakeTimers());
+  afterEach(() => jest.useRealTimers());
+  it('limits active work, serves queued work in order, and rejects overflow', /*#__PURE__*/_asyncToGenerator(function* () {
+    var scheduler = new _requests.FetchScheduler({
+      concurrency: 1,
+      queueLimit: 2
+    });
+    var first = deferred();
+    var started = [];
+    var a = scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      started.push(1);
+      return first.promise;
+    }));
+    var b = scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      started.push(2);
+      return 2;
+    }));
+    var c = scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      started.push(3);
+      return 3;
+    }));
+    var overflow = jest.fn(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 4;
+    }));
+    yield expect(scheduler.run(overflow)).rejects.toThrow('queue is full');
+    expect(started).toEqual([1]);
+    expect(overflow).not.toHaveBeenCalled();
+    first.resolve(1);
+    expect(yield Promise.all([a, b, c])).toEqual([1, 2, 3]);
+    expect(started).toEqual([1, 2, 3]);
+    yield tick();
+    expect(jest.getTimerCount()).toBe(0);
+  }));
+  it('removes expired and canceled queued work before it reaches the origin', /*#__PURE__*/_asyncToGenerator(function* () {
+    var scheduler = new _requests.FetchScheduler({
+      concurrency: 1,
+      queueLimit: 1
+    });
+    var first = deferred();
+    var a = scheduler.run(() => first.promise);
+    var queued = jest.fn(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 2;
+    }));
+    var expired = expect(scheduler.run(queued)).rejects.toThrow('queue wait timed out');
+    yield jest.advanceTimersByTimeAsync(1000);
+    yield expired;
+    var controller = new AbortController();
+    var canceled = expect(scheduler.run(queued, controller.signal)).rejects.toThrow('cancel');
+    controller.abort(new Error('cancel'));
+    yield canceled;
+    var recovered = scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 3;
+    }));
+    first.resolve(1);
+    expect(yield Promise.all([a, recovered])).toEqual([1, 3]);
+    expect(queued).not.toHaveBeenCalled();
+  }));
+  it('aborts a timed out transport and admits a subsequent retry', /*#__PURE__*/_asyncToGenerator(function* () {
+    var scheduler = new _requests.FetchScheduler({
+      concurrency: 1,
+      requestTimeout: 100
+    });
+    var signal;
+    var timedOut = expect(scheduler.run(s => {
+      signal = s;
+      return new Promise((_, reject) => s.addEventListener('abort', () => reject(s.reason)));
+    })).rejects.toThrow('timed out');
+    yield jest.advanceTimersByTimeAsync(100);
+    yield timedOut;
+    expect(signal.aborted).toBe(true);
+    expect(yield scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 'recovered';
+    }))).toBe('recovered');
+  }));
+  it('retains the physical slot if custom work ignores abort', /*#__PURE__*/_asyncToGenerator(function* () {
+    var scheduler = new _requests.FetchScheduler({
+      concurrency: 1,
+      queueLimit: 0,
+      requestTimeout: 100
+    });
+    var pending = deferred();
+    var timedOut = expect(scheduler.run(() => pending.promise)).rejects.toThrow('timed out');
+    yield jest.advanceTimersByTimeAsync(100);
+    yield timedOut;
+    yield expect(scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 2;
+    }))).rejects.toThrow('queue is full');
+    pending.resolve(1);
+    yield tick();
+    expect(yield scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 3;
+    }))).toBe(3);
+  }));
+  it('forwards active cancellation and never starts an already canceled call', /*#__PURE__*/_asyncToGenerator(function* () {
+    var scheduler = new _requests.FetchScheduler({
+      concurrency: 1
+    });
+    var controller = new AbortController();
+    var signal;
+    var canceled = expect(scheduler.run(s => {
+      signal = s;
+      return new Promise((_, reject) => s.addEventListener('abort', () => reject(s.reason)));
+    }, controller.signal)).rejects.toThrow('cancel');
+    yield tick();
+    controller.abort(new Error('cancel'));
+    yield canceled;
+    expect(signal.aborted).toBe(true);
+    var invoke = jest.fn(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 1;
+    }));
+    yield expect(scheduler.run(invoke, controller.signal)).rejects.toThrow('cancel');
+    expect(invoke).not.toHaveBeenCalled();
+    yield tick();
+    expect(yield scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 'ok';
+    }))).toBe('ok');
+  }));
+  it('keeps the deadline through response body consumption', /*#__PURE__*/_asyncToGenerator(function* () {
+    var scheduler = new _requests.FetchScheduler({
+      requestTimeout: 100
+    });
+    var transport = /*#__PURE__*/function () {
+      var _ref17 = _asyncToGenerator(function* (_input, init) {
+        return new Response(new ReadableStream({
+          start(controller) {
+            init.signal.addEventListener('abort', () => controller.error(init.signal.reason));
+          }
+        }));
+      });
+      return function transport(_x, _x2) {
+        return _ref17.apply(this, arguments);
+      };
+    }();
+    var bounded = (0, _requests.createBoundedFetch)(transport, scheduler);
+    var timedOut = expect(bounded('https://example.test')).rejects.toThrow('timed out');
+    yield jest.advanceTimersByTimeAsync(100);
+    yield timedOut;
+    var empty = (0, _requests.createBoundedFetch)(/*#__PURE__*/_asyncToGenerator(function* () {
+      return new Response(null, {
+        status: 204
+      });
+    }), scheduler);
+    expect((yield empty('https://example.test')).status).toBe(204);
+  }));
+});
+it('aborts a real HTTP response stalled after headers and then recovers', /*#__PURE__*/_asyncToGenerator(function* () {
+  jest.useRealTimers();
+  var server = (0, _nodeHttp.createServer)((request, response) => {
+    response.writeHead(200, {
+      'Content-Type': 'application/json'
+    });
+    if (request.url === '/stall') {
+      response.write('{');
+    } else {
+      response.end('{"ok":true}');
+    }
+  });
+  server.listen(0, '127.0.0.1');
+  yield (0, _nodeEvents.once)(server, 'listening');
+  var url = "http://127.0.0.1:".concat(server.address().port);
+  var fetch = (0, _requests.createBoundedFetch)(globalThis.fetch, new _requests.FetchScheduler({
+    concurrency: 1,
+    requestTimeout: 200
+  }));
+  try {
+    yield expect(fetch("".concat(url, "/stall"))).rejects.toThrow('timed out');
+    var result = yield fetch("".concat(url, "/ok"));
+    expect(yield result.json()).toEqual({
+      ok: true
+    });
+  } finally {
+    server.closeAllConnections();
+    yield new Promise(resolve => server.close(() => resolve()));
+  }
+}));

package/build/adapters/prezly/requests.test.mjs

@@ -0,0 +1,199 @@
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+import { once } from 'node:events';
+import { createServer } from 'node:http';
+import { createBoundedFetch, FetchScheduler } from "./requests.mjs";
+function deferred() {
+  var resolve;
+  var promise = new Promise(yes => {
+    resolve = yes;
+  });
+  return {
+    promise,
+    resolve
+  };
+}
+var tick = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* () {
+    for (var i = 0; i < 10; i++) yield Promise.resolve();
+  });
+  return function tick() {
+    return _ref.apply(this, arguments);
+  };
+}();
+describe('Content HTTP admission', () => {
+  beforeEach(() => jest.useFakeTimers());
+  afterEach(() => jest.useRealTimers());
+  it('limits active work, serves queued work in order, and rejects overflow', /*#__PURE__*/_asyncToGenerator(function* () {
+    var scheduler = new FetchScheduler({
+      concurrency: 1,
+      queueLimit: 2
+    });
+    var first = deferred();
+    var started = [];
+    var a = scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      started.push(1);
+      return first.promise;
+    }));
+    var b = scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      started.push(2);
+      return 2;
+    }));
+    var c = scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      started.push(3);
+      return 3;
+    }));
+    var overflow = jest.fn(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 4;
+    }));
+    yield expect(scheduler.run(overflow)).rejects.toThrow('queue is full');
+    expect(started).toEqual([1]);
+    expect(overflow).not.toHaveBeenCalled();
+    first.resolve(1);
+    expect(yield Promise.all([a, b, c])).toEqual([1, 2, 3]);
+    expect(started).toEqual([1, 2, 3]);
+    yield tick();
+    expect(jest.getTimerCount()).toBe(0);
+  }));
+  it('removes expired and canceled queued work before it reaches the origin', /*#__PURE__*/_asyncToGenerator(function* () {
+    var scheduler = new FetchScheduler({
+      concurrency: 1,
+      queueLimit: 1
+    });
+    var first = deferred();
+    var a = scheduler.run(() => first.promise);
+    var queued = jest.fn(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 2;
+    }));
+    var expired = expect(scheduler.run(queued)).rejects.toThrow('queue wait timed out');
+    yield jest.advanceTimersByTimeAsync(1000);
+    yield expired;
+    var controller = new AbortController();
+    var canceled = expect(scheduler.run(queued, controller.signal)).rejects.toThrow('cancel');
+    controller.abort(new Error('cancel'));
+    yield canceled;
+    var recovered = scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 3;
+    }));
+    first.resolve(1);
+    expect(yield Promise.all([a, recovered])).toEqual([1, 3]);
+    expect(queued).not.toHaveBeenCalled();
+  }));
+  it('aborts a timed out transport and admits a subsequent retry', /*#__PURE__*/_asyncToGenerator(function* () {
+    var scheduler = new FetchScheduler({
+      concurrency: 1,
+      requestTimeout: 100
+    });
+    var signal;
+    var timedOut = expect(scheduler.run(s => {
+      signal = s;
+      return new Promise((_, reject) => s.addEventListener('abort', () => reject(s.reason)));
+    })).rejects.toThrow('timed out');
+    yield jest.advanceTimersByTimeAsync(100);
+    yield timedOut;
+    expect(signal.aborted).toBe(true);
+    expect(yield scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 'recovered';
+    }))).toBe('recovered');
+  }));
+  it('retains the physical slot if custom work ignores abort', /*#__PURE__*/_asyncToGenerator(function* () {
+    var scheduler = new FetchScheduler({
+      concurrency: 1,
+      queueLimit: 0,
+      requestTimeout: 100
+    });
+    var pending = deferred();
+    var timedOut = expect(scheduler.run(() => pending.promise)).rejects.toThrow('timed out');
+    yield jest.advanceTimersByTimeAsync(100);
+    yield timedOut;
+    yield expect(scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 2;
+    }))).rejects.toThrow('queue is full');
+    pending.resolve(1);
+    yield tick();
+    expect(yield scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 3;
+    }))).toBe(3);
+  }));
+  it('forwards active cancellation and never starts an already canceled call', /*#__PURE__*/_asyncToGenerator(function* () {
+    var scheduler = new FetchScheduler({
+      concurrency: 1
+    });
+    var controller = new AbortController();
+    var signal;
+    var canceled = expect(scheduler.run(s => {
+      signal = s;
+      return new Promise((_, reject) => s.addEventListener('abort', () => reject(s.reason)));
+    }, controller.signal)).rejects.toThrow('cancel');
+    yield tick();
+    controller.abort(new Error('cancel'));
+    yield canceled;
+    expect(signal.aborted).toBe(true);
+    var invoke = jest.fn(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 1;
+    }));
+    yield expect(scheduler.run(invoke, controller.signal)).rejects.toThrow('cancel');
+    expect(invoke).not.toHaveBeenCalled();
+    yield tick();
+    expect(yield scheduler.run(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 'ok';
+    }))).toBe('ok');
+  }));
+  it('keeps the deadline through response body consumption', /*#__PURE__*/_asyncToGenerator(function* () {
+    var scheduler = new FetchScheduler({
+      requestTimeout: 100
+    });
+    var transport = /*#__PURE__*/function () {
+      var _ref17 = _asyncToGenerator(function* (_input, init) {
+        return new Response(new ReadableStream({
+          start(controller) {
+            init.signal.addEventListener('abort', () => controller.error(init.signal.reason));
+          }
+        }));
+      });
+      return function transport(_x, _x2) {
+        return _ref17.apply(this, arguments);
+      };
+    }();
+    var bounded = createBoundedFetch(transport, scheduler);
+    var timedOut = expect(bounded('https://example.test')).rejects.toThrow('timed out');
+    yield jest.advanceTimersByTimeAsync(100);
+    yield timedOut;
+    var empty = createBoundedFetch(/*#__PURE__*/_asyncToGenerator(function* () {
+      return new Response(null, {
+        status: 204
+      });
+    }), scheduler);
+    expect((yield empty('https://example.test')).status).toBe(204);
+  }));
+});
+it('aborts a real HTTP response stalled after headers and then recovers', /*#__PURE__*/_asyncToGenerator(function* () {
+  jest.useRealTimers();
+  var server = createServer((request, response) => {
+    response.writeHead(200, {
+      'Content-Type': 'application/json'
+    });
+    if (request.url === '/stall') {
+      response.write('{');
+    } else {
+      response.end('{"ok":true}');
+    }
+  });
+  server.listen(0, '127.0.0.1');
+  yield once(server, 'listening');
+  var url = "http://127.0.0.1:".concat(server.address().port);
+  var fetch = createBoundedFetch(globalThis.fetch, new FetchScheduler({
+    concurrency: 1,
+    requestTimeout: 200
+  }));
+  try {
+    yield expect(fetch("".concat(url, "/stall"))).rejects.toThrow('timed out');
+    var result = yield fetch("".concat(url, "/ok"));
+    expect(yield result.json()).toEqual({
+      ok: true
+    });
+  } finally {
+    server.closeAllConnections();
+    yield new Promise(resolve => server.close(() => resolve()));
+  }
+}));

package/build/adapters/prezly/server.cjs

@@ -4,9 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.PrezlyAdapter = void 0;
+var _sha = require("@noble/hashes/sha256");
+var _utils = require("@noble/hashes/utils");
+var _jsonStableStringify = _interopRequireDefault(require("json-stable-stringify"));
 var _sdk = require("@prezly/sdk");
 var _themeKitCore = require("@prezly/theme-kit-core");
 var _index = require("./cache/index.cjs");
+var _requests = require("./requests.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
@@ -15,32 +20,51 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
 var PrezlyAdapter;
 (function (_PrezlyAdapter) {
   function connect(config) {
-    var {
-      cache: cacheConfig,
-      fetch
-    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      cacheConfig = _ref.cache,
+      fetch = _ref.fetch;
     function usePrezlyClient() {
-      var {
-        // sdk client properties
-        accessToken,
-        baseUrl,
-        headers,
-        // contentDelivery client properties
-        newsroom,
-        theme,
-        formats
-      } = _themeKitCore.Resolvable.resolve(config);
+      var _cacheConfig$namespac, _cacheConfig$memory;
+      var _Resolvable$resolve = _themeKitCore.Resolvable.resolve(config),
+        accessToken = _Resolvable$resolve.accessToken,
+        baseUrl = _Resolvable$resolve.baseUrl,
+        headers = _Resolvable$resolve.headers,
+        newsroom = _Resolvable$resolve.newsroom,
+        theme = _Resolvable$resolve.theme,
+        formats = _Resolvable$resolve.formats;
       var client = (0, _sdk.createPrezlyClient)({
         fetch,
         accessToken,
         baseUrl,
         headers
       });
-      var contentDelivery = _themeKitCore.ContentDelivery.createClient(client, newsroom, theme, {
+      var cache = cacheConfig ? (0, _index.configure)(_objectSpread({
+        namespace: 'content:'
+      }, cacheConfig)) : undefined;
+      // Custom fetches may depend on hidden request context. Preserve their
+      // existing cache behavior unless the caller declares that identity.
+      var scope = cache && (!fetch || (cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.requestScope) !== undefined) ? (0, _utils.bytesToHex)((0, _sha.sha256)((0, _jsonStableStringify.default)({
+        baseUrl: baseUrl !== null && baseUrl !== void 0 ? baseUrl : 'https://api.prezly.com',
+        accessToken,
+        headers: headers !== null && headers !== void 0 ? headers : {},
+        cache: {
+          namespace: (_cacheConfig$namespac = cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.namespace) !== null && _cacheConfig$namespac !== void 0 ? _cacheConfig$namespac : 'content:',
+          memory: (_cacheConfig$memory = cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.memory) !== null && _cacheConfig$memory !== void 0 ? _cacheConfig$memory : false,
+          redis: cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.redis
+        },
+        requestScope: cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.requestScope
+      }))) : undefined;
+      var contentClient = cache ? (0, _sdk.createPrezlyClient)({
+        accessToken,
+        baseUrl,
+        headers,
+        fetch: (0, _requests.createBoundedFetch)(fetch !== null && fetch !== void 0 ? fetch : globalThis.fetch)
+      }) : client;
+      var contentDelivery = _themeKitCore.ContentDelivery.createClient(contentClient, newsroom, theme, {
         formats,
-        cache: cacheConfig ? (0, _index.configure)(_objectSpread({
-          namespace: 'content:'
-        }, cacheConfig)) : undefined
+        cache: cache ? _objectSpread(_objectSpread({}, cache), {}, {
+          scope
+        }) : undefined
       });
       return {
         client,