@sitecore-jss/sitecore-jss 0.1.0-beta.2

package/dist/esm/i18n/dictionary-service.js

@@ -0,0 +1,41 @@
+import { MemoryCacheClient } from '../cache-client';
+/**
+ * Base implementation of @see DictionaryService that handles caching dictionary values
+ */
+export class DictionaryServiceBase {
+    /**
+     * Initializes a new instance of @see DictionaryService using the provided @see CacheOptions
+     * @param {CacheOptions} options Configuration options
+     */
+    constructor(options) {
+        this.options = options;
+        this.cache = this.getCacheClient();
+    }
+    /**
+     * Caches a @see DictionaryPhrases value for the specified cache key.
+     * @param {string} key The cache key.
+     * @param {DictionaryPhrases} value The value to cache.
+     * @returns The value added to the cache.
+     * @mixes CacheClient<DictionaryPhrases>
+     */
+    setCacheValue(key, value) {
+        return this.cache.setCacheValue(key, value);
+    }
+    /**
+     * Retrieves a @see DictionaryPhrases value from the cache.
+     * @param {string} key The cache key.
+     * @returns The @see DictionaryPhrases value, or null if the specified key is not found in the cache.
+     */
+    getCacheValue(key) {
+        return this.cache.getCacheValue(key);
+    }
+    /**
+     * Gets a cache client that can cache data. Uses memory-cache as the default
+     * library for caching (@see MemoryCacheClient). Override this method if you
+     * want to use something else.
+     * @returns {CacheClient} implementation
+     */
+    getCacheClient() {
+        return new MemoryCacheClient(this.options);
+    }
+}

package/dist/esm/i18n/graphql-dictionary-service.js

@@ -0,0 +1,118 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { SitecoreTemplateId } from '../constants';
+import { DictionaryServiceBase } from './dictionary-service';
+import { getAppRootId, SearchQueryService } from '../graphql';
+import debug from '../debug';
+/** @private */
+export const queryError = 'Valid value for rootItemId not provided and failed to auto-resolve app root item.';
+const query = /* GraphQL */ `
+  query DictionarySearch(
+    $rootItemId: String!
+    $language: String!
+    $templates: String!
+    $pageSize: Int = 10
+    $after: String
+  ) {
+    search(
+      where: {
+        AND: [
+          { name: "_path", value: $rootItemId, operator: CONTAINS }
+          { name: "_language", value: $language }
+          { name: "_templates", value: $templates, operator: CONTAINS }
+        ]
+      }
+      first: $pageSize
+      after: $after
+    ) {
+      total
+      pageInfo {
+        endCursor
+        hasNext
+      }
+      results {
+        key: field(name: "Key") {
+          value
+        }
+        phrase: field(name: "Phrase") {
+          value
+        }
+      }
+    }
+  }
+`;
+/**
+ * Service that fetch dictionary data using Sitecore's GraphQL API.
+ * @augments DictionaryServiceBase
+ * @mixes SearchQueryService<DictionaryQueryResult>
+ */
+export class GraphQLDictionaryService extends DictionaryServiceBase {
+    /**
+     * Creates an instance of graphQL dictionary service with the provided options
+     * @param {GraphQLDictionaryService} options instance
+     */
+    constructor(options) {
+        super(options);
+        this.options = options;
+        this.graphQLClient = this.getGraphQLClient();
+        this.searchService = new SearchQueryService(this.graphQLClient);
+    }
+    /**
+     * Fetches dictionary data for internalization.
+     * @param {string} language the language to fetch
+     * @default query (@see query)
+     * @returns {Promise<DictionaryPhrases>} dictionary phrases
+     * @throws {Error} if the app root was not found for the specified site and language.
+     */
+    fetchDictionaryData(language) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cacheKey = this.options.siteName + language;
+            const cachedValue = this.getCacheValue(cacheKey);
+            if (cachedValue) {
+                debug.dictionary('using cached dictionary data for %s %s', language, this.options.siteName);
+                return cachedValue;
+            }
+            debug.dictionary('fetching site root for %s %s', language, this.options.siteName);
+            // If the caller does not specify a root item ID, then we try to figure it out
+            const rootItemId = this.options.rootItemId ||
+                (yield getAppRootId(this.graphQLClient, this.options.siteName, language, this.options.jssAppTemplateId));
+            if (!rootItemId) {
+                throw new Error(queryError);
+            }
+            debug.dictionary('fetching dictionary data for %s %s', language, this.options.siteName);
+            const phrases = {};
+            yield this.searchService
+                .fetch(query, {
+                rootItemId,
+                language,
+                templates: this.options.dictionaryEntryTemplateId || SitecoreTemplateId.DictionaryEntry,
+                pageSize: this.options.pageSize,
+            })
+                .then((results) => {
+                results.forEach((item) => (phrases[item.key.value] = item.phrase.value));
+            });
+            this.setCacheValue(cacheKey, phrases);
+            return phrases;
+        });
+    }
+    /**
+     * Gets a GraphQL client that can make requests to the API.
+     * @returns {GraphQLClient} implementation
+     */
+    getGraphQLClient() {
+        if (!this.options.clientFactory) {
+            throw new Error('You should provide a clientFactory.');
+        }
+        return this.options.clientFactory({
+            debugger: debug.dictionary,
+            retries: this.options.retries,
+        });
+    }
+}

