@prezly/theme-kit-core 7.1.0 → 8.0.1

package/build/content-delivery/ContentDelivery.mjs

@@ -0,0 +1,342 @@
+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(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(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 asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+import { ApiError, Category, NewsroomGallery, SortOrder, Stories, Story } from '@prezly/sdk';
+export var stories;
+export var allStories;
+export var story;
+export var galleries;
+/**
+ * Sort order to list stories chronologically, with pinned stories on top.
+ */
+var CHRONOLOGICALLY = SortOrder.combine(SortOrder.desc('is_pinned'), SortOrder.desc('published_at'));
+
+/**
+ * Do not cache these methods, as they are derivatives of other cached methods.
+ */
+var UNCACHED_METHODS = ['themeSettings', 'language', 'usedLanguages', 'locales', 'defaultLanguage', 'defaultLocale', 'languageOrDefault', 'companyInformation', 'notifications', 'category', 'translatedCategory', 'translatedCategories'];
+export function createClient(prezly, newsroomUuid, newsroomThemeUuid) {
+  var {
+    formats = [Story.FormatVersion.SLATEJS_V4],
+    cache
+  } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var client = {
+    newsroom() {
+      return prezly.newsrooms.get(newsroomUuid);
+    },
+    theme() {
+      return newsroomThemeUuid ? prezly.newsroomThemes.get(newsroomUuid, newsroomThemeUuid) : undefined;
+    },
+    themeSettings() {
+      return _asyncToGenerator(function* () {
+        var theme = yield client.theme();
+        return theme === null || theme === void 0 ? void 0 : theme.settings;
+      })();
+    },
+    languages() {
+      return prezly.newsroomLanguages.list(newsroomUuid).then(data => data.languages);
+    },
+    usedLanguages() {
+      return _asyncToGenerator(function* () {
+        var languages = yield client.languages();
+        return languages.filter(lang => lang.public_stories_count > 0);
+      })();
+    },
+    locales() {
+      return _asyncToGenerator(function* () {
+        var languages = yield client.languages();
+        return languages.map(lang => lang.code);
+      })();
+    },
+    defaultLanguage() {
+      return _asyncToGenerator(function* () {
+        var languages = yield client.languages();
+        var defaultLanguage = languages.find(lang => lang.is_default);
+        if (!defaultLanguage) {
+          throw new Error('A newsroom is expected to always have a default language. Something is wrong.');
+        }
+        return defaultLanguage;
+      })();
+    },
+    companyInformation(code) {
+      return _asyncToGenerator(function* () {
+        var languageSettings = code ? yield client.languageOrDefault(code) : yield client.defaultLanguage();
+        return languageSettings.company_information;
+      })();
+    },
+    notifications(locale) {
+      return _asyncToGenerator(function* () {
+        var languageSettings = yield client.languageOrDefault(locale);
+        return languageSettings.notifications;
+      })();
+    },
+    defaultLocale() {
+      return _asyncToGenerator(function* () {
+        var defaultLanguage = yield client.defaultLanguage();
+        return defaultLanguage.code;
+      })();
+    },
+    language(code) {
+      return _asyncToGenerator(function* () {
+        var languages = yield client.languages();
+        return languages.find(lang => !code && lang.is_default || lang.locale.code === code);
+      })();
+    },
+    languageOrDefault(code) {
+      return _asyncToGenerator(function* () {
+        var _yield$client$languag;
+        return (_yield$client$languag = yield client.language(code)) !== null && _yield$client$languag !== void 0 ? _yield$client$languag : yield client.defaultLanguage();
+      })();
+    },
+    categories() {
+      return prezly.newsroomCategories.list(newsroomUuid, {
+        sortOrder: '+order'
+      });
+    },
+    category(arg) {
+      return _asyncToGenerator(function* () {
+        var categories = yield client.categories();
+        if (typeof arg === 'number') {
+          return categories.find(category => category.id === arg);
+        }
+        return categories.find(category => Category.translations(category).some(translation => translation.slug === arg));
+      })();
+    },
+    translatedCategories(locale, categories) {
+      return _asyncToGenerator(function* () {
+        return Category.translations(categories !== null && categories !== void 0 ? categories : yield client.categories(), locale);
+      })();
+    },
+    translatedCategory(locale, slug) {
+      return _asyncToGenerator(function* () {
+        var translations = yield client.translatedCategories(locale);
+        return translations.find(category => category.slug === slug);
+      })();
+    },
+    featuredContacts() {
+      return prezly.newsroomContacts.search(newsroomUuid, {
+        query: {
+          is_featured: true
+        }
+      });
+    },
+    galleries() {
+      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var {
+        offset,
+        limit,
+        type
+      } = params;
+      return prezly.newsroomGalleries.search(newsroomUuid, {
+        limit,
+        offset,
+        scope: {
+          status: NewsroomGallery.Status.PUBLIC,
+          is_empty: false,
+          type
+        }
+      });
+    },
+    gallery(uuid) {
+      return _asyncToGenerator(function* () {
+        try {
+          return yield prezly.newsroomGalleries.get(newsroomUuid, uuid);
+        } catch (error) {
+          if (error instanceof ApiError && isNotAvailableError(error)) {
+            return null;
+          }
+          throw error;
+        }
+      })();
+    },
+    stories(params) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var {
+        search,
+        query,
+        offset = 0,
+        limit,
+        category,
+        locale,
+        highlighted = 0
+      } = params;
+      var {
+        include = []
+      } = options;
+      var localeCode = locale && typeof locale === 'object' ? locale.code : locale;
+      return prezly.stories.search({
+        sortOrder: CHRONOLOGICALLY,
+        formats,
+        limit: offset === 0 ? limit + highlighted : limit,
+        offset: offset > 0 ? offset + highlighted : offset,
+        search,
+        query: mergeQueries(query, {
+          ["category.id"]: category ? {
+            $any: [category.id]
+          } : undefined,
+          ["newsroom.uuid"]: {
+            $in: [newsroomUuid]
+          },
+          ["locale"]: localeCode ? {
+            $in: [localeCode]
+          } : undefined,
+          ["status"]: {
+            $in: [Story.Status.PUBLISHED]
+          },
+          ["visibility"]: {
+            $in: [Story.Visibility.PUBLIC]
+          }
+        }),
+        include
+      });
+    },
+    allStories() {
+      var _arguments = arguments;
+      return _asyncToGenerator(function* () {
+        var params = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : {};
+        var options = _arguments.length > 1 && _arguments[1] !== undefined ? _arguments[1] : {};
+        var {
+          include = []
+        } = options;
+        var newsroom = yield client.newsroom();
+        var chunkSize = 200;
+
+        // Note: This is a counter of ALL stories, public, private, or drafts.
+        //       Depending on the specific newsroom data, the rate of overfetching may be significant.
+        var maxStories = newsroom.stories_number;
+        var pages = Math.ceil(maxStories / chunkSize);
+        var promises = Array.from({
+          length: pages
+        }, (_, chunkIndex) => client.stories(_objectSpread(_objectSpread({}, params), {}, {
+          limit: chunkSize,
+          offset: chunkIndex * chunkSize
+        }), {
+          include
+        }));
+        return (yield Promise.all(promises)).flatMap(response => response.stories);
+      })();
+    },
+    story(params) {
+      var _arguments2 = arguments;
+      return _asyncToGenerator(function* () {
+        var options = _arguments2.length > 1 && _arguments2[1] !== undefined ? _arguments2[1] : {};
+        var {
+          include = []
+        } = options;
+        if (params.uuid) {
+          try {
+            return yield prezly.stories.get(params.uuid, {
+              formats,
+              include: [...Stories.EXTENDED_STORY_INCLUDED_EXTRA_FIELDS, ...include]
+            });
+          } catch (error) {
+            if (error instanceof ApiError && isNotAvailableError(error)) {
+              return null;
+            }
+            throw error;
+          }
+        }
+        try {
+          return yield prezly.stories.getBySlug(params.slug, {
+            formats,
+            query: {
+              ["newsroom.uuid"]: {
+                $in: [newsroomUuid]
+              },
+              ["status"]: {
+                $in: [Story.Status.PUBLISHED, Story.Status.EMBARGO]
+              },
+              ["visibility"]: {
+                $in: [Story.Visibility.PUBLIC, Story.Visibility.PRIVATE, Story.Visibility.EMBARGO]
+              }
+            },
+            include: [...Stories.EXTENDED_STORY_INCLUDED_EXTRA_FIELDS, ...include]
+          });
+        } catch (error) {
+          if (error instanceof ApiError && isNotAvailableError(error)) {
+            return null;
+          }
+          throw error;
+        }
+      })();
+    }
+  };
+  if (cache) {
+    injectCache(client, cache.storage.namespace("".concat(newsroomUuid, ":").concat(newsroomThemeUuid, ":").concat(formats.join(','), ":")), cache.latestVersion, UNCACHED_METHODS);
+  }
+  return client;
+}
+function injectCache(client, cache, latestVersion) {
+  var uncachedMethods = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  var methodCalls = new Map();
+  var methodNames = Object.keys(client);
+  methodNames.forEach(methodName => {
+    if (uncachedMethods.includes(methodName)) {
+      // Do not cache this method.
+      return;
+    }
+    var uncachedFn = client[methodName].bind(client);
+
+    // eslint-disable-next-line no-param-reassign
+    client[methodName] = /*#__PURE__*/_asyncToGenerator(function* () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      var cacheKey = "".concat(methodName, ":").concat(JSON.stringify(args));
+      var dedupeKey = "".concat(latestVersion, ":").concat(cacheKey);
+
+      // Dedupe requests
+      var pending = methodCalls.get(dedupeKey);
+      if (pending) return pending;
+      function invoke() {
+        return _invoke.apply(this, arguments);
+      }
+      function _invoke() {
+        _invoke = _asyncToGenerator(function* () {
+          var cached = yield cache.get(cacheKey, latestVersion);
+          if (cached) return cached;
+          var value = yield uncachedFn(...args);
+          cache.set(cacheKey, value, latestVersion);
+          methodCalls.delete(dedupeKey);
+          return value;
+        });
+        return _invoke.apply(this, arguments);
+      }
+      var invokation = invoke();
+      methodCalls.set(dedupeKey, invokation);
+      return invokation;
+    });
+  });
+}
+function mergeQueries() {
+  for (var _len2 = arguments.length, queries = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    queries[_key2] = arguments[_key2];
+  }
+  var queryObjects = queries.filter(query => Boolean(query)).map(query => {
+    if (typeof query === 'string') {
+      return JSON.parse(query);
+    }
+    return query;
+  }).filter(query => Boolean(query)).filter(query => Object.keys(query).length > 0);
+  if (queryObjects.length === 0) {
+    return undefined;
+  }
+  if (queryObjects.length === 1) {
+    return queryObjects[0];
+  }
+  return {
+    $and: queryObjects
+  };
+}
+var ERROR_CODE_NOT_FOUND = 404;
+var ERROR_CODE_FORBIDDEN = 403;
+var ERROR_CODE_GONE = 410;
+function isNotAvailableError(error) {
+  return error.status === ERROR_CODE_NOT_FOUND || error.status === ERROR_CODE_GONE || error.status === ERROR_CODE_FORBIDDEN;
+}

