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

package/dist/esm/site/graphql-robots-service.js

@@ -0,0 +1,74 @@
+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 { siteNameError } from '../constants';
+import debug from '../debug';
+// The default query for request robots.txt
+const defaultQuery = /* GraphQL */ `
+  query RobotsQuery($siteName: String!) {
+    site {
+      siteInfo(site: $siteName) {
+        robots
+      }
+    }
+  }
+`;
+/**
+ * Service that fetch the robots.txt data using Sitecore's GraphQL API.
+ */
+export class GraphQLRobotsService {
+    /**
+     * Creates an instance of graphQL robots.txt service with the provided options
+     * @param {GraphQLRobotsServiceConfig} options instance
+     */
+    constructor(options) {
+        this.options = options;
+        this.graphQLClient = this.getGraphQLClient();
+    }
+    get query() {
+        return defaultQuery;
+    }
+    /**
+     * Fetch a data of robots.txt from API
+     * @returns text of robots.txt
+     * @throws {Error} if the siteName is empty.
+     */
+    fetchRobots() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const siteName = this.options.siteName;
+            if (!siteName) {
+                throw new Error(siteNameError);
+            }
+            const robotsResult = this.graphQLClient.request(this.query, {
+                siteName,
+            });
+            try {
+                return robotsResult.then((result) => {
+                    var _a, _b;
+                    return (_b = (_a = result === null || result === void 0 ? void 0 : result.site) === null || _a === void 0 ? void 0 : _a.siteInfo) === null || _b === void 0 ? void 0 : _b.robots;
+                });
+            }
+            catch (e) {
+                return Promise.reject(e);
+            }
+        });
+    }
+    /**
+     * 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.robots,
+        });
+    }
+}

package/dist/esm/site/graphql-siteinfo-service.js

@@ -0,0 +1,121 @@
+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 debug from '../debug';
+import { MemoryCacheClient } from '../cache-client';
+const headlessSiteGroupingTemplate = 'E46F3AF2-39FA-4866-A157-7017C4B2A40C';
+const sitecoreContentRootItem = '0DE95AE4-41AB-4D01-9EB0-67441B7C2450';
+const defaultQuery = /* GraphQL */ `
+  query($pageSize: Int = 10, $after: String) {
+    search(
+      where: {
+        AND: [
+          { name: "_templates", value: "${headlessSiteGroupingTemplate}", operator: CONTAINS }
+          { name: "_path", value: "${sitecoreContentRootItem}", operator: CONTAINS }
+        ]
+      }
+      first: $pageSize
+      after: $after
+    ) {
+      pageInfo {
+        endCursor
+        hasNext
+      }
+      results {
+        ... on Item {
+          name: field(name: "SiteName") {
+            value
+          }
+          hostName: field(name: "Hostname") {
+            value
+          }
+          language: field(name: "Language") {
+            value
+          }
+        }
+      }
+    }
+  }
+`;
+export class GraphQLSiteInfoService {
+    /**
+     * Creates an instance of graphQL service to retrieve site configuration list from Sitecore
+     * @param {GraphQLSiteInfoServiceConfig} config instance
+     */
+    constructor(config) {
+        this.config = config;
+        this.graphQLClient = this.getGraphQLClient();
+        this.cache = this.getCacheClient();
+    }
+    get query() {
+        return defaultQuery;
+    }
+    fetchSiteInfo() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const cachedResult = this.cache.getCacheValue(this.getCacheKey());
+            if (cachedResult) {
+                return cachedResult;
+            }
+            if (process.env.SITECORE) {
+                debug.multisite('Skipping site information fetch (building on XM Cloud)');
+                return [];
+            }
+            const results = [];
+            let hasNext = true;
+            let after = '';
+            while (hasNext) {
+                const response = yield this.graphQLClient.request(this.query, {
+                    pageSize: this.config.pageSize,
+                    after,
+                });
+                const result = (_b = (_a = response === null || response === void 0 ? void 0 : response.search) === null || _a === void 0 ? void 0 : _a.results) === null || _b === void 0 ? void 0 : _b.reduce((result, current) => {
+                    result.push({
+                        name: current.name.value,
+                        hostName: current.hostName.value,
+                        language: current.language.value,
+                    });
+                    return result;
+                }, []);
+                results.push(...result);
+                hasNext = response.search.pageInfo.hasNext;
+                after = response.search.pageInfo.endCursor;
+            }
+            this.cache.setCacheValue(this.getCacheKey(), results);
+            return results;
+        });
+    }
+    /**
+     * Gets cache client implementation
+     * Override this method if custom cache needs to be used
+     * @returns CacheClient instance
+     */
+    getCacheClient() {
+        var _a, _b;
+        return new MemoryCacheClient({
+            cacheEnabled: (_a = this.config.cacheEnabled) !== null && _a !== void 0 ? _a : true,
+            cacheTimeout: (_b = this.config.cacheTimeout) !== null && _b !== void 0 ? _b : 10,
+        });
+    }
+    /**
+     * Gets a GraphQL client that can make requests to the API.
+     * @returns {GraphQLClient} implementation
+     */
+    getGraphQLClient() {
+        if (!this.config.clientFactory) {
+            throw new Error('You should provide a clientFactory.');
+        }
+        return this.config.clientFactory({
+            debugger: debug.multisite,
+        });
+    }
+    getCacheKey() {
+        return 'siteinfo-service-cache';
+    }
+}

