@sitecore-content-sdk/core 1.3.0-canary.9 → 1.4.0-canary.2

package/dist/cjs/utils/utils.js

@@ -1,229 +1,254 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeURLSearchParams = exports.escapeNonSpecialQuestionMarks = exports.areURLSearchParamsEqual = exports.isRegexOrUrl = exports.getEnforcedCorsHeaders = exports.enforceCors = exports.getAllowedOriginsFromEnv = exports.isTimeoutError = exports.isAbsoluteUrl = void 0;
-exports.resolveUrl = resolveUrl;
-const is_server_1 = __importDefault(require("./is-server"));
-/**
- * note: encodeURIComponent is available via browser (window) or natively in node.js
- * if you use another js engine for server-side rendering you may not have native encodeURIComponent
- * and would then need to install a package for that functionality
- * @param {ParsedUrlQueryInput} params query string parameters
- * @returns {string} query string
- */
-function getQueryString(params) {
-    return Object.keys(params)
-        .map((k) => `${encodeURIComponent(k)}=${encodeURIComponent(String(params[k]))}`)
-        .join('&');
-}
-/**
- * Resolves a base URL that may contain query string parameters and an additional set of query
- * string parameters into a unified string representation.
- * @param {string} urlBase the base URL that may contain query string parameters
- * @param {ParsedUrlQueryInput} params query string parameters
- * @returns a URL string
- * @throws {RangeError} if the provided url is an empty string
- */
-function resolveUrl(urlBase, params = {}) {
-    if (!urlBase) {
-        throw new RangeError('url must be a non-empty string');
-    }
-    // This is a better way to work with URLs since it handles different user input
-    // edge cases. This works in Node and all browser except IE11.
-    // https://developer.mozilla.org/en-US/docs/Web/API/URL
-    // TODO: Verify our browser support requirements.
-    if ((0, is_server_1.default)()) {
-        const url = new URL(urlBase);
-        for (const key in params) {
-            if ({}.hasOwnProperty.call(params, key)) {
-                url.searchParams.append(key, String(params[key]));
-            }
-        }
-        const result = url.toString();
-        return result;
-    }
-    const qs = getQueryString(params);
-    const result = urlBase.indexOf('?') !== -1 ? `${urlBase}&${qs}` : `${urlBase}?${qs}`;
-    return result;
-}
-const isAbsoluteUrl = (url) => {
-    if (!url) {
-        return false;
-    }
-    if (typeof url !== 'string') {
-        throw new TypeError('Expected a string');
-    }
-    return /^[a-z][a-z0-9+.-]*:/.test(url);
-};
-exports.isAbsoluteUrl = isAbsoluteUrl;
-/**
- * Indicates whether the error is a timeout error
- * @param {unknown} error error
- * @returns {boolean} is timeout error
- */
-const isTimeoutError = (error) => {
-    var _a;
-    return ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 408 || error.name === 'AbortError';
-};
-exports.isTimeoutError = isTimeoutError;
-/**
- * Converts a string value in a regex pattern allowing wildcard matching
- * @param {string} pattern input with wildcards i.e. site.*.com
- * @returns {string} modified string that can be used as regexp input
- */
-const convertToWildcardRegex = (pattern) => {
-    return '^' + pattern.replace(/\//g, '\\/').replace(/\./g, '\\.').replace(/\*/g, '.*') + '$';
-};
-/**
- * Gets allowed origins from JSS_ALLOWED_ORIGINS env variable
- * @returns {string[]} list of allowed origins from JSS_ALLOWED_ORIGINS env variable
- */
-const getAllowedOriginsFromEnv = () => process.env.JSS_ALLOWED_ORIGINS
-    ? process.env.JSS_ALLOWED_ORIGINS.replace(' ', '').split(',')
-    : [];
-exports.getAllowedOriginsFromEnv = getAllowedOriginsFromEnv;
-/**
- * Tests origin from incoming request against allowed origins list that can be
- * set in JSS's JSS_ALLOWED_ORIGINS env variable, passed via allowedOrigins param and/or
- * be already set in Access-Control-Allow-Origin by other logic.
- * Applies Access-Control-Allow-Origin and Access-Control-Allow-Methods on match
- * Also applies Access-Control-Allow-Headers for preflight requests
- * @param {IncomingMessage} req incoming request
- * @param {OutgoingMessage} res response to set CORS headers for
- * @param {string[]} [allowedOrigins] additional list of origins to test against
- * @returns true if incoming origin matches the allowed lists, false when it does not
- * @deprecated use getEnforcedCorsHeaders instead
- */
-const enforceCors = (req, res, allowedOrigins) => {
-    // origin in not present for non-CORS requests (e.g. server-side) - so we skip the checks
-    if (!req.headers.origin) {
-        return true;
-    }
-    // 3 sources of allowed origins are considered:
-    // the env value
-    const defaultAllowedOrigins = (0, exports.getAllowedOriginsFromEnv)();
-    // the allowedOrigins prop
-    allowedOrigins = defaultAllowedOrigins.concat(allowedOrigins || []);
-    // and the existing CORS header, if present (i.e. set by nextjs config)
-    const presetCors = res.getHeader('Access-Control-Allow-Origin');
-    if (presetCors) {
-        allowedOrigins.push(presetCors);
-    }
-    const origin = req.headers.origin;
-    if (origin &&
-        allowedOrigins.some((allowedOrigin) => origin === allowedOrigin || new RegExp(convertToWildcardRegex(allowedOrigin)).test(origin))) {
-        res.setHeader('Access-Control-Allow-Origin', origin);
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, DELETE, PUT, PATCH');
-        // set the allowed headers for preflight requests
-        if (req.method === 'OPTIONS') {
-            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-        }
-        return true;
-    }
-    return false;
-};
-exports.enforceCors = enforceCors;
-const getEnforcedCorsHeaders = ({ requestMethod, headers, presetCorsHeader, allowedOrigins = [], }) => {
-    // ugly but gotta satisfy both node.js and web fetch Headers interface somehow
-    const origin = headers.get
-        ? headers.get('origin')
-        : headers.origin;
-    if (!origin) {
-        return {};
-    }
-    // 3 sources of allowed origins are considered:
-    // the env value
-    const defaultAllowedOrigins = (0, exports.getAllowedOriginsFromEnv)();
-    // the allowedOrigins prop
-    allowedOrigins = defaultAllowedOrigins.concat(allowedOrigins || []);
-    // and the existing CORS header, if provided (i.e. from nextjs config)
-    if (presetCorsHeader) {
-        allowedOrigins.push(presetCorsHeader);
-    }
-    if (origin &&
-        allowedOrigins.some((allowedOrigin) => origin === allowedOrigin || new RegExp(convertToWildcardRegex(allowedOrigin)).test(origin))) {
-        const corsHeaders = {
-            'Access-Control-Allow-Origin': origin,
-            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS, DELETE, PUT, PATCH',
-        };
-        // set the allowed headers for preflight requests
-        if (requestMethod === 'OPTIONS') {
-            corsHeaders['Access-Control-Allow-Headers'] = 'Content-Type, Authorization';
-        }
-        return corsHeaders;
-    }
-    return null;
-};
-exports.getEnforcedCorsHeaders = getEnforcedCorsHeaders;
-/**
- * Determines whether the given input is a regular expression or resembles a URL.
- * @param {string} input - The input string to evaluate.
- * @returns {'regex' | 'url'} - Returns 'url' if the input looks like a URL, otherwise 'regex'.
- */
-const isRegexOrUrl = (input) => {
-    // Remove the trailing slash.
-    input = input.slice(0, -1);
-    // Check if the string resembles a URL.
-    const isUrlLike = /^\/[a-zA-Z0-9\-\/]+(\?([a-zA-Z0-9\-_]+=[a-zA-Z0-9\-_]+)(&[a-zA-Z0-9\-_]+=[a-zA-Z0-9\-_]+)*)?$/.test(input);
-    if (isUrlLike) {
-        return 'url';
-    }
-    // If it doesn't resemble a URL, it's likely a regular expression.
-    return 'regex';
-};
-exports.isRegexOrUrl = isRegexOrUrl;
-/**
- * Compares two URLSearchParams objects to determine if they are equal.
- * @param {URLSearchParams} params1 - The first set of URL search parameters.
- * @param {URLSearchParams} params2 - The second set of URL search parameters.
- * @returns {boolean} - Returns true if the parameters are equal, otherwise false.
- */
-const areURLSearchParamsEqual = (params1, params2) => {
-    // Generates a sorted string representation of URL search parameters.
-    const getSortedParamsString = (params) => {
-        return [...params.entries()]
-            .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
-            .map(([key, value]) => `${key}=${value}`)
-            .join('&');
-    };
-    // Compare the sorted strings of both parameter sets.
-    return getSortedParamsString(params1) === getSortedParamsString(params2);
-};
-exports.areURLSearchParamsEqual = areURLSearchParamsEqual;
-/**
- * Escapes non-special "?" characters in a string or regex.
- * - For regex patterns that start with `^` or end with `$`, it returns the pattern unchanged.
- * - For other strings, it escapes literal "?" characters but preserves regex quantifiers and special patterns.
- * @param {string} input - The input string or regex pattern.
- * @returns {string} - The modified string or regex with non-special "?" characters escaped.
- */
-const escapeNonSpecialQuestionMarks = (input) => {
-    // If the input is already a regex pattern (starts with ^ or ends with $), return it unchanged
-    if (input.startsWith('^') || input.endsWith('$')) {
-        return input;
-    }
-    // For non-regex strings, escape literal "?" characters
-    return input.replace(/\?/g, '\\?');
-};
-exports.escapeNonSpecialQuestionMarks = escapeNonSpecialQuestionMarks;
-/**
- * Merges two URLSearchParams objects. If both objects contain the same key, the value from the second object overrides the first.
- * @param {URLSearchParams} params1 - The first set of URL search parameters.
- * @param {URLSearchParams} params2 - The second set of URL search parameters.
- * @returns {string} - A string representation of the merged URL search parameters.
- */
-const mergeURLSearchParams = (params1, params2) => {
-    const merged = new URLSearchParams();
-    // Add all keys and values from the first object.
-    for (const [key, value] of params1.entries()) {
-        merged.set(key, value);
-    }
-    // Add all keys and values from the second object, replacing existing ones.
-    for (const [key, value] of params2.entries()) {
-        merged.set(key, value);
-    }
-    return merged.toString();
-};
-exports.mergeURLSearchParams = mergeURLSearchParams;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeURLSearchParams = exports.escapeNonSpecialQuestionMarks = exports.areURLSearchParamsEqual = exports.isRegexOrUrl = exports.getEnforcedCorsHeaders = exports.enforceCors = exports.getAllowedOriginsFromEnv = exports.isTimeoutError = exports.isAbsoluteUrl = void 0;
+exports.resolveUrl = resolveUrl;
+const is_server_1 = __importDefault(require("./is-server"));
+/**
+ * note: encodeURIComponent is available via browser (window) or natively in node.js
+ * if you use another js engine for server-side rendering you may not have native encodeURIComponent
+ * and would then need to install a package for that functionality
+ * @param {ParsedUrlQueryInput} params query string parameters
+ * @returns {string} query string
+ */
+function getQueryString(params) {
+    return Object.keys(params)
+        .map((k) => `${encodeURIComponent(k)}=${encodeURIComponent(String(params[k]))}`)
+        .join('&');
+}
+/**
+ * Resolves a base URL that may contain query string parameters and an additional set of query
+ * string parameters into a unified string representation.
+ * @param {string} urlBase the base URL that may contain query string parameters
+ * @param {ParsedUrlQueryInput} params query string parameters
+ * @returns a URL string
+ * @throws {RangeError} if the provided url is an empty string
+ * @public
+ */
+function resolveUrl(urlBase, params = {}) {
+    if (!urlBase) {
+        throw new RangeError('url must be a non-empty string');
+    }
+    // This is a better way to work with URLs since it handles different user input
+    // edge cases. This works in Node and all browser except IE11.
+    // https://developer.mozilla.org/en-US/docs/Web/API/URL
+    // TODO: Verify our browser support requirements.
+    if ((0, is_server_1.default)()) {
+        const url = new URL(urlBase);
+        for (const key in params) {
+            if ({}.hasOwnProperty.call(params, key)) {
+                url.searchParams.append(key, String(params[key]));
+            }
+        }
+        const result = url.toString();
+        return result;
+    }
+    const qs = getQueryString(params);
+    const result = urlBase.indexOf('?') !== -1 ? `${urlBase}&${qs}` : `${urlBase}?${qs}`;
+    return result;
+}
+/**
+ * Checks if the given URL is an absolute URL
+ * @param {string} url - The URL to check.
+ * @returns {boolean} - Returns true if the URL is an absolute URL, otherwise false.
+ * @public
+ */
+const isAbsoluteUrl = (url) => {
+    if (!url) {
+        return false;
+    }
+    if (typeof url !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+    return /^[a-z][a-z0-9+.-]*:/.test(url);
+};
+exports.isAbsoluteUrl = isAbsoluteUrl;
+/**
+ * Indicates whether the error is a timeout error
+ * @param {unknown} error error
+ * @returns {boolean} is timeout error
+ * @public
+ */
+const isTimeoutError = (error) => {
+    var _a;
+    return ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 408 || error.name === 'AbortError';
+};
+exports.isTimeoutError = isTimeoutError;
+/**
+ * Converts a string value in a regex pattern allowing wildcard matching
+ * @param {string} pattern input with wildcards i.e. site.*.com
+ * @returns {string} modified string that can be used as regexp input
+ */
+const convertToWildcardRegex = (pattern) => {
+    return '^' + pattern.replace(/\//g, '\\/').replace(/\./g, '\\.').replace(/\*/g, '.*') + '$';
+};
+/**
+ * Gets allowed origins from JSS_ALLOWED_ORIGINS env variable
+ * @returns {string[]} list of allowed origins from JSS_ALLOWED_ORIGINS env variable
+ * @public
+ */
+const getAllowedOriginsFromEnv = () => process.env.JSS_ALLOWED_ORIGINS
+    ? process.env.JSS_ALLOWED_ORIGINS.replace(' ', '').split(',')
+    : [];
+exports.getAllowedOriginsFromEnv = getAllowedOriginsFromEnv;
+/**
+ * Tests origin from incoming request against allowed origins list that can be
+ * set in JSS's JSS_ALLOWED_ORIGINS env variable, passed via allowedOrigins param and/or
+ * be already set in Access-Control-Allow-Origin by other logic.
+ * Applies Access-Control-Allow-Origin and Access-Control-Allow-Methods on match
+ * Also applies Access-Control-Allow-Headers for preflight requests
+ * @param {IncomingMessage} req incoming request
+ * @param {OutgoingMessage} res response to set CORS headers for
+ * @param {string[]} [allowedOrigins] additional list of origins to test against
+ * @returns true if incoming origin matches the allowed lists, false when it does not
+ * @deprecated use getEnforcedCorsHeaders instead
+ * @public
+ */
+const enforceCors = (req, res, allowedOrigins) => {
+    // origin in not present for non-CORS requests (e.g. server-side) - so we skip the checks
+    if (!req.headers.origin) {
+        return true;
+    }
+    // 3 sources of allowed origins are considered:
+    // the env value
+    const defaultAllowedOrigins = (0, exports.getAllowedOriginsFromEnv)();
+    // the allowedOrigins prop
+    allowedOrigins = defaultAllowedOrigins.concat(allowedOrigins || []);
+    // and the existing CORS header, if present (i.e. set by nextjs config)
+    const presetCors = res.getHeader('Access-Control-Allow-Origin');
+    if (presetCors) {
+        allowedOrigins.push(presetCors);
+    }
+    const origin = req.headers.origin;
+    if (origin &&
+        allowedOrigins.some((allowedOrigin) => origin === allowedOrigin || new RegExp(convertToWildcardRegex(allowedOrigin)).test(origin))) {
+        res.setHeader('Access-Control-Allow-Origin', origin);
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, DELETE, PUT, PATCH');
+        // set the allowed headers for preflight requests
+        if (req.method === 'OPTIONS') {
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        }
+        return true;
+    }
+    return false;
+};
+exports.enforceCors = enforceCors;
+/**
+ * Gets enforced CORS headers
+ * @param {string} requestMethod - The HTTP method of the request.
+ * @param {IncomingHttpHeaders | Headers} headers - The headers of the request.
+ * @param {string | string[]} presetCorsHeader - The preset CORS header.
+ * @param {string[]} [allowedOrigins] - The allowed origins.
+ * @returns {Record<string, string>} - The enforced CORS headers.
+ * @public
+ */
+const getEnforcedCorsHeaders = ({ requestMethod, headers, presetCorsHeader, allowedOrigins = [], }) => {
+    // ugly but gotta satisfy both node.js and web fetch Headers interface somehow
+    const origin = headers.get
+        ? headers.get('origin')
+        : headers.origin;
+    if (!origin) {
+        return {};
+    }
+    // 3 sources of allowed origins are considered:
+    // the env value
+    const defaultAllowedOrigins = (0, exports.getAllowedOriginsFromEnv)();
+    // the allowedOrigins prop
+    allowedOrigins = defaultAllowedOrigins.concat(allowedOrigins || []);
+    // and the existing CORS header, if provided (i.e. from nextjs config)
+    if (presetCorsHeader) {
+        allowedOrigins.push(presetCorsHeader);
+    }
+    if (origin &&
+        allowedOrigins.some((allowedOrigin) => origin === allowedOrigin || new RegExp(convertToWildcardRegex(allowedOrigin)).test(origin))) {
+        const corsHeaders = {
+            'Access-Control-Allow-Origin': origin,
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS, DELETE, PUT, PATCH',
+            'x-middleware-cache': 'no-cache',
+            'Cache-Control': 'no-store, must-revalidate',
+        };
+        // set the allowed headers for preflight requests
+        if (requestMethod === 'OPTIONS') {
+            corsHeaders['Access-Control-Allow-Headers'] = 'Content-Type, Authorization';
+        }
+        return corsHeaders;
+    }
+    return null;
+};
+exports.getEnforcedCorsHeaders = getEnforcedCorsHeaders;
+/**
+ * Determines whether the given input is a regular expression or resembles a URL.
+ * @param {string} input - The input string to evaluate.
+ * @returns {'regex' | 'url'} - Returns 'url' if the input looks like a URL, otherwise 'regex'.
+ * @public
+ */
+const isRegexOrUrl = (input) => {
+    // Remove the trailing slash.
+    input = input.slice(0, -1);
+    // Check if the string resembles a URL.
+    const isUrlLike = /^\/[a-zA-Z0-9\-\/]+(\?([a-zA-Z0-9\-_]+=[a-zA-Z0-9\-_]+)(&[a-zA-Z0-9\-_]+=[a-zA-Z0-9\-_]+)*)?$/.test(input);
+    if (isUrlLike) {
+        return 'url';
+    }
+    // If it doesn't resemble a URL, it's likely a regular expression.
+    return 'regex';
+};
+exports.isRegexOrUrl = isRegexOrUrl;
+/**
+ * Compares two URLSearchParams objects to determine if they are equal.
+ * @param {URLSearchParams} params1 - The first set of URL search parameters.
+ * @param {URLSearchParams} params2 - The second set of URL search parameters.
+ * @returns {boolean} - Returns true if the parameters are equal, otherwise false.
+ * @public
+ */
+const areURLSearchParamsEqual = (params1, params2) => {
+    // Generates a sorted string representation of URL search parameters.
+    const getSortedParamsString = (params) => {
+        return [...params.entries()]
+            .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+            .map(([key, value]) => `${key}=${value}`)
+            .join('&');
+    };
+    // Compare the sorted strings of both parameter sets.
+    return getSortedParamsString(params1) === getSortedParamsString(params2);
+};
+exports.areURLSearchParamsEqual = areURLSearchParamsEqual;
+/**
+ * Escapes non-special "?" characters in a string or regex.
+ * - For regex patterns that start with `^` or end with `$`, it returns the pattern unchanged.
+ * - For other strings, it escapes literal "?" characters but preserves regex quantifiers and special patterns.
+ * @param {string} input - The input string or regex pattern.
+ * @returns {string} - The modified string or regex with non-special "?" characters escaped.
+ * @public
+ */
+const escapeNonSpecialQuestionMarks = (input) => {
+    // If the input is already a regex pattern (starts with ^ or ends with $), return it unchanged
+    if (input.startsWith('^') || input.endsWith('$')) {
+        return input;
+    }
+    // For non-regex strings, escape literal "?" characters
+    return input.replace(/\?/g, '\\?');
+};
+exports.escapeNonSpecialQuestionMarks = escapeNonSpecialQuestionMarks;
+/**
+ * Merges two URLSearchParams objects. If both objects contain the same key, the value from the second object overrides the first.
+ * @param {URLSearchParams} params1 - The first set of URL search parameters.
+ * @param {URLSearchParams} params2 - The second set of URL search parameters.
+ * @returns {string} - A string representation of the merged URL search parameters.
+ * @public
+ */
+const mergeURLSearchParams = (params1, params2) => {
+    const merged = new URLSearchParams();
+    // Add all keys and values from the first object.
+    for (const [key, value] of params1.entries()) {
+        merged.set(key, value);
+    }
+    // Add all keys and values from the second object, replacing existing ones.
+    for (const [key, value] of params2.entries()) {
+        merged.set(key, value);
+    }
+    return merged.toString();
+};
+exports.mergeURLSearchParams = mergeURLSearchParams;

package/dist/esm/cache-client.js

@@ -1,50 +1,51 @@
-import { Cache } from 'memory-cache';
-/**
- * Default cache configuration
- */
-const DEFAULTS = Object.freeze({
-    cacheTimeout: 60,
-    cacheEnabled: true,
-});
-/**
- * A cache client that uses the 'memory-cache' library (https://github.com/ptarjan/node-cache).
- * This class is meant to be extended or used as a mixin; it's not meant to be used directly.
- * @template T The type of data being cached.
- * @mixin
- */
-export class MemoryCacheClient {
-    /**
-     * Initializes a new instance of @see MemoryCacheClient using the provided @see CacheOptions
-     * @param {CacheOptions} options Configuration options
-     */
-    constructor(options) {
-        var _a;
-        this.options = options;
-        this.cache = new Cache();
-        this.options.cacheTimeout = ((_a = this.options.cacheTimeout) !== null && _a !== void 0 ? _a : DEFAULTS.cacheTimeout) * 1000;
-        if (this.options.cacheEnabled === undefined) {
-            this.options.cacheEnabled = DEFAULTS.cacheEnabled;
-        }
-    }
-    /**
-     * Retrieves a value from the cache.
-     * @template T The type of data being cached.
-     * @param {string} key The cache key.
-     * @returns The cache value as {T}, or null if the specified key is not found in the cache.
-     */
-    getCacheValue(key) {
-        return this.options.cacheEnabled ? this.cache.get(key) : null;
-    }
-    /**
-     * Adds a value to the cache for the specified cache key.
-     * @template T The type of data being cached.
-     * @param {string} key The cache key.
-     * @param {T} value The value to cache.
-     * @returns The value added to the cache.
-     */
-    setCacheValue(key, value) {
-        return this.options.cacheEnabled
-            ? this.cache.put(key, value, this.options.cacheTimeout)
-            : value;
-    }
-}
+import { Cache } from 'memory-cache';
+/**
+ * Default cache configuration
+ */
+const DEFAULTS = Object.freeze({
+    cacheTimeout: 60,
+    cacheEnabled: true,
+});
+/**
+ * A cache client that uses the 'memory-cache' library (https://github.com/ptarjan/node-cache).
+ * This class is meant to be extended or used as a mixin; it's not meant to be used directly.
+ * @template T The type of data being cached.
+ * @mixin
+ * @public
+ */
+export class MemoryCacheClient {
+    /**
+     * Initializes a new instance of @see MemoryCacheClient using the provided @see CacheOptions
+     * @param {CacheOptions} options Configuration options
+     */
+    constructor(options) {
+        var _a;
+        this.options = options;
+        this.cache = new Cache();
+        this.options.cacheTimeout = ((_a = this.options.cacheTimeout) !== null && _a !== void 0 ? _a : DEFAULTS.cacheTimeout) * 1000;
+        if (this.options.cacheEnabled === undefined) {
+            this.options.cacheEnabled = DEFAULTS.cacheEnabled;
+        }
+    }
+    /**
+     * Retrieves a value from the cache.
+     * @template T The type of data being cached.
+     * @param {string} key The cache key.
+     * @returns The cache value as {T}, or null if the specified key is not found in the cache.
+     */
+    getCacheValue(key) {
+        return this.options.cacheEnabled ? this.cache.get(key) : null;
+    }
+    /**
+     * Adds a value to the cache for the specified cache key.
+     * @template T The type of data being cached.
+     * @param {string} key The cache key.
+     * @param {T} value The value to cache.
+     * @returns The value added to the cache.
+     */
+    setCacheValue(key, value) {
+        return this.options.cacheEnabled
+            ? this.cache.put(key, value, this.options.cacheTimeout)
+            : value;
+    }
+}

package/dist/esm/client/constants.js

@@ -1,4 +1,4 @@
-/** @private */
-export const siteNameError = 'The site name must be a non-empty string';
-/** @private */
-export const languageError = 'The language must be a non-empty string';
+/** @private */
+export const siteNameError = 'The site name must be a non-empty string';
+/** @private */
+export const languageError = 'The language must be a non-empty string';