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

package/dist/esm/tools/templating/plugins.js

@@ -1,70 +1,72 @@
-import fs from 'fs';
-import path from 'path';
-import { getItems } from './utils';
-/**
- * Identifies the format of the module to be compiled
- */
-export var ModuleType;
-(function (ModuleType) {
-    ModuleType[ModuleType["CJS"] = 0] = "CJS";
-    ModuleType[ModuleType["ESM"] = 1] = "ESM";
-})(ModuleType || (ModuleType = {}));
-/**
- * Get list of plugins from @var path
- * Returns a list of plugins in the following format:
- * {
- *   path: 'path/to/plugin/foo',
- *   name: 'fooPlugin'
- * }
- * @example getPluginList('src/foo/plugins', 'Foo')
- * @param {object} definition plugin definition
- * @param {string} definition.path path to get plugin from
- * @param {string} definition.pluginName plugin name
- * @param {boolean} [definition.silent] whether to suppress console output
- */
-export function getPluginList({ path, pluginName, silent = false, }) {
-    const plugins = getItems({
-        path,
-        resolveItem: (path, name) => ({
-            path: `${path}/${name}`,
-            name: `${name.replace(/-./g, (x) => x[1].toUpperCase())}Plugin`,
-        }),
-        cb: (name) => !silent && console.debug(`Registering ${pluginName} plugin ${name}`),
-    });
-    return plugins;
-}
-/**
- * Generates the plugins file and saves it to the filesystem.
- * By convention, we expect to find plugins under {pluginName}/plugins/** (subfolders are searched recursively).
- * generated file will be saved to @var {distPath} and will contain a list of plugins in the following format:
- * CJS: exports.fooPlugin = require('{pluginPath}');
- * ESM: export { fooPlugin } from '{pluginPath}';
- * @example generatePlugins({ distPath: 'src/temp/foo-plugins.js', rootPath: 'src/foo/plugins', moduleType: ModuleType.CJS })
- * @param {PluginDefinition} definition plugin definition
- */
-export function generatePlugins(definition) {
-    const { rootPath, distPath, moduleType, relative = false, silent } = definition;
-    const segments = rootPath.split('/');
-    const pluginName = segments[segments.length - 2];
-    const plugins = getPluginList({ path: rootPath, pluginName, silent });
-    let fileContent = '';
-    fileContent = plugins
-        .map((plugin) => {
-        const sourcePath = relative
-            ? path.relative(path.dirname(distPath), plugin.path).replace(/\\/g, '/')
-            : plugin.path;
-        return moduleType === ModuleType.CJS
-            ? `exports.${plugin.name} = require('${sourcePath}');`
-            : `export { ${plugin.name} } from '${sourcePath}';`;
-    })
-        .join('\r\n')
-        .concat('\r\n');
-    if (!plugins.length) {
-        fileContent = moduleType === ModuleType.CJS ? 'module.exports = {};\r\n' : 'export {};\r\n';
-    }
-    const filePath = path.resolve(distPath);
-    !silent && console.log(`Writing ${pluginName} plugins to ${filePath}`);
-    fs.writeFileSync(filePath, fileContent, {
-        encoding: 'utf8',
-    });
-}
+import fs from 'fs';
+import path from 'path';
+import { getItems } from './utils';
+/**
+ * Identifies the format of the module to be compiled
+ * @public
+ */
+export var ModuleType;
+(function (ModuleType) {
+    ModuleType[ModuleType["CJS"] = 0] = "CJS";
+    ModuleType[ModuleType["ESM"] = 1] = "ESM";
+})(ModuleType || (ModuleType = {}));
+/**
+ * Get list of plugins from @var path
+ * Returns a list of plugins in the following format:
+ * {
+ *   path: 'path/to/plugin/foo',
+ *   name: 'fooPlugin'
+ * }
+ * @example getPluginList('src/foo/plugins', 'Foo')
+ * @param {object} definition plugin definition
+ * @param {string} definition.path path to get plugin from
+ * @param {string} definition.pluginName plugin name
+ * @param {boolean} [definition.silent] whether to suppress console output
+ */
+export function getPluginList({ path, pluginName, silent = false, }) {
+    const plugins = getItems({
+        path,
+        resolveItem: (path, name) => ({
+            path: `${path}/${name}`,
+            name: `${name.replace(/-./g, (x) => x[1].toUpperCase())}Plugin`,
+        }),
+        cb: (name) => !silent && console.debug(`Registering ${pluginName} plugin ${name}`),
+    });
+    return plugins;
+}
+/**
+ * Generates the plugins file and saves it to the filesystem.
+ * By convention, we expect to find plugins under {pluginName}/plugins/** (subfolders are searched recursively).
+ * generated file will be saved to @var {distPath} and will contain a list of plugins in the following format:
+ * CJS: exports.fooPlugin = require('{pluginPath}');
+ * ESM: export { fooPlugin } from '{pluginPath}';
+ * @example generatePlugins({ distPath: 'src/temp/foo-plugins.js', rootPath: 'src/foo/plugins', moduleType: ModuleType.CJS })
+ * @param {PluginDefinition} definition plugin definition
+ * @public
+ */
+export function generatePlugins(definition) {
+    const { rootPath, distPath, moduleType, relative = false, silent } = definition;
+    const segments = rootPath.split('/');
+    const pluginName = segments[segments.length - 2];
+    const plugins = getPluginList({ path: rootPath, pluginName, silent });
+    let fileContent = '';
+    fileContent = plugins
+        .map((plugin) => {
+        const sourcePath = relative
+            ? path.relative(path.dirname(distPath), plugin.path).replace(/\\/g, '/')
+            : plugin.path;
+        return moduleType === ModuleType.CJS
+            ? `exports.${plugin.name} = require('${sourcePath}');`
+            : `export { ${plugin.name} } from '${sourcePath}';`;
+    })
+        .join('\r\n')
+        .concat('\r\n');
+    if (!plugins.length) {
+        fileContent = moduleType === ModuleType.CJS ? 'module.exports = {};\r\n' : 'export {};\r\n';
+    }
+    const filePath = path.resolve(distPath);
+    !silent && console.log(`Writing ${pluginName} plugins to ${filePath}`);
+    fs.writeFileSync(filePath, fileContent, {
+        encoding: 'utf8',
+    });
+}