package/dist/esm/i18n/index.js

@@ -0,0 +1,2 @@
+export { DictionaryServiceBase } from './dictionary-service';
+export { GraphQLDictionaryService, } from './graphql-dictionary-service';

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+// NOTE: all imports are now named as to not make breaking changes
+// and to keep react-native working with cjs modules.
+import * as constants from './constants';
+export { default as debug, enableDebug } from './debug';
+export { GraphQLRequestClient, } from './graphql-request-client';
+export { NativeDataFetcher, } from './native-fetcher';
+export { constants };

package/dist/esm/layout/content-styles.js

@@ -0,0 +1,65 @@
+import { SITECORE_EDGE_URL_DEFAULT } from '../constants';
+/**
+ * Regular expression to check if the content styles are used in the field value
+ */
+const CLASS_REGEXP = /class=".*(\bck-content\b).*"/g;
+/**
+ * Get the content styles link to be loaded from the Sitecore Edge Platform
+ * @param {LayoutServiceData} layoutData Layout service data
+ * @param {string} sitecoreEdgeContextId Sitecore Edge Context ID
+ * @param {string} [sitecoreEdgeUrl] Sitecore Edge Platform URL. Default is https://edge-platform.sitecorecloud.io
+ * @returns {HTMLLink | null} content styles link, null if no styles are used in layout
+ */
+export const getContentStylesheetLink = (layoutData, sitecoreEdgeContextId, sitecoreEdgeUrl = SITECORE_EDGE_URL_DEFAULT) => {
+    if (!layoutData.sitecore.route)
+        return null;
+    const config = { loadStyles: false };
+    traverseComponent(layoutData.sitecore.route, config);
+    if (!config.loadStyles)
+        return null;
+    return {
+        href: getContentStylesheetUrl(sitecoreEdgeContextId, sitecoreEdgeUrl),
+        rel: 'stylesheet',
+    };
+};
+export const getContentStylesheetUrl = (sitecoreEdgeContextId, sitecoreEdgeUrl = SITECORE_EDGE_URL_DEFAULT) => `${sitecoreEdgeUrl}/v1/files/pages/styles/content-styles.css?sitecoreContextId=${sitecoreEdgeContextId}`;
+export const traversePlaceholder = (components, config) => {
+    if (config.loadStyles)
+        return;
+    components.forEach((component) => {
+        traverseComponent(component, config);
+    });
+};
+export const traverseField = (field, config) => {
+    if (!field || config.loadStyles)
+        return;
+    if ('editable' in field && field.editable) {
+        config.loadStyles = CLASS_REGEXP.test(field.editable);
+    }
+    else if ('value' in field && typeof field.value === 'string') {
+        config.loadStyles = CLASS_REGEXP.test(field.value);
+    }
+    else if ('fields' in field) {
+        Object.values(field.fields).forEach((field) => {
+            traverseField(field, config);
+        });
+    }
+    else if (Array.isArray(field)) {
+        field.forEach((field) => {
+            traverseField(field, config);
+        });
+    }
+};
+export const traverseComponent = (component, config) => {
+    if (config.loadStyles)
+        return;
+    if ('fields' in component && component.fields) {
+        Object.values(component.fields).forEach((field) => {
+            traverseField(field, config);
+        });
+    }
+    const placeholders = component.placeholders || {};
+    Object.keys(placeholders).forEach((placeholder) => {
+        traversePlaceholder(placeholders[placeholder], config);
+    });
+};