package/dist/esm/site/graphql-sitemap-service.js

@@ -0,0 +1,84 @@
+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 { siteNameError } from '../constants';
+import debug from '../debug';
+const PREFIX_NAME_SITEMAP = 'sitemap';
+// The default query for request sitemaps
+const defaultQuery = /* GraphQL */ `
+  query SitemapQuery($siteName: String!) {
+    site {
+      siteInfo(site: $siteName) {
+        sitemap
+      }
+    }
+  }
+`;
+/**
+ * Service that fetch the sitemaps data using Sitecore's GraphQL API.
+ */
+export class GraphQLSitemapXmlService {
+    /**
+     * Creates an instance of graphQL sitemaps service with the provided options
+     * @param {GraphQLSitemapXmlServiceConfig} options instance
+     */
+    constructor(options) {
+        this.options = options;
+        this.graphQLClient = this.getGraphQLClient();
+    }
+    get query() {
+        return defaultQuery;
+    }
+    /**
+     * Fetch list of sitemaps for the site
+     * @returns {string[]} list of sitemap paths
+     * @throws {Error} if the siteName is empty.
+     */
+    fetchSitemaps() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const siteName = this.options.siteName;
+            if (!siteName) {
+                throw new Error(siteNameError);
+            }
+            const sitemapResult = this.graphQLClient.request(this.query, {
+                siteName,
+            });
+            try {
+                return sitemapResult.then((result) => result.site.siteInfo.sitemap);
+            }
+            catch (e) {
+                return Promise.reject(e);
+            }
+        });
+    }
+    /**
+     * Get sitemap file path for sitemap id
+     * @param {string} id the sitemap id (can be empty for default 'sitemap.xml' file)
+     * @returns {string | undefined} the sitemap file path or undefined if one doesn't exist
+     */
+    getSitemap(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchSitemap = `${PREFIX_NAME_SITEMAP}${id}.xml`;
+            const sitemaps = yield this.fetchSitemaps();
+            return sitemaps.find((sitemap) => sitemap.includes(searchSitemap));
+        });
+    }
+    /**
+     * 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.sitemap,
+        });
+    }
+}

package/dist/esm/site/index.js

@@ -0,0 +1,7 @@
+export { GraphQLRobotsService, } from './graphql-robots-service';
+export { REDIRECT_TYPE_301, REDIRECT_TYPE_302, REDIRECT_TYPE_SERVER_TRANSFER, GraphQLRedirectsService, } from './graphql-redirects-service';
+export { GraphQLSitemapXmlService, } from './graphql-sitemap-service';
+export { GraphQLErrorPagesService, } from './graphql-error-pages-service';
+export { GraphQLSiteInfoService, } from './graphql-siteinfo-service';
+export { getSiteRewrite, getSiteRewriteData, normalizeSiteRewrite } from './utils';
+export { SiteResolver } from './site-resolver';

package/dist/esm/site/site-resolver.js

@@ -0,0 +1,75 @@
+// Delimiters for multi-value hostnames
+const DELIMITERS = /\||,|;/g;
+/**
+ * Resolves site based on the provided host or site name
+ */
+export class SiteResolver {
+    /**
+     * @param {SiteInfo[]} sites Array of sites to be used in resolution
+     */
+    constructor(sites) {
+        this.sites = sites;
+        /**
+         * Resolve site by host name
+         * @param {string} hostName the host name
+         * @returns {SiteInfo} the resolved site
+         * @throws {Error} if a matching site is not found
+         */
+        this.getByHost = (hostName) => {
+            for (const [hostname, site] of this.getHostMap()) {
+                if (this.matchesPattern(hostName, hostname)) {
+                    return site;
+                }
+            }
+            throw new Error(`Could not resolve site for host ${hostName}`);
+        };
+        /**
+         * Resolve site by site name
+         * @param {string} siteName the site name
+         * @returns {SiteInfo} the resolved site
+         * @throws {Error} if a matching site is not found
+         */
+        this.getByName = (siteName) => {
+            const siteInfo = this.sites.find((info) => info.name.toLocaleLowerCase() === siteName.toLocaleLowerCase());
+            if (!siteInfo) {
+                throw new Error(`Could not resolve site for name ${siteName}`);
+            }
+            return siteInfo;
+        };
+        this.getHostMap = () => {
+            const map = new Map();
+            // First collect unique hostnames.
+            // For sites with same hostname defined, priority is given to the first encountered.
+            this.sites.forEach((site) => {
+                const hostnames = site.hostName
+                    .replace(/\s/g, '')
+                    .toLocaleLowerCase()
+                    .split(DELIMITERS);
+                hostnames.forEach((hostname) => {
+                    if (!map.has(hostname)) {
+                        map.set(hostname, site);
+                    }
+                });
+            });
+            // Now order by specificity.
+            // This equivalates to sorting from longest to shortest with the assumption
+            // that your match is less specific as wildcards are introduced.
+            // E.g. order.eu.site.com → *.eu.site.com → *.site.com → *
+            // In case of a tie (e.g. *.site.com vs i.site.com), prefer one with less wildcards.
+            return new Map(Array.from(map).sort((a, b) => {
+                if (a[0].length === b[0].length) {
+                    return (a[0].match(/\*/g) || []).length - (b[0].match(/\*/g) || []).length;
+                }
+                return b[0].length - a[0].length;
+            }));
+        };
+    }
+    // b[0].match(/\*/g) || []).length
+    matchesPattern(hostname, pattern) {
+        // dots should be treated as chars
+        // stars should be treated as wildcards
+        const regExpPattern = pattern.replace(/\./g, '\\.').replace(/\*/g, '.*');
+        const regExp = new RegExp(`^${regExpPattern}$`, 'gi');
+        return !!hostname.match(regExp);
+    }
+}