package/dist/esm/tools/templating/utils.js

@@ -1,58 +1,59 @@
-import fs from 'fs';
-import path from 'path';
-/**
- * Compares two paths to determine if they match.
- * @param {string} itemPath base path to compare against, can be absolute or relative
- * @param {string} compare comparer, can be relate, absolute or regex string
- * @returns true if paths match, false otherwise
- */
-export const matchPath = (itemPath, compare) => {
-    if (compare === itemPath ||
-        path.join(process.cwd(), itemPath) === compare ||
-        itemPath === path.join(process.cwd(), compare) ||
-        new RegExp(compare).test(itemPath)) {
-        return true;
-    }
-    return false;
-};
-/**
- * Using @var path find all files and generate output using @var resolveItem function for each file
- * Can be used to generate list of components, templates, etc.
- * @param {GetItemsSettings} settings
- * @returns {Item[]} list of items
- */
-export function getItems(settings) {
-    const { recursive = true, path, resolveItem, cb, fileFormat = new RegExp(/(.+)(?<!\.d)\.[jt]sx?$/), exclude, } = settings;
-    const items = [];
-    const folders = [];
-    if (!fs.existsSync(path))
-        return [];
-    if (exclude) {
-        for (const exclusion of exclude) {
-            if (matchPath(path, exclusion))
-                return [];
-        }
-    }
-    fs.readdirSync(path, { withFileTypes: true }).forEach((item) => {
-        if (item.isDirectory()) {
-            folders.push(item);
-        }
-        if (fileFormat.test(item.name)) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const name = item.name.match(fileFormat)[1];
-            items.push(resolveItem(path, name));
-            cb && cb(name);
-        }
-    });
-    for (const folder of folders) {
-        recursive
-            ? items.push(...getItems({
-                path: `${path}/${folder.name}`,
-                resolveItem,
-                cb,
-                fileFormat,
-            }))
-            : items.push(resolveItem(`${path}/${folder.name}`, folder.name));
-    }
-    return items;
-}
+import fs from 'fs';
+import path from 'path';
+/**
+ * Compares two paths to determine if they match.
+ * @param {string} itemPath base path to compare against, can be absolute or relative
+ * @param {string} compare comparer, can be relate, absolute or regex string
+ * @returns true if paths match, false otherwise
+ * @public
+ */
+export const matchPath = (itemPath, compare) => {
+    if (compare === itemPath ||
+        path.join(process.cwd(), itemPath) === compare ||
+        itemPath === path.join(process.cwd(), compare) ||
+        new RegExp(compare).test(itemPath)) {
+        return true;
+    }
+    return false;
+};
+/**
+ * Using @var path find all files and generate output using @var resolveItem function for each file
+ * Can be used to generate list of components, templates, etc.
+ * @param {GetItemsSettings} settings
+ * @returns {Item[]} list of items
+ */
+export function getItems(settings) {
+    const { recursive = true, path, resolveItem, cb, fileFormat = new RegExp(/(.+)(?<!\.d)\.[jt]sx?$/), exclude, } = settings;
+    const items = [];
+    const folders = [];
+    if (!fs.existsSync(path))
+        return [];
+    if (exclude) {
+        for (const exclusion of exclude) {
+            if (matchPath(path, exclusion))
+                return [];
+        }
+    }
+    fs.readdirSync(path, { withFileTypes: true }).forEach((item) => {
+        if (item.isDirectory()) {
+            folders.push(item);
+        }
+        if (fileFormat.test(item.name)) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const name = item.name.match(fileFormat)[1];
+            items.push(resolveItem(path, name));
+            cb && cb(name);
+        }
+    });
+    for (const folder of folders) {
+        recursive
+            ? items.push(...getItems({
+                path: `${path}/${folder.name}`,
+                resolveItem,
+                cb,
+                fileFormat,
+            }))
+            : items.push(resolveItem(`${path}/${folder.name}`, folder.name));
+    }
+    return items;
+}