package/dist/esm/layout/graphql-layout-service.js

@@ -0,0 +1,77 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { LayoutServiceBase } from './layout-service';
+import debug from '../debug';
+/**
+ * Service that fetch layout data using Sitecore's GraphQL API.
+ * @augments LayoutServiceBase
+ * @mixes GraphQLRequestClient
+ */
+export class GraphQLLayoutService extends LayoutServiceBase {
+    /**
+     * Fetch layout data using the Sitecore GraphQL endpoint.
+     * @param {GraphQLLayoutServiceConfig} serviceConfig configuration
+     */
+    constructor(serviceConfig) {
+        super();
+        this.serviceConfig = serviceConfig;
+        this.graphQLClient = this.getGraphQLClient();
+    }
+    /**
+     * Fetch layout data for an item.
+     * @param {string} itemPath item path to fetch layout data for.
+     * @param {string} [language] the language to fetch layout data for.
+     * @returns {Promise<LayoutServiceData>} layout service data
+     */
+    fetchLayoutData(itemPath, language) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = this.getLayoutQuery(itemPath, language);
+            debug.layout('fetching layout data for %s %s %s', itemPath, language, this.serviceConfig.siteName);
+            const data = yield this.graphQLClient.request(query);
+            // If `rendered` is empty -> not found
+            return (((_b = (_a = data === null || data === void 0 ? void 0 : data.layout) === null || _a === void 0 ? void 0 : _a.item) === null || _b === void 0 ? void 0 : _b.rendered) || {
+                sitecore: { context: { pageEditing: false, language }, route: null },
+            });
+        });
+    }
+    /**
+     * Gets a GraphQL client that can make requests to the API.
+     * @returns {GraphQLClient} implementation
+     */
+    getGraphQLClient() {
+        if (!this.serviceConfig.clientFactory) {
+            throw new Error('You should provide a clientFactory.');
+        }
+        return this.serviceConfig.clientFactory({
+            debugger: debug.layout,
+            retries: this.serviceConfig.retries,
+        });
+    }
+    /**
+     * Returns GraphQL Layout query
+     * @param {string} itemPath page route
+     * @param {string} [language] language
+     * @returns {string} GraphQL query
+     */
+    getLayoutQuery(itemPath, language) {
+        const languageVariable = language ? `, language:"${language}"` : '';
+        const layoutQuery = this.serviceConfig.formatLayoutQuery
+            ? this.serviceConfig.formatLayoutQuery(this.serviceConfig.siteName, itemPath, language)
+            : `layout(site:"${this.serviceConfig.siteName}", routePath:"${itemPath}"${languageVariable})`;
+        return `query {
+      ${layoutQuery}{
+        item {
+          rendered
+        }
+      }
+    }`;
+    }
+}

package/dist/esm/layout/index.js

@@ -0,0 +1,6 @@
+// layout
+export { LayoutServicePageState, RenderingType, EDITING_COMPONENT_PLACEHOLDER, EDITING_COMPONENT_ID, } from './models';
+export { getFieldValue, getChildPlaceholder } from './utils';
+export { getContentStylesheetLink } from './content-styles';
+export { GraphQLLayoutService } from './graphql-layout-service';
+export { getComponentLibraryStylesheetLinks } from './themes';

package/dist/esm/layout/layout-service.js

@@ -0,0 +1,5 @@
+/**
+ * Base abstraction to implement custom layout service
+ */
+export class LayoutServiceBase {
+}

package/dist/esm/layout/models.js