package/build/content-delivery/cache/index.cjs

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  createSharedMemoryCache: true,
+  createStackedCache: true
+};
+Object.defineProperty(exports, "createSharedMemoryCache", {
+  enumerable: true,
+  get: function get() {
+    return _memory.createSharedMemoryCache;
+  }
+});
+Object.defineProperty(exports, "createStackedCache", {
+  enumerable: true,
+  get: function get() {
+    return _stacked.createStackedCache;
+  }
+});
+var _type = require("./type.cjs");
+Object.keys(_type).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _type[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _type[key];
+    }
+  });
+});
+var _memory = require("./memory.cjs");
+var _stacked = require("./stacked.cjs");

package/build/content-delivery/cache/index.d.ts

@@ -0,0 +1,3 @@
+export * from './type';
+export { createSharedMemoryCache } from './memory';
+export { createStackedCache } from './stacked';

package/build/content-delivery/cache/index.mjs

@@ -0,0 +1,3 @@
+export * from "./type.mjs";
+export { createSharedMemoryCache } from "./memory.mjs";
+export { createStackedCache } from "./stacked.mjs";

package/build/content-delivery/cache/memory.cjs

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RECORDS_LIMIT = void 0;
+exports.createSharedMemoryCache = createSharedMemoryCache;
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+var RECORDS_LIMIT = exports.RECORDS_LIMIT = 10000;
+var GC_PROBABILITY = 1 / 100;
+var CACHE = new Map();
+function createSharedMemoryCache() {
+  var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return {
+    get(key, latestVersion) {
+      var entry = CACHE.get("".concat(prefix).concat(key));
+      if (!entry) {
+        return undefined;
+      }
+      if (entry.version < latestVersion) {
+        CACHE.delete("".concat(prefix).concat(key));
+        return undefined;
+      }
+      var {
+        value,
+        version
+      } = entry;
+      CACHE.set("".concat(prefix).concat(key), {
+        value,
+        version,
+        accessed: new Date().getTime()
+      });
+      return value;
+    },
+    set(key, value, version) {
+      var entry = {
+        value,
+        version,
+        accessed: new Date().getTime()
+      };
+      CACHE.set("".concat(prefix).concat(key), entry);
+      if (CACHE.size > RECORDS_LIMIT && Math.random() < GC_PROBABILITY) {
+        gc();
+      }
+    },
+    namespace(namespace) {
+      return createSharedMemoryCache("".concat(prefix).concat(namespace, ":"));
+    }
+  };
+}
+function gc() {
+  Array.from(CACHE.entries()).sort((_ref, _ref2) => {
+    var [, a] = _ref;
+    var [, b] = _ref2;
+    return -cmp(a.accessed, b.accessed);
+  }).slice(RECORDS_LIMIT).forEach(_ref3 => {
+    var [key] = _ref3;
+    CACHE.delete(key);
+  });
+}
+function cmp(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}

