@prezly/theme-kit-nextjs 10.9.0 → 10.9.1

package/build/adapters/prezly/cache/redis.cjs

@@ -8,52 +8,84 @@ var _jsonStableStringify = _interopRequireDefault(require("json-stable-stringify
 var _redis = require("redis");
 var _excluded = ["ttl", "prefix"];
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-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 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 _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
 function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+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); }); }; }
+var COMMAND_TIMEOUT = 1000;
 var CONNECTIONS = new Map();
+function command(_x) {
+  return _command.apply(this, arguments);
+}
+function _command() {
+  _command = _asyncToGenerator(function* (invoke) {
+    var timer;
+    try {
+      // node-redis 4 can corrupt its command queue when aborting a command
+      // already sent to the socket. Leave that operation tracked by the client;
+      // commandsQueueMaxLength bounds all outstanding replies, including these.
+      return yield Promise.race([Promise.resolve().then(invoke), new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error('Content cache command timed out.')), COMMAND_TIMEOUT);
+      })]);
+    } finally {
+      clearTimeout(timer);
+    }
+  });
+  return _command.apply(this, arguments);
+}
 function createRedisCache(_ref) {
-  var _CONNECTIONS$get;
-  var {
-      ttl,
-      prefix = ''
-    } = _ref,
+  var ttl = _ref.ttl,
+    _ref$prefix = _ref.prefix,
+    prefix = _ref$prefix === void 0 ? '' : _ref$prefix,
     options = _objectWithoutProperties(_ref, _excluded);
   var connectionKey = (0, _jsonStableStringify.default)(options);
-  var connection = (_CONNECTIONS$get = CONNECTIONS.get(connectionKey)) !== null && _CONNECTIONS$get !== void 0 ? _CONNECTIONS$get : (0, _redis.createClient)(options).on('error', error => console.error(error)).connect();
-  CONNECTIONS.set(connectionKey, connection);
+  var client = CONNECTIONS.get(connectionKey);
+  if (!client) {
+    client = (0, _redis.createClient)(_objectSpread(_objectSpread({}, options), {}, {
+      // Do not accumulate application commands during a disconnected period.
+      disableOfflineQueue: true,
+      commandsQueueMaxLength: 128,
+      socket: _objectSpread(_objectSpread({}, options.socket), {}, {
+        connectTimeout: 1000
+      })
+    })).on('error', error => console.error(error));
+    CONNECTIONS.set(connectionKey, client);
+    // Reconnection belongs to this one shared client. Requests never wait on
+    // its potentially long-lived connection promise when Redis is unavailable.
+    void client.connect().catch(() => undefined);
+  }
+  var connection = client;
   function createCache() {
     var namespacePrefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
     return {
       get(key, latestVersion) {
         return _asyncToGenerator(function* () {
-          var client = yield connection;
-          var cached = yield client.get("".concat(namespacePrefix).concat(key));
-          if (!cached) {
-            return undefined;
-          }
+          if (!connection.isReady) return undefined;
+          var cached = yield command(() => connection.get("".concat(namespacePrefix).concat(key)));
+          if (!cached) return undefined;
           var entry = JSON.parse(cached);
-          if (entry.version < latestVersion) {
-            // the entry is stale and cannot be used anymore
-            return undefined;
-          }
+          if (entry.version < latestVersion) return undefined;
           if (ttl) {
-            client.expire("".concat(namespacePrefix).concat(key), ttl); // bump TTL on entries access
+            void command(() => connection.expire("".concat(namespacePrefix).concat(key), ttl)).catch(() => undefined);
           }
           return entry.value;
         })();
       },
       set(key, value, version) {
         return _asyncToGenerator(function* () {
-          var client = yield connection;
+          if (!connection.isReady) return;
           var entry = {
             value,
             version
           };
-          yield client.set("".concat(namespacePrefix).concat(key), JSON.stringify(entry), {
+          yield command(() => connection.set("".concat(namespacePrefix).concat(key), JSON.stringify(entry), {
             EX: ttl
-          });
+          }));
         })();
       },
       namespace(namespace) {

package/build/adapters/prezly/cache/redis.mjs

@@ -1,52 +1,84 @@
 var _excluded = ["ttl", "prefix"];
-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 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 _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
 function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+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 stableStringify from 'json-stable-stringify';
 import { createClient } from 'redis';
+var COMMAND_TIMEOUT = 1000;
 var CONNECTIONS = new Map();
+function command(_x) {
+  return _command.apply(this, arguments);
+}
+function _command() {
+  _command = _asyncToGenerator(function* (invoke) {
+    var timer;
+    try {
+      // node-redis 4 can corrupt its command queue when aborting a command
+      // already sent to the socket. Leave that operation tracked by the client;
+      // commandsQueueMaxLength bounds all outstanding replies, including these.
+      return yield Promise.race([Promise.resolve().then(invoke), new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error('Content cache command timed out.')), COMMAND_TIMEOUT);
+      })]);
+    } finally {
+      clearTimeout(timer);
+    }
+  });
+  return _command.apply(this, arguments);
+}
 export function createRedisCache(_ref) {
-  var _CONNECTIONS$get;
-  var {
-      ttl,
-      prefix = ''
-    } = _ref,
+  var ttl = _ref.ttl,
+    _ref$prefix = _ref.prefix,
+    prefix = _ref$prefix === void 0 ? '' : _ref$prefix,
     options = _objectWithoutProperties(_ref, _excluded);
   var connectionKey = stableStringify(options);
-  var connection = (_CONNECTIONS$get = CONNECTIONS.get(connectionKey)) !== null && _CONNECTIONS$get !== void 0 ? _CONNECTIONS$get : createClient(options).on('error', error => console.error(error)).connect();
-  CONNECTIONS.set(connectionKey, connection);
+  var client = CONNECTIONS.get(connectionKey);
+  if (!client) {
+    client = createClient(_objectSpread(_objectSpread({}, options), {}, {
+      // Do not accumulate application commands during a disconnected period.
+      disableOfflineQueue: true,
+      commandsQueueMaxLength: 128,
+      socket: _objectSpread(_objectSpread({}, options.socket), {}, {
+        connectTimeout: 1000
+      })
+    })).on('error', error => console.error(error));
+    CONNECTIONS.set(connectionKey, client);
+    // Reconnection belongs to this one shared client. Requests never wait on
+    // its potentially long-lived connection promise when Redis is unavailable.
+    void client.connect().catch(() => undefined);
+  }
+  var connection = client;
   function createCache() {
     var namespacePrefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
     return {
       get(key, latestVersion) {
         return _asyncToGenerator(function* () {
-          var client = yield connection;
-          var cached = yield client.get("".concat(namespacePrefix).concat(key));
-          if (!cached) {
-            return undefined;
-          }
+          if (!connection.isReady) return undefined;
+          var cached = yield command(() => connection.get("".concat(namespacePrefix).concat(key)));
+          if (!cached) return undefined;
           var entry = JSON.parse(cached);
-          if (entry.version < latestVersion) {
-            // the entry is stale and cannot be used anymore
-            return undefined;
-          }
+          if (entry.version < latestVersion) return undefined;
           if (ttl) {
-            client.expire("".concat(namespacePrefix).concat(key), ttl); // bump TTL on entries access
+            void command(() => connection.expire("".concat(namespacePrefix).concat(key), ttl)).catch(() => undefined);
           }
           return entry.value;
         })();
       },
       set(key, value, version) {
         return _asyncToGenerator(function* () {
-          var client = yield connection;
+          if (!connection.isReady) return;
           var entry = {
             value,
             version
           };
-          yield client.set("".concat(namespacePrefix).concat(key), JSON.stringify(entry), {
+          yield command(() => connection.set("".concat(namespacePrefix).concat(key), JSON.stringify(entry), {
             EX: ttl
-          });
+          }));
         })();
       },
       namespace(namespace) {

package/build/adapters/prezly/cache/redis.test.cjs

@@ -0,0 +1,103 @@
+"use strict";
+
+var _redis = require("redis");
+var _redis2 = require("./redis.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); }); }; }
+jest.mock('redis', () => ({
+  createClient: jest.fn()
+}));
+var sequence = 0;
+function connection() {
+  var ready = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  var client = {
+    isReady: ready,
+    on: jest.fn().mockReturnThis(),
+    connect: jest.fn(() => ready ? Promise.resolve(undefined) : new Promise(() => {})),
+    get: jest.fn(/*#__PURE__*/_asyncToGenerator(function* () {
+      return JSON.stringify({
+        version: 2,
+        value: 'cached'
+      });
+    })),
+    set: jest.fn(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 'OK';
+    })),
+    expire: jest.fn(/*#__PURE__*/_asyncToGenerator(function* () {
+      return true;
+    }))
+  };
+  _redis.createClient.mockReturnValue(client);
+  var options = {
+    url: "redis://test-".concat(sequence++, ":6379"),
+    ttl: 300,
+    prefix: 'test:'
+  };
+  return {
+    client,
+    options,
+    cache: (0, _redis2.createRedisCache)(options)
+  };
+}
+afterEach(() => jest.useRealTimers());
+it('fails open while disconnected without waiting for connection establishment', /*#__PURE__*/_asyncToGenerator(function* () {
+  var _connection = connection(false),
+    client = _connection.client,
+    cache = _connection.cache,
+    options = _connection.options;
+  expect(yield cache.get('key', 1)).toBeUndefined();
+  yield cache.set('key', 'value', 1);
+  expect(client.get).not.toHaveBeenCalled();
+  expect(client.set).not.toHaveBeenCalled();
+  (0, _redis2.createRedisCache)(options);
+  expect(client.connect).toHaveBeenCalledTimes(1);
+  expect(_redis.createClient).toHaveBeenLastCalledWith(expect.objectContaining({
+    disableOfflineQueue: true,
+    commandsQueueMaxLength: 128,
+    socket: expect.objectContaining({
+      connectTimeout: 1000
+    })
+  }));
+  client.isReady = true;
+  expect(yield cache.get('key', 1)).toBe('cached');
+}));
+it('preserves namespace, version and sliding expiry and observes expiry rejection', /*#__PURE__*/_asyncToGenerator(function* () {
+  var _connection2 = connection(),
+    client = _connection2.client,
+    cache = _connection2.cache;
+  client.expire.mockRejectedValueOnce(new Error('expiry failed'));
+  expect(yield cache.namespace('room').get('key', 2)).toBe('cached');
+  expect(client.get).toHaveBeenLastCalledWith('test:room:key');
+  expect(yield cache.get('key', 3)).toBeUndefined();
+  expect(client.expire).toHaveBeenCalledTimes(1);
+  yield cache.set('key', 'updated', 3);
+  expect(client.set).toHaveBeenLastCalledWith('test:key', JSON.stringify({
+    value: 'updated',
+    version: 3
+  }), {
+    EX: 300
+  });
+}));
+it.each(['get', 'set'])('times out stalled %s commands without unsafe cancellation and recovers', /*#__PURE__*/function () {
+  var _ref6 = _asyncToGenerator(function* (method) {
+    jest.useFakeTimers();
+    var _connection3 = connection(),
+      client = _connection3.client,
+      cache = _connection3.cache;
+    var rejectOperation;
+    client[method].mockImplementationOnce(() => new Promise((_, reject) => {
+      rejectOperation = reject;
+    }));
+    var pending = method === 'get' ? cache.get('key', 1) : cache.set('key', 'value', 1);
+    var failed = expect(pending).rejects.toThrow('timed out');
+    yield jest.advanceTimersByTimeAsync(1000);
+    yield failed;
+    rejectOperation(new Error('late failure'));
+    expect(yield cache.get('key', 1)).toBe('cached');
+    yield jest.advanceTimersByTimeAsync(0);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+  return function (_x) {
+    return _ref6.apply(this, arguments);
+  };
+}());

package/build/adapters/prezly/cache/redis.test.mjs

@@ -0,0 +1,101 @@
+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 { createClient } from 'redis';
+import { createRedisCache } from "./redis.mjs";
+jest.mock('redis', () => ({
+  createClient: jest.fn()
+}));
+var sequence = 0;
+function connection() {
+  var ready = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  var client = {
+    isReady: ready,
+    on: jest.fn().mockReturnThis(),
+    connect: jest.fn(() => ready ? Promise.resolve(undefined) : new Promise(() => {})),
+    get: jest.fn(/*#__PURE__*/_asyncToGenerator(function* () {
+      return JSON.stringify({
+        version: 2,
+        value: 'cached'
+      });
+    })),
+    set: jest.fn(/*#__PURE__*/_asyncToGenerator(function* () {
+      return 'OK';
+    })),
+    expire: jest.fn(/*#__PURE__*/_asyncToGenerator(function* () {
+      return true;
+    }))
+  };
+  createClient.mockReturnValue(client);
+  var options = {
+    url: "redis://test-".concat(sequence++, ":6379"),
+    ttl: 300,
+    prefix: 'test:'
+  };
+  return {
+    client,
+    options,
+    cache: createRedisCache(options)
+  };
+}
+afterEach(() => jest.useRealTimers());
+it('fails open while disconnected without waiting for connection establishment', /*#__PURE__*/_asyncToGenerator(function* () {
+  var _connection = connection(false),
+    client = _connection.client,
+    cache = _connection.cache,
+    options = _connection.options;
+  expect(yield cache.get('key', 1)).toBeUndefined();
+  yield cache.set('key', 'value', 1);
+  expect(client.get).not.toHaveBeenCalled();
+  expect(client.set).not.toHaveBeenCalled();
+  createRedisCache(options);
+  expect(client.connect).toHaveBeenCalledTimes(1);
+  expect(createClient).toHaveBeenLastCalledWith(expect.objectContaining({
+    disableOfflineQueue: true,
+    commandsQueueMaxLength: 128,
+    socket: expect.objectContaining({
+      connectTimeout: 1000
+    })
+  }));
+  client.isReady = true;
+  expect(yield cache.get('key', 1)).toBe('cached');
+}));
+it('preserves namespace, version and sliding expiry and observes expiry rejection', /*#__PURE__*/_asyncToGenerator(function* () {
+  var _connection2 = connection(),
+    client = _connection2.client,
+    cache = _connection2.cache;
+  client.expire.mockRejectedValueOnce(new Error('expiry failed'));
+  expect(yield cache.namespace('room').get('key', 2)).toBe('cached');
+  expect(client.get).toHaveBeenLastCalledWith('test:room:key');
+  expect(yield cache.get('key', 3)).toBeUndefined();
+  expect(client.expire).toHaveBeenCalledTimes(1);
+  yield cache.set('key', 'updated', 3);
+  expect(client.set).toHaveBeenLastCalledWith('test:key', JSON.stringify({
+    value: 'updated',
+    version: 3
+  }), {
+    EX: 300
+  });
+}));
+it.each(['get', 'set'])('times out stalled %s commands without unsafe cancellation and recovers', /*#__PURE__*/function () {
+  var _ref6 = _asyncToGenerator(function* (method) {
+    jest.useFakeTimers();
+    var _connection3 = connection(),
+      client = _connection3.client,
+      cache = _connection3.cache;
+    var rejectOperation;
+    client[method].mockImplementationOnce(() => new Promise((_, reject) => {
+      rejectOperation = reject;
+    }));
+    var pending = method === 'get' ? cache.get('key', 1) : cache.set('key', 'value', 1);
+    var failed = expect(pending).rejects.toThrow('timed out');
+    yield jest.advanceTimersByTimeAsync(1000);
+    yield failed;
+    rejectOperation(new Error('late failure'));
+    expect(yield cache.get('key', 1)).toBe('cached');
+    yield jest.advanceTimersByTimeAsync(0);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+  return function (_x) {
+    return _ref6.apply(this, arguments);
+  };
+}());

package/build/adapters/prezly/requests.cjs

@@ -0,0 +1,152 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FetchScheduler = void 0;
+exports.createBoundedFetch = createBoundedFetch;
+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. */
+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());
+      }
+    });
+  }
+}
+exports.FetchScheduler = FetchScheduler;
+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();
+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.d.ts

@@ -0,0 +1,17 @@
+interface Limits {
+    concurrency: number;
+    queueLimit: number;
+    queueTimeout: number;
+    requestTimeout: number;
+}
+/** Limit actual HTTP requests, not aggregate ContentDelivery methods. */
+export declare class FetchScheduler {
+    private active;
+    private readonly queue;
+    private readonly limits;
+    constructor(limits?: Partial<Limits>);
+    run<T>(invoke: (signal: AbortSignal) => Promise<T>, signal?: AbortSignal | null): Promise<T>;
+    private start;
+}
+export declare function createBoundedFetch(fetchImpl: typeof fetch, scheduler?: FetchScheduler): typeof fetch;
+export {};