@@ -0,0 +1,24 @@
+/**
+ * Static placeholder name used for component rendering
+ */
+export const EDITING_COMPONENT_PLACEHOLDER = 'editing-componentmode-placeholder';
+/**
+ * Id of wrapper for component rendering
+ */
+export const EDITING_COMPONENT_ID = 'editing-component';
+/**
+ * Layout Service page state enum
+ */
+export var LayoutServicePageState;
+(function (LayoutServicePageState) {
+    LayoutServicePageState["Preview"] = "preview";
+    LayoutServicePageState["Edit"] = "edit";
+    LayoutServicePageState["Normal"] = "normal";
+})(LayoutServicePageState || (LayoutServicePageState = {}));
+/**
+ * Editing rendering type
+ */
+export var RenderingType;
+(function (RenderingType) {
+    RenderingType["Component"] = "component";
+})(RenderingType || (RenderingType = {}));

package/dist/esm/layout/themes.js

@@ -0,0 +1,74 @@
+import { getFieldValue, } from '.';
+import { SITECORE_EDGE_URL_DEFAULT } from '../constants';
+/**
+ * Pattern for library ids
+ * @example -library--foo
+ */
+const STYLES_LIBRARY_ID_REGEX = /-library--([^\s]+)/;
+/**
+ * Walks through rendering tree and returns list of links of all FEAAS, BYOC or SXA Component Library Stylesheets that are used
+ * @param {LayoutServiceData} layoutData Layout service data
+ * @param {string} sitecoreEdgeContextId Sitecore Edge Context ID
+ * @param {string} [sitecoreEdgeUrl] Sitecore Edge Platform URL. Default is https://edge-platform.sitecorecloud.io
+ * @returns {HTMLLink[]} library stylesheet links
+ */
+export function getComponentLibraryStylesheetLinks(layoutData, sitecoreEdgeContextId, sitecoreEdgeUrl = SITECORE_EDGE_URL_DEFAULT) {
+    const ids = new Set();
+    if (!layoutData.sitecore.route)
+        return [];
+    traverseComponent(layoutData.sitecore.route, ids);
+    return [...ids].map((id) => ({
+        href: getStylesheetUrl(id, sitecoreEdgeContextId, sitecoreEdgeUrl),
+        rel: 'stylesheet',
+    }));
+}
+export const getStylesheetUrl = (id, sitecoreEdgeContextId, sitecoreEdgeUrl = SITECORE_EDGE_URL_DEFAULT) => {
+    return `${sitecoreEdgeUrl}/v1/files/components/styles/${id}.css?sitecoreContextId=${sitecoreEdgeContextId}`;
+};
+/**
+ * Traverse placeholder and components to add library ids
+ * @param {Array<ComponentRendering | HtmlElementRendering>} components
+ * @param {Set<string>} ids library ids
+ */
+const traversePlaceholder = (components, ids) => {
+    components.map((component) => {
+        const rendering = component;
+        return traverseComponent(rendering, ids);
+    });
+};
+/**
+ * Traverse component and children to add library ids
+ * @param {RouteData | ComponentRendering | HtmlElementRendering} component component data
+ * @param {Set<string>} ids library ids
+ */
+const traverseComponent = (component, ids) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    let libraryId = undefined;
+    if ('params' in component && component.params) {
+        // LibraryID in css class name takes precedence over LibraryId attribute
+        libraryId =
+            ((_b = (_a = component.params.CSSStyles) === null || _a === void 0 ? void 0 : _a.match(STYLES_LIBRARY_ID_REGEX)) === null || _b === void 0 ? void 0 : _b[1]) ||
+                ((_d = (_c = component.params.Styles) === null || _c === void 0 ? void 0 : _c.match(STYLES_LIBRARY_ID_REGEX)) === null || _d === void 0 ? void 0 : _d[1]) ||
+                component.params.LibraryId ||
+                undefined;
+    }
+    // if params are empty we try to fall back to data source or attributes
+    if (!libraryId && 'fields' in component && component.fields) {
+        libraryId =
+            ((_e = getFieldValue(component.fields, 'CSSStyles', '').match(STYLES_LIBRARY_ID_REGEX)) === null || _e === void 0 ? void 0 : _e[1]) ||
+                ((_f = getFieldValue(component.fields, 'Styles', '').match(STYLES_LIBRARY_ID_REGEX)) === null || _f === void 0 ? void 0 : _f[1]) ||
+                getFieldValue(component.fields, 'LibraryId', '') ||
+                undefined;
+    }
+    // HTMLRendering its class attribute
+    if (!libraryId && 'attributes' in component && typeof component.attributes.class === 'string') {
+        libraryId = (_g = component.attributes.class.match(STYLES_LIBRARY_ID_REGEX)) === null || _g === void 0 ? void 0 : _g[1];
+    }
+    if (libraryId) {
+        ids.add(libraryId);
+    }
+    const placeholders = component.placeholders || {};
+    Object.keys(placeholders).forEach((placeholder) => {
+        traversePlaceholder(placeholders[placeholder], ids);
+    });
+};

