@sitecore-content-sdk/content 1.5.0-canary.10

package/dist/esm/client/edge-proxy.js

@@ -0,0 +1,24 @@
+import { constants } from '@sitecore-content-sdk/core';
+import { normalizeUrl } from '@sitecore-content-sdk/core/tools';
+/**
+ * Resolves the base Edge URL from config. Caller should pass the resolved Edge URL from config.
+ * @param {string} [sitecoreEdgeUrl] - The base Edge URL from config. Defaults to platform URL.
+ * @internal
+ */
+const getBaseEdgeUrl = (sitecoreEdgeUrl = constants.SITECORE_EDGE_PLATFORM_URL_DEFAULT) => normalizeUrl(sitecoreEdgeUrl);
+/**
+ * Generates a URL for accessing Sitecore Edge Platform Content using the provided endpoint and context ID.
+ * @param {string} [sitecoreEdgeUrl] - The base endpoint URL for the Edge Platform (resolved at config level). Defaults to platform URL.
+ * @returns {string} The complete URL for accessing content through the Edge Platform.
+ * @public
+ */
+export const getEdgeProxyContentUrl = (sitecoreEdgeUrl = constants.SITECORE_EDGE_PLATFORM_URL_DEFAULT) => `${getBaseEdgeUrl(sitecoreEdgeUrl)}/v1/content/api/graphql/v1`;
+/**
+ * Generates a URL for accessing Sitecore Edge Platform Forms using the provided form ID and context ID.
+ * @param {string} sitecoreEdgeContextId - The unique context id.
+ * @param {string} formId - The unique form id.
+ * @param {string} [sitecoreEdgeUrl] - The base endpoint URL for the Edge Platform (resolved at config level). Defaults to platform URL.
+ * @returns {string} The complete URL for accessing forms through the Edge Platform.
+ * @internal
+ */
+export const getEdgeProxyFormsUrl = (sitecoreEdgeContextId, formId, sitecoreEdgeUrl = constants.SITECORE_EDGE_PLATFORM_URL_DEFAULT) => `${getBaseEdgeUrl(sitecoreEdgeUrl)}/v1/forms/publisher/${formId}?sitecoreContextId=${sitecoreEdgeContextId}`;

package/dist/esm/client/index.js

@@ -0,0 +1,4 @@
+export { GraphQLRequestClient, DefaultRetryStrategy } from '@sitecore-content-sdk/core';
+export { getEdgeProxyContentUrl, getEdgeProxyFormsUrl } from './edge-proxy';
+export { SitecoreClient, ErrorPage, } from './sitecore-client';
+export { createGraphQLClientFactory } from './utils';

package/dist/esm/client/models.js

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

package/dist/esm/client/sitecore-client.js