package/build/content-delivery/cache/memory.d.ts

@@ -0,0 +1,3 @@
+import type { Cache } from './type';
+export declare const RECORDS_LIMIT = 10000;
+export declare function createSharedMemoryCache(prefix?: string): Cache;

package/build/content-delivery/cache/memory.mjs

@@ -0,0 +1,58 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+export var RECORDS_LIMIT = 10000;
+var GC_PROBABILITY = 1 / 100;
+var CACHE = new Map();
+export function createSharedMemoryCache() {
+  var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return {
+    get(key, latestVersion) {
+      var entry = CACHE.get("".concat(prefix).concat(key));
+      if (!entry) {
+        return undefined;
+      }
+      if (entry.version < latestVersion) {
+        CACHE.delete("".concat(prefix).concat(key));
+        return undefined;
+      }
+      var {
+        value,
+        version
+      } = entry;
+      CACHE.set("".concat(prefix).concat(key), {
+        value,
+        version,
+        accessed: new Date().getTime()
+      });
+      return value;
+    },
+    set(key, value, version) {
+      var entry = {
+        value,
+        version,
+        accessed: new Date().getTime()
+      };
+      CACHE.set("".concat(prefix).concat(key), entry);
+      if (CACHE.size > RECORDS_LIMIT && Math.random() < GC_PROBABILITY) {
+        gc();
+      }
+    },
+    namespace(namespace) {
+      return createSharedMemoryCache("".concat(prefix).concat(namespace, ":"));
+    }
+  };
+}
+function gc() {
+  Array.from(CACHE.entries()).sort((_ref, _ref2) => {
+    var [, a] = _ref;
+    var [, b] = _ref2;
+    return -cmp(a.accessed, b.accessed);
+  }).slice(RECORDS_LIMIT).forEach(_ref3 => {
+    var [key] = _ref3;
+    CACHE.delete(key);
+  });
+}
+function cmp(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}