package/dist/esm/layout/utils.js

@@ -0,0 +1,39 @@
+/**
+ * @param {ComponentRendering | Fields} renderingOrFields the rendering or fields object to extract the field from
+ * @param {string} fieldName the name of the field to extract
+ * @param {T} [defaultValue] the default value to return if the field is not defined
+ * @returns {Field | T} the field value or the default value if the field is not defined
+ */
+// eslint-disable-next-line no-redeclare
+export function getFieldValue(renderingOrFields, fieldName, defaultValue) {
+    if (!renderingOrFields || !fieldName) {
+        return defaultValue;
+    }
+    const fields = renderingOrFields;
+    const field = fields[fieldName];
+    if (field && typeof field.value !== 'undefined') {
+        return field.value;
+    }
+    const rendering = renderingOrFields;
+    if (!rendering.fields ||
+        !rendering.fields[fieldName] ||
+        typeof rendering.fields[fieldName].value === 'undefined') {
+        return defaultValue;
+    }
+    return rendering.fields[fieldName].value;
+}
+/**
+ * Gets rendering definitions in a given child placeholder under a current rendering.
+ * @param {ComponentRendering} rendering
+ * @param {string} placeholderName
+ * @returns {Array<ComponentRendering | HtmlElementRendering>} child placeholder
+ */
+export function getChildPlaceholder(rendering, placeholderName) {
+    if (!rendering ||
+        !placeholderName ||
+        !rendering.placeholders ||
+        !rendering.placeholders[placeholderName]) {
+        return [];
+    }
+    return rendering.placeholders[placeholderName];
+}

package/dist/esm/media/index.js

@@ -0,0 +1,2 @@
+import * as mediaApi from './media-api';
+export { mediaApi };

package/dist/esm/media/media-api.js