@@ -0,0 +1,439 @@
+import { NativeDataFetcher, debug, } from '@sitecore-content-sdk/core';
+import { resolveEdgeUrlForStaticFiles, resolveExperienceEdgeUrl, } from '@sitecore-content-sdk/core/tools';
+import { DictionaryService } from '../i18n';
+import { getDesignLibraryStylesheetLinks, getContentStylesheetLink, LayoutService, LayoutServicePageState, rewriteEdgeHostInResponse, getDefaultMediaUrlTransformer, applyMediaUrlRewrite, } from '../layout';
+import { getGroomedVariantIds } from '../personalize/utils';
+import { personalizeLayout } from '../personalize/layout-personalizer';
+import { ErrorPagesService, SitePathService, SitemapXmlService } from '../site';
+import { createGraphQLClientFactory } from './utils';
+import { RobotsService } from '../site/robots-service';
+import { DesignLibraryVariantGeneration } from '../editing/models';
+import { EditingService, ComponentLayoutService, DesignLibraryMode, } from '../editing';
+/**
+ * Error page codes
+ * @public
+ */
+export var ErrorPage;
+(function (ErrorPage) {
+    ErrorPage["NotFound"] = "404";
+    ErrorPage["InternalServerError"] = "500";
+})(ErrorPage || (ErrorPage = {}));
+/**
+ * This is a generic content client that can be used by any framework.
+ * Use it to retrieve pages, preview data, dictionary and other data
+ * @public
+ */
+export class SitecoreClient {
+    /**
+     * Init SitecoreClient
+     * @param {SitecoreClientInit} initOptions initOptions for the client, containing site and Sitecore connection details
+     */
+    constructor(initOptions) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        this.initOptions = initOptions;
+        this.clientFactory = this.getClientFactory();
+        this.graphQLClient = this.clientFactory({
+            debugger: debug.http,
+        });
+        const baseServiceOptions = this.getBaseServiceOptions();
+        this.layoutService =
+            (_b = (_a = initOptions.custom) === null || _a === void 0 ? void 0 : _a.layoutService) !== null && _b !== void 0 ? _b : this.getLayoutService(baseServiceOptions);
+        this.dictionaryService =
+            (_d = (_c = initOptions.custom) === null || _c === void 0 ? void 0 : _c.dictionaryService) !== null && _d !== void 0 ? _d : this.getDictionaryService(baseServiceOptions);
+        this.editingService = (_f = (_e = initOptions.custom) === null || _e === void 0 ? void 0 : _e.editingService) !== null && _f !== void 0 ? _f : this.getEditingService();
+        this.errorPagesService = (_h = (_g = initOptions.custom) === null || _g === void 0 ? void 0 : _g.errorPagesService) !== null && _h !== void 0 ? _h : this.getErrorPagesService();
+        this.sitePathService = (_k = (_j = initOptions.custom) === null || _j === void 0 ? void 0 : _j.sitePathService) !== null && _k !== void 0 ? _k : this.getSitePathService();
+        this.componentService = this.getComponentService();
+    }
+    /**
+     * Normalize path regardless of type
+     * @param {string | string[]} path string or string array path
+     * @returns {string} string path
+     */
+    parsePath(path) {
+        // join array path, while clearing extra slashes and ensure first slash
+        return typeof path === 'string'
+            ? path.startsWith('/')
+                ? path
+                : `/${path}`
+            : `/${path
+                .filter((part) => part !== '/')
+                .map((part) => part.replace(/^\/+/, '').replace(/\/+$/, ''))
+                .join('/')}`;
+    }
+    /**
+     * Execute a raw GraphQL request using the client's configured GraphQL Edge endpoint.
+     * This is a thin pass-through to the underlying `GraphQLClient.request` method,
+     * @param {string | DocumentNode} query GraphQL query
+     * @param {Record<string, unknown>} [variables] Optional variables bag
+     * @param {FetchOptions} [fetchOptions] Optional fetch overrides (e.g. fetch, headers)
+     */
+    getData(query, variables, fetchOptions) {
+        return this.graphQLClient.request(query, variables, fetchOptions);
+    }
+    /**
+     * Get page details for a route, with layout and other details
+     * @param {string} path route path
+     * @param {PageOptions} [pageOptions] site, language and personalization variant details for route
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
+     * @returns {Page | null} page details
+     */
+    async getPage(path, pageOptions, fetchOptions) {
+        var _a, _b, _c, _d;
+        const computedPath = this.parsePath(path);
+        const locale = (_a = pageOptions === null || pageOptions === void 0 ? void 0 : pageOptions.locale) !== null && _a !== void 0 ? _a : this.initOptions.defaultLanguage;
+        const site = (_b = pageOptions === null || pageOptions === void 0 ? void 0 : pageOptions.site) !== null && _b !== void 0 ? _b : this.initOptions.defaultSite;
+        // Fetch layout data, passing on req/res for SSR
+        let layout = await this.layoutService.fetchLayoutData(computedPath, {
+            locale,
+            site,
+        }, fetchOptions);
+        if (!layout.sitecore.route) {
+            return null;
+        }
+        // Apply personalization first to select the variant(s) that will be used,
+        // then rewrite content URLs so we only process the selected variant(s)
+        if ((_c = pageOptions === null || pageOptions === void 0 ? void 0 : pageOptions.personalize) === null || _c === void 0 ? void 0 : _c.variantId) {
+            personalizeLayout(layout, pageOptions.personalize.variantId, pageOptions.personalize.componentVariantIds);
+        }
+        layout = this.applyContentRewrite(layout);
+        return {
+            layout,
+            siteName: ((_d = layout.sitecore.context.site) === null || _d === void 0 ? void 0 : _d.name) || site,
+            locale,
+            mode: this.getPageMode(LayoutServicePageState.Normal),
+        };
+    }
+    /**
+     * Retrieves the head `<link>` elements for Sitecore styles and themes.
+     * @param {LayoutServiceData} layoutData - The layout data containing styles and themes.
+     * @param {object} [options] - Optional configuration for enabling styles and themes.
+     * @param {boolean} [options.enableStyles] - Whether to include content styles.
+     * @param {boolean} [options.enableThemes] - Whether to include theme styles.
+     * @returns {HTMLLink[]} An array of `<link>` elements for stylesheets.
+     */
+    getHeadLinks(layoutData, options = {}) {
+        const { enableStyles = true, enableThemes = true } = options;
+        const { contextId: serverContextId, clientContextId } = this.initOptions.api.edge;
+        const headLinks = [];
+        const contextId = serverContextId || clientContextId;
+        // Use default Edge URL for styles (ignore custom hostname) so stylesheets load from platform
+        const edgeUrlForStyles = resolveEdgeUrlForStaticFiles();
+        if (enableStyles) {
+            const contentStyles = getContentStylesheetLink(layoutData, contextId, edgeUrlForStyles);
+            if (contentStyles)
+                headLinks.push(contentStyles);
+        }
+        if (enableThemes) {
+            headLinks.push(...getDesignLibraryStylesheetLinks(layoutData, contextId, edgeUrlForStyles));
+        }
+        return headLinks;
+    }
+    /**
+     * Retrieves dictionary phrases for a given site and locale.
+     * @param {RouteOptions} routeOptions - Route options containing language and site name to load dictionary for
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
+     * @returns {DictionaryPhrases} A promise that resolves to the dictionary phrases.
+     */
+    async getDictionary(routeOptions, fetchOptions) {
+        const locale = (routeOptions === null || routeOptions === void 0 ? void 0 : routeOptions.locale) || this.initOptions.defaultLanguage;
+        const site = (routeOptions === null || routeOptions === void 0 ? void 0 : routeOptions.site) || this.initOptions.defaultSite;
+        return await this.dictionaryService.fetchDictionaryData(locale, site, fetchOptions);
+    }
+    /**
+     * Retrieves error pages for a given site and locale.
+     * @param {RouteOptions} routeOptions - Route options containing language and site name to load error pages
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
+     * @returns {ErrorPages | null} A promise that resolves to the error pages or null if not found.
+     */
+    async getErrorPages(routeOptions, fetchOptions) {
+        const locale = (routeOptions === null || routeOptions === void 0 ? void 0 : routeOptions.locale) || this.initOptions.defaultLanguage;
+        const site = (routeOptions === null || routeOptions === void 0 ? void 0 : routeOptions.site) || this.initOptions.defaultSite;
+        return await this.errorPagesService.fetchErrorPages(site, locale, fetchOptions);
+    }
+    /**
+     * Retrieves preview page and layout details
+     * @param {EditingPreviewData | undefined} previewData - The editing preview data for metadata mode.
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
+     * @returns {Page} preview page details
+     */
+    async getPreview(previewData, fetchOptions) {
+        var _a;
+        if (!previewData) {
+            console.error('Preview data missing');
+            return null;
+        }
+        // If we're in Pages preview (editing) mode, prefetch the editing data
+        const { site, itemId, language, version, layoutKind, mode } = previewData;
+        const variantIds = Array.isArray(previewData.variantIds)
+            ? previewData.variantIds
+            : previewData.variantIds.split(',');
+        const data = await this.editingService.fetchEditingData({
+            itemId,
+            language,
+            version,
+            layoutKind,
+            mode,
+        }, fetchOptions);
+        if (!data) {
+            throw new Error(`Unable to fetch editing data for preview ${JSON.stringify(previewData)}`);
+        }
+        let layout = data.layoutData;
+        const personalizeData = getGroomedVariantIds(variantIds);
+        personalizeLayout(layout, personalizeData.variantId, personalizeData.componentVariantIds);
+        layout = this.applyContentRewrite(layout);
+        const page = {
+            locale: language,
+            layout,
+            siteName: ((_a = layout.sitecore.context.site) === null || _a === void 0 ? void 0 : _a.name) || site,
+            mode: this.getPageMode(mode),
+        };
+        return page;
+    }
+    /**
+     * Get design library page details for Design Library mode of your app
+     * @param {DesignLibraryRenderPreviewData} designLibData preview data set in 'library' mode of the app
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
+     * @returns {Page} preview page for Design Library
+     */
+    async getDesignLibraryData(designLibData, fetchOptions) {
+        var _a;
+        if (!this.initOptions.api.local) {
+            throw new Error('Component Library requires Sitecore apiHost and apiKey to be provided');
+        }
+        const { itemId, componentUid, site, language, renderingId, dataSourceId, version, mode, generation, } = designLibData;
+        const componentData = await this.componentService.fetchComponentData(Object.assign({ siteName: site, itemId,
+            language,
+            componentUid,
+            renderingId,
+            dataSourceId,
+            version,
+            mode }, (generation ? { generation } : {})), fetchOptions);
+        if (!componentData) {
+            throw new Error(`Unable to fetch editing data for preview ${JSON.stringify(designLibData)}`);
+        }
+        const layout = this.applyContentRewrite(componentData);
+        const page = {
+            locale: designLibData.language,
+            layout,
+            siteName: ((_a = layout.sitecore.context.site) === null || _a === void 0 ? void 0 : _a.name) || site,
+            mode: this.getPageMode(mode, generation),
+        };
+        return page;
+    }
+    /**
+     * Get error page details for a given error code
+     * @param {ErrorPage} code - The error code to get the error page for
+     * @param {Partial<RouteOptions>} pageOptions - The page options to get the error page for
+     * @param {FetchOptions} [fetchOptions] - Additional fetch fetch options to override GraphQL requests
+     * @returns {Promise<Page | null>} A promise that resolves to the error page details or null if not found
+     */
+    async getErrorPage(code, pageOptions, fetchOptions) {
+        var _a, _b;
+        const locale = (pageOptions === null || pageOptions === void 0 ? void 0 : pageOptions.locale) || this.initOptions.defaultLanguage;
+        const site = (pageOptions === null || pageOptions === void 0 ? void 0 : pageOptions.site) || this.initOptions.defaultSite;
+        const result = await this.getErrorPages({
+            site,
+            locale,
+        }, fetchOptions);
+        let layout = null;
+        switch (code) {
+            case ErrorPage.NotFound:
+                layout = ((_a = result === null || result === void 0 ? void 0 : result.notFoundPage) === null || _a === void 0 ? void 0 : _a.rendered) || null;
+                break;
+            case ErrorPage.InternalServerError:
+                layout = ((_b = result === null || result === void 0 ? void 0 : result.serverErrorPage) === null || _b === void 0 ? void 0 : _b.rendered) || null;
+                break;
+            default:
+                return null;
+        }
+        if (!layout) {
+            return null;
+        }
+        layout = this.applyContentRewrite(layout);
+        return {
+            layout,
+            locale,
+            mode: this.getPageMode(LayoutServicePageState.Normal),
+            siteName: site,
+        };
+    }
+    /**
+     * Retrieves the static paths for pages based on the given languages.
+     * @param {string[]} sites - An array of site names to fetch routes for.
+     * @param {string[]} [languages] - An optional array of language codes to generate paths for.
+     * @param {FetchOptions} [fetchOptions] - Additional fetch options.
+     * @returns {Promise<StaticPath[]>} A promise that resolves to an array of static paths.
+     */
+    async getPagePaths(sites, languages, fetchOptions) {
+        return this.sitePathService.fetchSiteRoutes(sites, languages || [], fetchOptions);
+    }
+    /**
+     * Retrieves sitemap XML content - either a specific sitemap or the index of all sitemaps.
+     * @param {SitemapXmlOptions} reqOptions - Options for sitemap retrieval
+     * @param {FetchOptions} [fetchOptions] - Additional fetch options.
+     * @returns {Promise<string>} Promise resolving to the sitemap XML content as string
+     * @throws {Error} Throws 'REDIRECT_404' if requested sitemap is not found
+     */
+    async getSiteMap(reqOptions, fetchOptions) {
+        const { reqHost, reqProtocol, id, siteName } = reqOptions;
+        // create sitemap graphql service
+        const sitemapXmlService = this.getGraphqlSitemapXMLService(siteName || this.initOptions.defaultSite);
+        // The id is present if url has sitemap-{n}.xml type.
+        // The id can be null if it's index sitemap.xml request
+        const sitemapPath = await sitemapXmlService.getSitemap(id);
+        // regular sitemap
+        if (sitemapPath) {
+            try {
+                const experienceEdgeUrl = resolveExperienceEdgeUrl();
+                const rewrittenSitemapPath = rewriteEdgeHostInResponse(sitemapPath, experienceEdgeUrl);
+                const fetcher = new NativeDataFetcher();
+                const xmlResponse = await fetcher.fetch(rewrittenSitemapPath);
+                if (!xmlResponse.data) {
+                    throw new Error('REDIRECT_404');
+                }
+                return rewriteEdgeHostInResponse(xmlResponse.data, experienceEdgeUrl);
+                // eslint-disable-next-line no-unused-vars
+            }
+            catch (error) {
+                throw new Error('REDIRECT_404');
+            }
+        }
+        // index /sitemap.xml that includes links to all sitemaps
+        const sitemaps = await sitemapXmlService.fetchSitemaps(fetchOptions);
+        if (!sitemaps.length) {
+            throw new Error('REDIRECT_404');
+        }
+        return `<?xml version="1.0" encoding="UTF-8"?>
+      <sitemapindex xmlns="http://sitemaps.org/schemas/sitemap/0.9">
+      ${sitemaps
+            .map((item) => {
+            const parseUrl = item.split('/');
+            const lastSegment = parseUrl[parseUrl.length - 1];
+            const escapedUrl = `${reqProtocol}://${reqHost}/${lastSegment}`.replace(/&/g, '&amp;');
+            return `<sitemap><loc>${escapedUrl}</loc></sitemap>`;
+        })
+            .join('')}
+      </sitemapindex>`;
+    }
+    /**
+     * Retrieves the robots.txt content for a given site name.
+     * @param {string} siteName - The name of the site to retrieve the robots.txt for.
+     * @param {FetchOptions} [fetchOptions] - Optional fetch options.
+     * @returns {Promise<string | null>} A promise that resolves to the robots.txt content,
+     * or null if no content is found.
+     */
+    async getRobots(siteName, fetchOptions) {
+        const robotsService = this.getRobotsService(siteName || this.initOptions.defaultSite);
+        const content = await robotsService.fetchRobots(fetchOptions);
+        return content || null;
+    }
+    /**
+     * Factory methods for creating dependencies
+     * Subclasses can override these to provide custom implementations.
+     */
+    getGraphqlSitemapXMLService(siteName) {
+        return new SitemapXmlService({
+            clientFactory: this.clientFactory,
+            siteName,
+        });
+    }
+    getRobotsService(siteName) {
+        return new RobotsService({
+            clientFactory: this.clientFactory,
+            siteName,
+        });
+    }
+    getBaseServiceOptions() {
+        return {
+            defaultSite: this.initOptions.defaultSite,
+            clientFactory: this.clientFactory,
+            retries: this.initOptions.retries,
+        };
+    }
+    /**
+     * Get page mode based on mode name
+     * @param {PageModeName} mode - The mode name to get the page mode for
+     * @param { DesignLibraryVariantGeneration} generation - The variant generation mode, if applicable
+     * @returns {PageMode} The page mode
+     */
+    /**
+     * Applies media URL rewrite when rewriteMediaUrls is enabled.
+     * When true, uses default Edge host rewriter; when a function, transforms each string.
+     * @param {LayoutServiceData} layout - Layout data from layout/editing/component/error service
+     * @returns {LayoutServiceData} Rewritten layout (or same reference if rewrite disabled)
+     * @internal
+     */
+    applyContentRewrite(layout) {
+        const opt = this.initOptions.rewriteMediaUrls;
+        if (!opt) {
+            return layout;
+        }
+        const experienceEdgeUrl = resolveExperienceEdgeUrl();
+        const transformer = opt === true ? getDefaultMediaUrlTransformer(experienceEdgeUrl) : opt;
+        return applyMediaUrlRewrite(layout, transformer);
+    }
+    getPageMode(mode, generation) {
+        const pageMode = {
+            name: mode,
+            isNormal: false,
+            isPreview: false,
+            isEditing: false,
+            isDesignLibrary: false,
+            designLibrary: { isVariantGeneration: false },
+        };
+        switch (mode) {
+            case LayoutServicePageState.Normal:
+                pageMode.isNormal = true;
+                break;
+            case LayoutServicePageState.Preview:
+                pageMode.isPreview = true;
+                break;
+            case LayoutServicePageState.Edit:
+                pageMode.isEditing = true;
+                break;
+            case DesignLibraryMode.Normal:
+                pageMode.isDesignLibrary = true;
+                break;
+            case DesignLibraryMode.Metadata:
+                pageMode.isDesignLibrary = true;
+                pageMode.isEditing = true;
+                break;
+            default:
+                break;
+        }
+        if (pageMode.isDesignLibrary && generation === DesignLibraryVariantGeneration.Variant) {
+            pageMode.designLibrary.isVariantGeneration = true;
+            pageMode.isEditing = true;
+        }
+        return pageMode;
+    }
+    getClientFactory() {
+        const graphQLOptions = {
+            api: this.initOptions.api,
+            retries: this.initOptions.retries.count,
+            retryStrategy: this.initOptions.retries.retryStrategy,
+        };
+        return createGraphQLClientFactory(graphQLOptions);
+    }
+    getLayoutService(baseOptions) {
+        return new LayoutService(Object.assign(Object.assign({}, baseOptions), { formatLayoutQuery: this.initOptions.layout.formatLayoutQuery }));
+    }
+    getDictionaryService(baseOptions) {
+        return new DictionaryService(Object.assign(Object.assign({}, baseOptions), { cacheEnabled: this.initOptions.dictionary.caching.enabled, cacheTimeout: this.initOptions.dictionary.caching.timeout }));
+    }
+    getEditingService() {
+        return new EditingService({ clientFactory: this.clientFactory });
+    }
+    getErrorPagesService() {
+        return new ErrorPagesService(Object.assign(Object.assign({}, this.initOptions), { language: this.initOptions.defaultLanguage, clientFactory: this.clientFactory }));
+    }
+    getComponentService() {
+        return new ComponentLayoutService(this.initOptions.api.edge);
+    }
+    getSitePathService() {
+        return new SitePathService({
+            clientFactory: this.clientFactory,
+        });
+    }
+}

package/dist/esm/client/utils.js

@@ -0,0 +1,49 @@
+import { GraphQLRequestClient, } from '@sitecore-content-sdk/core';
+import { getEdgeProxyContentUrl } from './edge-proxy';
+/**
+ * Creates a new GraphQLRequestClientFactory instance
+ * @param {GraphQLClientOptions} options content sdk config
+ * @returns GraphQLRequestClientFactory instance
+ * @public
+ */
+export const createGraphQLClientFactory = (options) => {
+    let clientConfig;
+    const { api } = options;
+    const { edge, local } = api !== null && api !== void 0 ? api : {};
+    const isBrowser = typeof window !== 'undefined';
+    if (edge === null || edge === void 0 ? void 0 : edge.contextId) {
+        // Real client for server-side rendering / API routes
+        clientConfig = {
+            endpoint: getEdgeProxyContentUrl(edge.edgeUrl),
+            contextId: edge.contextId,
+        };
+    }
+    else if (isBrowser && (edge === null || edge === void 0 ? void 0 : edge.clientContextId)) {
+        // Real client for client-side requests
+        clientConfig = {
+            endpoint: getEdgeProxyContentUrl(edge.edgeUrl),
+            contextId: edge.clientContextId,
+        };
+    }
+    else if ((local === null || local === void 0 ? void 0 : local.apiKey) && (local === null || local === void 0 ? void 0 : local.apiHost)) {
+        // Fallback to local API settings
+        clientConfig = {
+            endpoint: `${local.apiHost}${local.path}`,
+            apiKey: local.apiKey,
+        };
+    }
+    else if (isBrowser) {
+        // Browser bundle has no IDs – initialise a dummy client and warn
+        /* eslint-disable no-console */
+        console.warn('GraphQL client initialised in the browser without Edge or local API configuration; client-side requests may fail.');
+        clientConfig = { endpoint: '/api/graphql' };
+    }
+    else {
+        throw new Error(`GraphQL client misconfigured.
+      Configure one of the following in sitecore.config or your .env file:
+      Edge mode: set both sitecore.edge.contextId (server-side) and sitecore.edge.clientContextId (browser).
+      Local API mode: set api.local.apiHost and api.local.apiKey.
+      Supplying only api.edge.clientContextId will cause the application to fail at runtime.`);
+    }
+    return GraphQLRequestClient.createClientFactory(Object.assign(Object.assign({}, clientConfig), options));
+};