package/dist/esm/site/utils.js

@@ -0,0 +1,37 @@
+export const SITE_PREFIX = '_site_';
+/**
+ * Get a site rewrite path for given pathname
+ * @param {string} pathname the pathname
+ * @param {SiteRewriteData} data the site data to include in the rewrite
+ * @returns {string} the rewrite path
+ */
+export function getSiteRewrite(pathname, data) {
+    const path = pathname.startsWith('/') ? pathname : '/' + pathname;
+    return `/${SITE_PREFIX}${data.siteName}${path}`;
+}
+/**
+ * Get site data from the rewrite path
+ * @param {string} pathname the pathname
+ * @param {string} defaultSiteName the default site name
+ * @returns {SiteRewriteData} the site data from the rewrite
+ */
+export function getSiteRewriteData(pathname, defaultSiteName) {
+    const data = {
+        siteName: defaultSiteName,
+    };
+    const path = pathname.endsWith('/') ? pathname : pathname + '/';
+    const result = path.match(`${SITE_PREFIX}(.*?)\\/`);
+    if (result && result[1] !== '') {
+        data.siteName = result[1];
+    }
+    return data;
+}
+/**
+ * Normalize a site rewrite path (remove site data)
+ * @param {string} pathname the pathname
+ * @returns {string} the pathname with site data removed
+ */
+export function normalizeSiteRewrite(pathname) {
+    const result = pathname.match(`${SITE_PREFIX}.*?(?:\\/|$)`);
+    return result === null ? pathname : pathname.replace(result[0], '');
+}

package/dist/esm/utils/edit-frame.js