@@ -0,0 +1,117 @@
+import unescape from 'lodash.unescape';
+import URL from 'url-parse';
+// finds an img tag with HTML attributes
+const imgTagRegex = /<img([^>]+)\/>/i;
+// finds all the HTML attributes in a string
+const htmlAttrsRegex = /([^=\s]+)(="([^"]*)")?/gi;
+// finds the Sitecore media URL prefix
+const mediaUrlPrefixRegex = /\/([-~]{1})\/media\//i;
+/**
+ * Makes a request to Sitecore Content Service for the specified item path.
+ * @param {string} editorMarkup the markup to parse
+ * @returns {Object | null} found image tag; null in case if not found
+ */
+export const findEditorImageTag = (editorMarkup) => {
+    // match the tag
+    const tagMatch = editorMarkup.match(imgTagRegex);
+    if (!tagMatch || tagMatch.length < 2) {
+        return null;
+    }
+    // find the attrs and turn them into a Map
+    const attrs = {};
+    let match = htmlAttrsRegex.exec(tagMatch[1]);
+    while (match !== null) {
+        attrs[match[1]] = unescape(match[3]);
+        match = htmlAttrsRegex.exec(tagMatch[1]);
+    }
+    return {
+        imgTag: tagMatch[0],
+        attrs,
+    };
+};
+/**
+ * Get required query string params which should be merged with user params
+ * @param {object} qs layout service parsed query string
+ * @returns {object} requiredParams
+ */
+export const getRequiredParams = (qs) => {
+    const { rev, db, la, vs, ts } = qs;
+    return { rev, db, la, vs, ts };
+};
+/**
+ * Replace `/~/media` or `/-/media` with `/~/jssmedia` or `/-/jssmedia`, respectively.
+ * Can use `mediaUrlPrefix` in order to use a custom prefix.
+ * @param {string} url The URL to replace the media URL prefix in
+ * @param {RegExp} [mediaUrlPrefix=mediaUrlPrefixRegex] The regex to match the media URL prefix
+ * @returns {string} The URL with the media URL prefix replaced
+ */
+export const replaceMediaUrlPrefix = (url, mediaUrlPrefix = mediaUrlPrefixRegex) => {
+    const parsed = URL(url, {}, true);
+    const match = mediaUrlPrefix.exec(parsed.pathname);
+    if (match && match.length > 1) {
+        // regex will provide us with /-/ or /~/ type
+        parsed.set('pathname', parsed.pathname.replace(mediaUrlPrefix, `/${match[1]}/jssmedia/`));
+    }
+    return parsed.toString();
+};
+/**
+ * Prepares a Sitecore media URL with `params` for use by the JSS media handler.
+ * This is done by replacing `/~/media` or `/-/media` with `/~/jssmedia` or `/-/jssmedia`, respectively.
+ * Provided `params` are used as the querystring parameters for the media URL.
+ * Can use `mediaUrlPrefix` in order to use a custom prefix.
+ * If no `params` are sent, the original media URL is returned.
+ * @param {string} url The URL to prepare
+ * @param {Object} [params] The querystring parameters to use
+ * @param {RegExp} [mediaUrlPrefix=mediaUrlPrefixRegex] The regex to match the media URL prefix
+ * @returns {string} The prepared URL
+ */
+export const updateImageUrl = (url, params, mediaUrlPrefix = mediaUrlPrefixRegex) => {
+    if (!params || Object.keys(params).length === 0) {
+        // if params aren't supplied, no need to run it through JSS media handler
+        return url;
+    }
+    // polyfill node `global` in browser to workaround https://github.com/unshiftio/url-parse/issues/150
+    if (typeof window !== 'undefined' && !window.global) {
+        window.global = {};
+    }
+    const parsed = URL(replaceMediaUrlPrefix(url, mediaUrlPrefix), {}, true);
+    const requiredParams = getRequiredParams(parsed.query);
+    const query = Object.assign({}, params);
+    Object.entries(requiredParams).forEach(([key, param]) => {
+        if (param) {
+            query[key] = param;
+        }
+    });
+    parsed.set('query', query);
+    return parsed.toString();
+};
+/**
+ * Receives an array of `srcSet` parameters that are iterated and used as parameters to generate
+ * a corresponding set of updated Sitecore media URLs via @see updateImageUrl. The result is a comma-delimited
+ * list of media URLs with respective dimension parameters.
+ *
+ * @example
+ * // returns '/ipsum.jpg?h=1000&w=1000 1000w, /ipsum.jpg?mh=250&mw=250 250w'
+ * getSrcSet('/ipsum.jpg', [{ h: 1000, w: 1000 }, { mh: 250, mw: 250 } ])
+ *
+ * More information about `srcSet`: {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img}
+ *
+ * @param {string} url The URL to prepare
+ * @param {Array} srcSet The array of parameters to use
+ * @param {Object} [imageParams] The querystring parameters to use
+ * @param {RegExp} [mediaUrlPrefix] The regex to match the media URL prefix
+ * @returns {string} The prepared URL
+ */
+export const getSrcSet = (url, srcSet, imageParams, mediaUrlPrefix) => {
+    return srcSet
+        .map((params) => {
+        const newParams = Object.assign(Object.assign({}, imageParams), params);
+        const imageWidth = newParams.w || newParams.mw;
+        if (!imageWidth) {
+            return null;
+        }
+        return `${updateImageUrl(url, newParams, mediaUrlPrefix)} ${imageWidth}w`;
+    })
+        .filter((value) => value)
+        .join(', ');
+};

package/dist/esm/models.js

@@ -0,0 +1 @@
+export {};