package/build/content-delivery/cache/memory.test.cjs

@@ -0,0 +1,54 @@
+"use strict";
+
+var _memory = require("./memory.cjs");
+describe('createSharedMemoryCache', () => {
+  it('should write and read keys', () => {
+    var cache = (0, _memory.createSharedMemoryCache)();
+    expect(cache.get('hello', 0)).toBeUndefined();
+    cache.set('hello', 'world', 0);
+    expect(cache.get('hello', 0)).toBe('world');
+  });
+  it('should delete accessed records if the current version is higher', () => {
+    var cache = (0, _memory.createSharedMemoryCache)();
+    cache.set('hello', 'world', 0);
+    expect(cache.get('hello', 0)).toBe('world');
+    expect(cache.get('hello', 1)).toBeUndefined();
+    expect(cache.get('hello', 0)).toBeUndefined();
+  });
+  it('should separate datasets by namespace', () => {
+    var cache = (0, _memory.createSharedMemoryCache)();
+    var a = cache.namespace('a:');
+    var b = cache.namespace('b:');
+    a.set('hello', 'world', 0);
+    b.set('hello', 'universe', 0);
+    expect(cache.get('hello', 0)).toBeUndefined();
+    expect(a.get('hello', 0)).toBe('world');
+    expect(b.get('hello', 0)).toBe('universe');
+  });
+  it('should garbage-collect old cache records when threshold is reached (with a chance of 1/100)', () => {
+    var cache = (0, _memory.createSharedMemoryCache)();
+    for (var i = 0; i < _memory.RECORDS_LIMIT; i += 1) {
+      cache.set("record-".concat(i), "value-".concat(i), 0);
+    }
+    for (var _i = 0; _i < _memory.RECORDS_LIMIT; _i += 1) {
+      expect(cache.get("record-".concat(_i), 0)).toBe("value-".concat(_i));
+    }
+
+    // Write 10% more records, 10 times to trigger CG
+    for (var repeat = 0; repeat < 10; repeat += 1) {
+      for (var _i2 = _memory.RECORDS_LIMIT; _i2 < _memory.RECORDS_LIMIT * 1.1; _i2 += 1) {
+        cache.set("record-".concat(_i2), "value-".concat(_i2), 0);
+      }
+    }
+
+    // the oldest part of the cache should be removed already
+    for (var _i3 = 0; _i3 < _memory.RECORDS_LIMIT * 0.09; _i3 += 1) {
+      expect(cache.get("record-".concat(_i3), 0)).toBeUndefined();
+    }
+
+    // and the rest kept
+    for (var _i4 = _memory.RECORDS_LIMIT * 0.11; _i4 < _memory.RECORDS_LIMIT * 1.1; _i4 += 1) {
+      expect(cache.get("record-".concat(_i4), 0)).toBe("value-".concat(_i4));
+    }
+  });
+});