@@ -0,0 +1,133 @@
+export const DefaultEditFrameButtonIds = {
+    edit: '{70C4EED5-D4CD-4D7D-9763-80C42504F5E7}',
+};
+export const DefaultEditFrameButton = {
+    insert: {
+        header: 'Insert New',
+        icon: '/~/icon/Office/16x16/insert_from_template.png',
+        click: 'webedit:new',
+        tooltip: 'Insert a new item',
+    },
+    editRelatedItem: {
+        header: 'Edit the related item',
+        icon: '/~/icon/Office/16x16/cubes.png',
+        click: 'webedit:open',
+        tooltip: 'Edit the related item in the Content Editor.',
+    },
+    edit: {
+        header: 'Edit Item',
+        icon: '/~/icon/people/16x16/cubes_blue.png',
+        fields: ['Title', 'Text'],
+        tooltip: 'Edit the item fields.',
+    },
+};
+export const DefaultEditFrameButtons = [
+    DefaultEditFrameButton.editRelatedItem,
+    DefaultEditFrameButton.insert,
+    DefaultEditFrameButton.edit,
+];
+/**
+ * @param {WebEditButton | FieldEditButton} button the button to determine the type of
+ */
+function isWebEditButton(button) {
+    return button.click !== undefined;
+}
+/**
+ * Map the edit button types to chrome data
+ * @param {EditButtonTypes } button the edit button to build a ChromeCommand for
+ * @param {string} itemId the ID of the item the EditFrame is associated with
+ * @param {Record<string, string | number | boolean | undefined | null>} frameParameters additional parameters passed to the EditFrame
+ */
+export function mapButtonToCommand(button, itemId, frameParameters) {
+    if (button === '|' || button.isDivider) {
+        return {
+            click: 'chrome:dummy',
+            header: 'Separator',
+            icon: '',
+            isDivider: true,
+            tooltip: null,
+            type: 'separator',
+        };
+    }
+    else if (isWebEditButton(button)) {
+        return commandBuilder(button, itemId, frameParameters);
+    }
+    else {
+        const fieldsString = button.fields.join('|');
+        const editButton = Object.assign({ click: `webedit:fieldeditor(command=${DefaultEditFrameButtonIds.edit},fields=${fieldsString})` }, button);
+        return commandBuilder(editButton, itemId, frameParameters);
+    }
+}
+/**
+ * Build a ChromeCommand from a web edit button. Merging the parameters from the button, frame and id
+ * @param {WebEditButton } button the web edit button to build a ChromeCommand for
+ * @param {string} itemId the ID of the item the EditFrame is associated with
+ * @param {Record<string, string>} frameParameters additional parameters passed to the EditFrame
+ */
+export function commandBuilder(button, itemId, frameParameters) {
+    if (!button.click) {
+        return Object.assign({ isDivider: false, type: button.type || null, header: button.header || '', icon: button.icon || '', tooltip: button.tooltip || '' }, button);
+    }
+    else if (button.click.startsWith('javascript:') || button.click.startsWith('chrome:')) {
+        return Object.assign({ isDivider: false, type: button.type || null, header: button.header || '', icon: button.icon || '', tooltip: button.tooltip || '' }, button);
+    }
+    else {
+        if (!itemId) {
+            return Object.assign({ isDivider: false, type: button.type || null, header: button.header || '', icon: button.icon || '', tooltip: button.tooltip || '' }, button);
+        }
+        else {
+            let message = button.click;
+            let parameters = {};
+            // Extract any parameters already in the command
+            const length = button.click.indexOf('(');
+            if (length >= 0) {
+                const end = button.click.indexOf(')');
+                if (end < 0) {
+                    throw new Error('Message with arguments must end with ")".');
+                }
+                parameters = button.click
+                    .substring(length + 1, end)
+                    .split(',')
+                    .map((_) => _.trim())
+                    .reduce((previous, current) => {
+                    const parts = current.split('=');
+                    if (parts.length < 2) {
+                        previous[parts[0]] = '';
+                    }
+                    else {
+                        previous[parts[0]] = parts[1];
+                    }
+                    return previous;
+                }, {});
+                message = button.click.substring(0, length);
+            }
+            parameters.id = itemId;
+            if (button.parameters) {
+                Object.keys(button.parameters).forEach((_) => {
+                    var _a;
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    parameters[_] = ((_a = button.parameters[_]) === null || _a === void 0 ? void 0 : _a.toString()) || '';
+                });
+            }
+            if (frameParameters) {
+                Object.keys(frameParameters).forEach((_) => {
+                    var _a;
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    parameters[_] = ((_a = frameParameters[_]) === null || _a === void 0 ? void 0 : _a.toString()) || '';
+                });
+            }
+            const parameterString = Object.keys(parameters)
+                .map((_) => `${_}=${parameters[_]}`)
+                .join(', ');
+            const click = `${message}(${parameterString})`;
+            return {
+                isDivider: false,
+                click: `javascript:Sitecore.PageModes.PageEditor.postRequest('${click}',null,false)`,
+                header: button.header || '',
+                icon: button.icon || '',
+                tooltip: button.tooltip || '',
+                type: button.type || null,
+            };
+        }
+    }
+}

package/dist/esm/utils/editing.js