package/dist/esm/utils/ensurePath.js

@@ -1,13 +1,13 @@
-import fs from 'fs';
-import path from 'path';
-/**
- * Ensures that the directory path for the given file path exists.
- * If the directory does not exist, it will be created recursively.
- * @param {string} filePath - The file path for which to ensure the directory exists.
- */
-export const ensurePathExists = (filePath) => {
-    const outputDir = path.dirname(filePath);
-    if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, { recursive: true });
-    }
-};
+import fs from 'fs';
+import path from 'path';
+/**
+ * Ensures that the directory path for the given file path exists.
+ * If the directory does not exist, it will be created recursively.
+ * @param {string} filePath - The file path for which to ensure the directory exists.
+ */
+export const ensurePathExists = (filePath) => {
+    const outputDir = path.dirname(filePath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+};

package/dist/esm/utils/env.js

@@ -1,23 +1,24 @@
-/**
- * Method to parse JSON-formatted environment variables
- * @param {string} envValue - can be undefined when providing values via process.env
- * @param {T} defaultValue - default value
- * @returns {T | string} parsed value
- */
-export const tryParseEnvValue = (envValue, defaultValue) => {
-    if (!envValue) {
-        return defaultValue;
-    }
-    if (envValue.startsWith('{') && envValue.endsWith('}')) {
-        try {
-            return JSON.parse(envValue);
-            // eslint-disable-next-line no-unused-vars
-        }
-        catch (error) {
-            console.warn('Parsing of env variable failed');
-            console.warn(`Attempted to parse ${envValue}`);
-            return defaultValue;
-        }
-    }
-    return defaultValue;
-};
+/**
+ * Method to parse JSON-formatted environment variables
+ * @param {string} envValue - can be undefined when providing values via process.env
+ * @param {T} defaultValue - default value
+ * @returns {T | string} parsed value
+ * @public
+ */
+export const tryParseEnvValue = (envValue, defaultValue) => {
+    if (!envValue) {
+        return defaultValue;
+    }
+    if (envValue.startsWith('{') && envValue.endsWith('}')) {
+        try {
+            return JSON.parse(envValue);
+            // eslint-disable-next-line no-unused-vars
+        }
+        catch (error) {
+            console.warn('Parsing of env variable failed');
+            console.warn(`Attempted to parse ${envValue}`);
+            return defaultValue;
+        }
+    }
+    return defaultValue;
+};

package/dist/esm/utils/globalCache.js

@@ -0,0 +1,49 @@
+/**
+ * Stores a value in the global cache under the specified key.
+ * - Initializes the cache object on `globalThis` if it does not exist.
+ * - Overwrites any existing value for the given key.
+ * @param {string} key - The cache key to set.
+ * @param {unknown} data - The value to store in the cache.
+ * @internal
+ */
+export function setCache(key, data) {
+    if (!globalThis.__dlCache) {
+        globalThis.__dlCache = {};
+    }
+    globalThis.__dlCache[key] = data;
+}
+/**
+ * Retrieves a value from the global cache by key.
+ *  - The cache is stored on `globalThis`
+ * @param {string} key - The cache key to retrieve and remove.
+ * @returns {T} - The cached value if present, otherwise undefined.
+ * @internal
+ */
+export function getCache(key) {
+    const cache = globalThis.__dlCache;
+    return cache === null || cache === void 0 ? void 0 : cache[key];
+}
+/**
+ * Retrieves a value from the global cache by key and removes it from the cache.
+ *  - The cache is stored on `globalThis`
+ * @param {string} key - The cache key to retrieve and remove.
+ * @returns {T} - The cached value if present, otherwise undefined.
+ * @internal
+ */
+export function getCacheAndClean(key) {
+    const cache = globalThis.__dlCache;
+    const data = cache === null || cache === void 0 ? void 0 : cache[key];
+    cache === null || cache === void 0 ? true : delete cache[key];
+    return data;
+}
+/**
+ * Determines whether a cached value exists for the provided key
+ *  - The cache is stored on `globalThis`
+ * @param {string} key - The cache key to test for existence.
+ * @returns {boolean} - true if a value is present for the given key; otherwise false.
+ * @internal
+ */
+export function hasCache(key) {
+    const cache = globalThis.__dlCache;
+    return (cache === null || cache === void 0 ? void 0 : cache[key]) !== undefined;
+}

package/dist/esm/utils/index.js

@@ -1,3 +1,4 @@
-export { default as isServer } from './is-server';
-export { resolveUrl, isAbsoluteUrl, isTimeoutError, enforceCors, getEnforcedCorsHeaders, getAllowedOriginsFromEnv, isRegexOrUrl, areURLSearchParamsEqual, escapeNonSpecialQuestionMarks, mergeURLSearchParams, } from './utils';
-export { tryParseEnvValue } from './env';
+export { default as isServer } from './is-server';
+export { resolveUrl, isAbsoluteUrl, isTimeoutError, enforceCors, getEnforcedCorsHeaders, getAllowedOriginsFromEnv, isRegexOrUrl, areURLSearchParamsEqual, escapeNonSpecialQuestionMarks, mergeURLSearchParams, } from './utils';
+export { hasCache, getCache, getCacheAndClean, setCache } from './globalCache';
+export { tryParseEnvValue } from './env';

package/dist/esm/utils/is-server.js

@@ -1,8 +1,9 @@
-/**
- * Determines whether the current execution context is server-side
- * @returns true if executing server-side
- */
-function isServer() {
-    return !(typeof window !== 'undefined' && window.document);
-}
-export default isServer;
+/**
+ * Determines whether the current execution context is server-side
+ * @returns true if executing server-side
+ * @public
+ */
+function isServer() {
+    return !(typeof window !== 'undefined' && window.document);
+}
+export default isServer;

package/dist/esm/utils/normalize-url.js

@@ -1 +1 @@
-export const normalizeUrl = (url) => (url.endsWith('/') ? url.slice(0, -1) : url);
+export const normalizeUrl = (url) => (url.endsWith('/') ? url.slice(0, -1) : url);

package/dist/esm/utils/timeout-promise.js

@@ -1,28 +1,28 @@
-/**
- * A helper to assign timeouts to fetch or other promises
- * Useful in nextjs middleware until fetch.signal is fully supported by Vercel edge functions
- */
-export default class TimeoutPromise {
-    constructor(timeout) {
-        this.timeout = timeout;
-        this.timeoutId = undefined;
-    }
-    /**
-     * Creates a timeout promise
-     */
-    get start() {
-        return new Promise((_, reject) => {
-            this.timeoutId = setTimeout(() => {
-                const abortError = new Error(`Request timed out, timeout of ${this.timeout}ms is exceeded`);
-                abortError.name = 'AbortError';
-                reject(abortError);
-            }, this.timeout);
-        });
-    }
-    /**
-     * Clears the timeout from timeout promise
-     */
-    clear() {
-        this.timeoutId && clearTimeout(this.timeoutId);
-    }
-}
+/**
+ * A helper to assign timeouts to fetch or other promises
+ * Useful in nextjs middleware until fetch.signal is fully supported by Vercel edge functions
+ */
+export default class TimeoutPromise {
+    constructor(timeout) {
+        this.timeout = timeout;
+        this.timeoutId = undefined;
+    }
+    /**
+     * Creates a timeout promise
+     */
+    get start() {
+        return new Promise((_, reject) => {
+            this.timeoutId = setTimeout(() => {
+                const abortError = new Error(`Request timed out, timeout of ${this.timeout}ms is exceeded`);
+                abortError.name = 'AbortError';
+                reject(abortError);
+            }, this.timeout);
+        });
+    }
+    /**
+     * Clears the timeout from timeout promise
+     */
+    clear() {
+        this.timeoutId && clearTimeout(this.timeoutId);
+    }
+}