package/build/content-delivery/cache/memory.test.mjs

@@ -0,0 +1,52 @@
+import { createSharedMemoryCache, RECORDS_LIMIT } from "./memory.mjs";
+describe('createSharedMemoryCache', () => {
+  it('should write and read keys', () => {
+    var cache = createSharedMemoryCache();
+    expect(cache.get('hello', 0)).toBeUndefined();
+    cache.set('hello', 'world', 0);
+    expect(cache.get('hello', 0)).toBe('world');
+  });
+  it('should delete accessed records if the current version is higher', () => {
+    var cache = createSharedMemoryCache();
+    cache.set('hello', 'world', 0);
+    expect(cache.get('hello', 0)).toBe('world');
+    expect(cache.get('hello', 1)).toBeUndefined();
+    expect(cache.get('hello', 0)).toBeUndefined();
+  });
+  it('should separate datasets by namespace', () => {
+    var cache = createSharedMemoryCache();
+    var a = cache.namespace('a:');
+    var b = cache.namespace('b:');
+    a.set('hello', 'world', 0);
+    b.set('hello', 'universe', 0);
+    expect(cache.get('hello', 0)).toBeUndefined();
+    expect(a.get('hello', 0)).toBe('world');
+    expect(b.get('hello', 0)).toBe('universe');
+  });
+  it('should garbage-collect old cache records when threshold is reached (with a chance of 1/100)', () => {
+    var cache = createSharedMemoryCache();
+    for (var i = 0; i < RECORDS_LIMIT; i += 1) {
+      cache.set("record-".concat(i), "value-".concat(i), 0);
+    }
+    for (var _i = 0; _i < RECORDS_LIMIT; _i += 1) {
+      expect(cache.get("record-".concat(_i), 0)).toBe("value-".concat(_i));
+    }
+
+    // Write 10% more records, 10 times to trigger CG
+    for (var repeat = 0; repeat < 10; repeat += 1) {
+      for (var _i2 = RECORDS_LIMIT; _i2 < RECORDS_LIMIT * 1.1; _i2 += 1) {
+        cache.set("record-".concat(_i2), "value-".concat(_i2), 0);
+      }
+    }
+
+    // the oldest part of the cache should be removed already
+    for (var _i3 = 0; _i3 < RECORDS_LIMIT * 0.09; _i3 += 1) {
+      expect(cache.get("record-".concat(_i3), 0)).toBeUndefined();
+    }
+
+    // and the rest kept
+    for (var _i4 = RECORDS_LIMIT * 0.11; _i4 < RECORDS_LIMIT * 1.1; _i4 += 1) {
+      expect(cache.get("record-".concat(_i4), 0)).toBe("value-".concat(_i4));
+    }
+  });
+});