@@ -0,0 +1,111 @@
+import isServer from './is-server';
+/**
+ * Static utility class for Sitecore Experience Editor
+ */
+export class ExperienceEditor {
+    /**
+     * Determines whether the current execution context is within a Experience Editor.
+     * Experience Editor environment can be identified only in the browser
+     * @returns true if executing within a Experience Editor
+     */
+    static isActive() {
+        if (isServer()) {
+            return false;
+        }
+        // eslint-disable-next-line
+        const sc = window.Sitecore;
+        return Boolean(sc && sc.PageModes && sc.PageModes.ChromeManager);
+    }
+    static resetChromes() {
+        if (isServer()) {
+            return;
+        }
+        window.Sitecore.PageModes.ChromeManager.resetChromes();
+    }
+}
+/**
+ * Copy of chrome rediscovery contract from Horizon (chrome-rediscovery.contract.ts)
+ */
+export const ChromeRediscoveryGlobalFunctionName = {
+    name: 'Sitecore.Horizon.ResetChromes',
+};
+/**
+ * Static utility class for Sitecore Horizon Editor
+ */
+export class HorizonEditor {
+    /**
+     * Determines whether the current execution context is within a Horizon Editor.
+     * Horizon Editor environment can be identified only in the browser
+     * @returns true if executing within a Horizon Editor
+     */
+    static isActive() {
+        if (isServer()) {
+            return false;
+        }
+        // Horizon will add "sc_horizon=editor" query string parameter for the editor and "sc_horizon=simulator" for the preview
+        return window.location.search.indexOf('sc_horizon=editor') > -1;
+    }
+    static resetChromes() {
+        if (isServer()) {
+            return;
+        }
+        // Reset chromes in Horizon
+        window[ChromeRediscoveryGlobalFunctionName.name] &&
+            window[ChromeRediscoveryGlobalFunctionName.name]();
+    }
+}
+/**
+ * Determines whether the current execution context is within a Sitecore editor.
+ * Sitecore Editor environment can be identified only in the browser
+ * @returns true if executing within a Sitecore editor
+ */
+export const isEditorActive = () => {
+    return ExperienceEditor.isActive() || HorizonEditor.isActive();
+};
+/**
+ * Resets Sitecore editor "chromes"
+ */
+export const resetEditorChromes = () => {
+    if (ExperienceEditor.isActive()) {
+        ExperienceEditor.resetChromes();
+    }
+    else if (HorizonEditor.isActive()) {
+        HorizonEditor.resetChromes();
+    }
+};
+/**
+ * @description in Experience Editor, anchor tags
+ * with both onclick and href attributes will use the href, blocking the onclick from firing.
+ * This function makes it so the anchor tags function as intended in the sample when using Experience Editor
+ *
+ * The Mutation Observer API is used to observe changes to the body, then select all elements with href="#" and an onclick,
+ * and replaces the # value with javascript:void(0); which prevents the anchor tag from blocking the onclick event handler.
+ * @see Mutation Observer API: https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver/MutationObserver
+ */
+export const handleEditorAnchors = () => {
+    // The sample gives the href attribute priority over the onclick attribute if both are present, so we must replace
+    // the href attribute to avoid overriding the onclick in Experience Editor
+    if (!window || !ExperienceEditor.isActive()) {
+        return;
+    }
+    const targetNode = document.querySelector('body');
+    const callback = (mutationList) => {
+        mutationList.forEach((mutation) => {
+            const btns = document.querySelectorAll('.scChromeDropDown > a[href="#"], .scChromeDropDown > a[href="#!"], a[onclick]');
+            if (mutation.type === 'childList') {
+                btns.forEach((link) => {
+                    link.href = 'javascript:void(0);';
+                });
+            }
+            return;
+        });
+    };
+    const observer = new MutationObserver(callback);
+    const observerOptions = {
+        childList: true,
+        subtree: true,
+    };
+    if (targetNode) {
+        observer.observe(targetNode, observerOptions);
+    }
+};

package/dist/esm/utils/env.js

@@ -0,0 +1,22 @@
+/**
+ * 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);
+        }
+        catch (error) {
+            console.warn('Parsing of env variable failed');
+            console.warn(`Attempted to parse ${envValue}`);
+            return defaultValue;
+        }
+    }
+    return defaultValue;
+};

package/dist/esm/utils/index.js

@@ -0,0 +1,5 @@
+export { default as isServer } from './is-server';
+export { resolveUrl, isAbsoluteUrl, isTimeoutError } from './utils';
+export { tryParseEnvValue } from './env';
+export { ExperienceEditor, HorizonEditor, isEditorActive, resetEditorChromes, handleEditorAnchors, } from './editing';
+export { DefaultEditFrameButton, DefaultEditFrameButtons, DefaultEditFrameButtonIds, mapButtonToCommand, } from './edit-frame';

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

@@ -0,0 +1,8 @@
+/**
+ * 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;