package/build/content-delivery/cache/stacked.cjs

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createStackedCache = createStackedCache;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function createStackedCache(caches) {
+  return {
+    get(key, latestVersion) {
+      return _asyncToGenerator(function* () {
+        for (var i = 0; i < caches.length; i += 1) {
+          // eslint-disable-next-line no-await-in-loop
+          var value = yield caches[i].get(key, latestVersion);
+          if (value !== undefined) {
+            return value;
+          }
+        }
+        return undefined;
+      })();
+    },
+    set(key, value, version) {
+      return _asyncToGenerator(function* () {
+        yield Promise.all(caches.map(cache => cache.set(key, value, version)));
+      })();
+    },
+    namespace(namespace) {
+      return createStackedCache(caches.map(cache => cache.namespace(namespace)));
+    }
+  };
+}

package/build/content-delivery/cache/stacked.d.ts

@@ -0,0 +1,2 @@
+import type { Cache } from './type';
+export declare function createStackedCache(caches: Cache[]): Cache;

package/build/content-delivery/cache/stacked.mjs

@@ -0,0 +1,26 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+export function createStackedCache(caches) {
+  return {
+    get(key, latestVersion) {
+      return _asyncToGenerator(function* () {
+        for (var i = 0; i < caches.length; i += 1) {
+          // eslint-disable-next-line no-await-in-loop
+          var value = yield caches[i].get(key, latestVersion);
+          if (value !== undefined) {
+            return value;
+          }
+        }
+        return undefined;
+      })();
+    },
+    set(key, value, version) {
+      return _asyncToGenerator(function* () {
+        yield Promise.all(caches.map(cache => cache.set(key, value, version)));
+      })();
+    },
+    namespace(namespace) {
+      return createStackedCache(caches.map(cache => cache.namespace(namespace)));
+    }
+  };
+}