@sitecore-content-sdk/core 0.1.0-beta.1

package/dist/esm/editing/models.js

@@ -0,0 +1,20 @@
+/**
+ * Represents the Editing Layout variant.
+ * - shared - shared layout
+ * - final - final layout
+ */
+export var LayoutKind;
+(function (LayoutKind) {
+    LayoutKind["Final"] = "final";
+    LayoutKind["Shared"] = "shared";
+})(LayoutKind || (LayoutKind = {}));
+/**
+ * Represents the kind of metadata element.
+ * - open - starting chrome element
+ * - close - closing chrome element
+ */
+export var MetadataKind;
+(function (MetadataKind) {
+    MetadataKind["Open"] = "open";
+    MetadataKind["Close"] = "close";
+})(MetadataKind || (MetadataKind = {}));

package/dist/esm/editing/rest-component-layout-service.js

@@ -0,0 +1,72 @@
+import { debug, NativeDataFetcher } from '..';
+import { fetchData } from '../data-fetcher';
+/**
+ * REST service that enables Component Library functioality
+ * Makes a request to /sitecore/api/layout/component in 'library' mode in Pages.
+ * Returns layoutData for one single rendered component
+ */
+export class RestComponentLayoutService {
+    constructor(config) {
+        this.config = config;
+        this.getFetcher = (req, res) => {
+            return this.config.dataFetcherResolver
+                ? this.config.dataFetcherResolver(req, res)
+                : this.getDefaultFetcher(req);
+        };
+        /**
+         * Provides default @see NativeDataFetcher data fetcher
+         * @param {IncomingMessage} [req] Request instance
+         * @returns default fetcher
+         */
+        this.getDefaultFetcher = (req) => {
+            var _a;
+            const config = {
+                debugger: debug.editing,
+            };
+            const nativeFetcher = new NativeDataFetcher(config);
+            const headers = req && Object.assign(Object.assign({}, req.headers), (((_a = req.socket) === null || _a === void 0 ? void 0 : _a.remoteAddress) ? { 'X-Forwarded-For': req.socket.remoteAddress } : {}));
+            const fetcher = (url, data) => {
+                data = Object.assign(Object.assign({}, data), { headers: headers });
+                return nativeFetcher.fetch(url, data);
+            };
+            return fetcher;
+        };
+    }
+    fetchComponentData(params, req, res) {
+        params.siteName = params.siteName || this.config.siteName;
+        const querystringParams = this.getComponentFetchParams(params);
+        debug.layout('fetching component with uid %s for %s %s %s', params.componentUid, params.itemId, params.language, params.siteName);
+        const fetcher = this.getFetcher(req, res);
+        const fetchUrl = this.resolveLayoutServiceUrl('component');
+        return fetchData(fetchUrl, fetcher, querystringParams).catch((error) => {
+            var _a;
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                return error.response.data;
+            }
+            throw error;
+        });
+    }
+    /**
+     * Resolves layout service url
+     * @param {string} apiType which layout service API to call ('render' or 'placeholder')
+     * @returns the layout service url
+     */
+    resolveLayoutServiceUrl(apiType) {
+        const { apiHost = '', configurationName = 'jss' } = this.config;
+        return `${apiHost}/sitecore/api/layout/${apiType}/${configurationName}`;
+    }
+    getComponentFetchParams(params) {
+        // exclude undefined params with this one simple trick
+        return JSON.parse(JSON.stringify({
+            sc_apikey: this.config.apiKey,
+            item: params.itemId,
+            uid: params.componentUid,
+            dataSourceId: params.dataSourceId,
+            renderingItemId: params.renderingId,
+            version: params.version,
+            sc_site: params.siteName,
+            sc_lang: params.language || 'en',
+            sc_mode: params.editMode,
+        }));
+    }
+}

package/dist/esm/editing/utils.js

@@ -0,0 +1,76 @@
+import isServer from '../utils/is-server';
+/**
+ * Default value of uid for root placeholder when uid is not present.
+ */
+export const DEFAULT_PLACEHOLDER_UID = '00000000-0000-0000-0000-000000000000';
+/**
+ * Query parameter for editing secret
+ */
+export const QUERY_PARAM_EDITING_SECRET = 'secret';
+/**
+ * ID to be used as a marker for a script rendered in XMC Pages
+ * Should identify app is in XM Cloud Pages editing mode
+ */
+export const PAGES_EDITING_MARKER = 'jss-hrz-editing';
+/**
+ * Default allowed origins for editing requests. This is used to enforce CORS, CSP headers.
+ */
+export const EDITING_ALLOWED_ORIGINS = ['https://pages.sitecorecloud.io'];
+/**
+ * Copy of chrome rediscovery contract from Horizon (chrome-rediscovery.contract.ts)
+ */
+export const ChromeRediscoveryGlobalFunctionName = {
+    name: 'Sitecore.Horizon.ResetChromes',
+};
+/**
+ * Static utility class for Sitecore Pages Editor
+ */
+export class PagesEditor {
+    /**
+     * Determines whether the current execution context is within a Pages Editor.
+     * Pages Editor environment can be identified only in the browser
+     * @returns true if executing within a Pages Editor
+     */
+    static isActive() {
+        if (isServer()) {
+            return false;
+        }
+        // Check for Chromes mode
+        const chromesCheck = window.location.search.indexOf('sc_headless_mode=edit') > -1;
+        // JSS will render a jss-exclusive script element in Metadata mode to indicate edit mode in Pages
+        return chromesCheck || !!window.document.getElementById(PAGES_EDITING_MARKER);
+    }
+    static resetChromes() {
+        if (isServer()) {
+            return;
+        }
+        // Reset chromes in Pages
+        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 PagesEditor.isActive();
+};
+/**
+ * Resets Sitecore editor "chromes"
+ */
+export const resetEditorChromes = () => {
+    if (PagesEditor.isActive()) {
+        PagesEditor.resetChromes();
+    }
+};
+/**
+ * Gets extra JSS clientData scripts to render in XMC Pages in addition to clientData from Pages itself
+ * @returns {Record} collection of clientData
+ */
+export const getJssPagesClientData = () => {
+    const clientData = {};
+    clientData[PAGES_EDITING_MARKER] = {};
+    return clientData;
+};

package/dist/esm/graphql/app-root-query.js

@@ -0,0 +1,69 @@
+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';
+/** @private */
+export const siteNameError = 'The site name must be a non-empty string';
+/** @private */
+export const languageError = 'The language must be a non-empty string';
+/*
+ * GraphQL query that returns the ID of the root item of the specified site and language
+ */
+const appRootQuery = /* GraphQL */ `
+  query AppRootQuery($jssAppTemplateId: String!, $siteName: String!, $language: String!) {
+    layout(site: $siteName, routePath: "/", language: $language) {
+      homePage: item {
+        rootItem: ancestors(includeTemplateIDs: [$jssAppTemplateId]) {
+          id
+        }
+      }
+    }
+  }
+`;
+/**
+ * Gets the ID of the JSS App root item for the specified site and language.
+ * @param {GraphQLClient} client that fetches data from a GraphQL endpoint.
+ * @param {string} siteName the name of the Sitecore site.
+ * @param {string} language the item language version.
+ * @param {string} [jssAppTemplateId] optional template ID of the app root item. If not
+ * specified, the ID of the "/sitecore/templates/Foundation/JavaScript Services/App"
+ * item is used.
+ * @returns the root item ID of the JSS App in Sitecore. Returns null if the app root item is not found.
+ * @throws {RangeError} if a valid site name value is not provided.
+ * @throws {RangeError} if a valid language value is not provided.
+ * @summary This function intentionally avoids throwing an error if a root item is not found,
+ * leaving that decision up to implementations.
+ */
+export function getAppRootId(client, siteName, language, jssAppTemplateId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        if (!siteName) {
+            throw new RangeError(siteNameError);
+        }
+        if (!language) {
+            throw new RangeError(languageError);
+        }
+        let fetchResponse = yield client.request(appRootQuery, {
+            jssAppTemplateId: jssAppTemplateId || SitecoreTemplateId.JssApp,
+            siteName,
+            language,
+        });
+        if (!((_c = (_b = (_a = fetchResponse === null || fetchResponse === void 0 ? void 0 : fetchResponse.layout) === null || _a === void 0 ? void 0 : _a.homePage) === null || _b === void 0 ? void 0 : _b.rootItem) === null || _c === void 0 ? void 0 : _c.length) && language !== 'en') {
+            fetchResponse = yield client.request(appRootQuery, {
+                jssAppTemplateId: jssAppTemplateId || SitecoreTemplateId.JssApp,
+                siteName,
+                language: 'en',
+            });
+        }
+        if (!((_f = (_e = (_d = fetchResponse === null || fetchResponse === void 0 ? void 0 : fetchResponse.layout) === null || _d === void 0 ? void 0 : _d.homePage) === null || _e === void 0 ? void 0 : _e.rootItem) === null || _f === void 0 ? void 0 : _f.length)) {
+            return null;
+        }
+        return fetchResponse.layout.homePage.rootItem[0].id;
+    });
+}

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

@@ -0,0 +1,16 @@
+import { SITECORE_EDGE_URL_DEFAULT } from '../constants';
+/**
+ * Generates a URL for accessing Sitecore Edge Platform Content using the provided endpoint and context ID.
+ * @param {string} sitecoreEdgeContextId - The unique context id.
+ * @param {string} [sitecoreEdgeUrl] - The base endpoint URL for the Edge Platform. Default is https://edge-platform.sitecorecloud.io
+ * @returns {string} The complete URL for accessing content through the Edge Platform.
+ */
+export const getEdgeProxyContentUrl = (sitecoreEdgeContextId, sitecoreEdgeUrl = SITECORE_EDGE_URL_DEFAULT) => `${sitecoreEdgeUrl}/v1/content/api/graphql/v1?sitecoreContextId=${sitecoreEdgeContextId}`;
+/**
+ * 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. Default is https://edge-platform.sitecorecloud.io
+ * @returns {string} The complete URL for accessing forms through the Edge Platform.
+ */
+export const getEdgeProxyFormsUrl = (sitecoreEdgeContextId, formId, sitecoreEdgeUrl = SITECORE_EDGE_URL_DEFAULT) => `${sitecoreEdgeUrl}/v1/forms/publisher/${formId}?sitecoreContextId=${sitecoreEdgeContextId}`;

package/dist/esm/graphql/index.js

@@ -0,0 +1,4 @@
+export { getAppRootId } from './app-root-query';
+export { DefaultRetryStrategy, GraphQLRequestClient, } from '../graphql-request-client';
+export { SearchQueryService, } from './search-service';
+export { getEdgeProxyContentUrl, getEdgeProxyFormsUrl } from './graphql-edge-proxy';

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

@@ -0,0 +1,57 @@
+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());
+    });
+};
+/**
+ * @deprecated use GraphQLClient instead
+ * Provides functionality for performing GraphQL 'search' operations, including handling pagination.
+ * This class is meant to be extended or used as a mixin; it's not meant to be used directly.
+ * @template T The type of objects being requested.
+ * @mixin
+ */
+export class SearchQueryService {
+    /**
+     * Creates an instance of search query service.
+     * @param {GraphQLClient} client that fetches data from a GraphQL endpoint.
+     */
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * 1. Validates mandatory search query arguments
+     * 2. Executes search query with pagination
+     * 3. Aggregates pagination results into a single result-set.
+     * @template T The type of objects being requested.
+     * @param {string | DocumentNode} query the search query.
+     * @param {SearchQueryVariables} args search query arguments.
+     * @returns {T[]} array of result objects.
+     * @throws {RangeError} if a valid root item ID is not provided.
+     * @throws {RangeError} if the provided language(s) is(are) not valid.
+     */
+    fetch(query, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!args.rootItemId) {
+                throw new RangeError('"rootItemId" and "language" must be non-empty strings');
+            }
+            if (!args.language) {
+                throw new RangeError('"rootItemId" and "language" must be non-empty strings');
+            }
+            let results = [];
+            let hasNext = true;
+            let after = '';
+            while (hasNext) {
+                const fetchResponse = yield this.client.request(query, Object.assign(Object.assign({}, args), { after }));
+                results = results.concat((_a = fetchResponse === null || fetchResponse === void 0 ? void 0 : fetchResponse.search) === null || _a === void 0 ? void 0 : _a.results);
+                hasNext = fetchResponse.search.pageInfo.hasNext;
+                after = fetchResponse.search.pageInfo.endCursor;
+            }
+            return results;
+        });
+    }
+}

package/dist/esm/graphql-request-client.js

@@ -0,0 +1,144 @@
+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 { GraphQLClient as Client } from 'graphql-request';
+import parse from 'url-parse';
+import debuggers from './debug';
+import TimeoutPromise from './utils/timeout-promise';
+/**
+ * Represents a default retry strategy for handling retry attempts in case of specific HTTP status codes.
+ * This class implements the RetryStrategy interface and provides methods to determine whether a request
+ * should be retried and calculates the delay before the next retry attempt.
+ */
+export class DefaultRetryStrategy {
+    /**
+     * @param {object} options Configurable options for retry mechanism.
+     * @param {number[]} [options.statusCodes] HTTP status codes to trigger retries on. Default is [429].
+     * @param {string[]} [options.errorCodes] Node error codes to trigger retries. Default is ['ECONNRESET', 'ETIMEDOUT', 'EPROTO'].
+     * @param {number} [options.factor] Factor by which the delay increases with each retry attempt. Default is 2.
+     */
+    constructor(options = {}) {
+        this.statusCodes = options.statusCodes || [429];
+        this.errorCodes = options.errorCodes || ['ECONNRESET', 'ETIMEDOUT', 'EPROTO'];
+        this.factor = options.factor || 2;
+    }
+    shouldRetry(error, attempt, retries) {
+        var _a;
+        const isStatusCodeError = ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) !== undefined && this.statusCodes.includes(error.response.status);
+        const isNodeErrorCode = error.code !== undefined && this.errorCodes.includes(error.code);
+        return retries > 0 && attempt <= retries && (isStatusCodeError || isNodeErrorCode);
+    }
+    getDelay(error, attempt) {
+        var _a;
+        const rawHeaders = (_a = error.response) === null || _a === void 0 ? void 0 : _a.headers;
+        const retryAfterHeader = rawHeaders === null || rawHeaders === void 0 ? void 0 : rawHeaders.get('Retry-After');
+        if (retryAfterHeader !== null &&
+            retryAfterHeader !== undefined &&
+            retryAfterHeader.trim() !== '') {
+            const delaySeconds = Number.parseFloat(retryAfterHeader);
+            return delaySeconds * 1000;
+        }
+        else {
+            return Math.pow(this.factor, attempt - 1) * 1000;
+        }
+    }
+}
+/**
+ * A GraphQL client for Sitecore APIs that uses the 'graphql-request' library.
+ * https://github.com/prisma-labs/graphql-request
+ */
+export class GraphQLRequestClient {
+    /**
+     * Provides ability to execute graphql query using given `endpoint`
+     * @param {string} endpoint The Graphql endpoint
+     * @param {GraphQLRequestClientConfig} [clientConfig] GraphQL request client configuration.
+     */
+    constructor(endpoint, clientConfig = {}) {
+        var _a;
+        this.endpoint = endpoint;
+        this.headers = {};
+        if (clientConfig.apiKey) {
+            this.headers.sc_apikey = clientConfig.apiKey;
+        }
+        if (clientConfig.headers) {
+            this.headers = Object.assign(Object.assign({}, this.headers), clientConfig.headers);
+        }
+        if (!endpoint || !parse(endpoint).hostname) {
+            throw new Error(`Invalid GraphQL endpoint '${endpoint}'. Verify that 'layoutServiceHost' property in 'scjssconfig.json' file or appropriate environment variable is set`);
+        }
+        this.timeout = clientConfig.timeout;
+        this.retries = (_a = clientConfig.retries) !== null && _a !== void 0 ? _a : 3;
+        this.retryStrategy =
+            clientConfig.retryStrategy ||
+                new DefaultRetryStrategy({ statusCodes: [429, 502, 503, 504, 520, 521, 522, 523, 524] });
+        this.client = new Client(endpoint, {
+            headers: this.headers,
+            fetch: clientConfig.fetch,
+        });
+        this.debug = clientConfig.debugger || debuggers.http;
+    }
+    /**
+     * Factory method for creating a GraphQLRequestClientFactory.
+     * @param {object} config - client configuration options.
+     * @param {string} config.endpoint - endpoint
+     * @param {string} [config.apiKey] - apikey
+     */
+    static createClientFactory({ endpoint, apiKey, }) {
+        return (config = {}) => new GraphQLRequestClient(endpoint, Object.assign(Object.assign({}, config), { apiKey }));
+    }
+    /**
+     * Execute graphql request
+     * @param {string | DocumentNode} query graphql query
+     * @param {object} [variables] graphql variables
+     * @param {RequestOptions} [options] Options for configuring a GraphQL request.
+     */
+    request(query, variables, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let attempt = 1;
+            const retryer = () => __awaiter(this, void 0, void 0, function* () {
+                // Note we don't have access to raw request/response with graphql-request
+                // but we should log whatever we have.
+                this.debug('request: %o', {
+                    url: this.endpoint,
+                    headers: Object.assign(Object.assign({}, this.headers), options === null || options === void 0 ? void 0 : options.headers),
+                    query,
+                    variables,
+                });
+                const startTimestamp = Date.now();
+                const fetchWithOptionalTimeout = [this.client.request(query, variables, options === null || options === void 0 ? void 0 : options.headers)];
+                if (this.timeout) {
+                    this.abortTimeout = new TimeoutPromise(this.timeout);
+                    fetchWithOptionalTimeout.push(this.abortTimeout.start);
+                }
+                return Promise.race(fetchWithOptionalTimeout).then((data) => {
+                    var _a;
+                    (_a = this.abortTimeout) === null || _a === void 0 ? void 0 : _a.clear();
+                    this.debug('response in %dms: %o', Date.now() - startTimestamp, data);
+                    return Promise.resolve(data);
+                }, (error) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    (_a = this.abortTimeout) === null || _a === void 0 ? void 0 : _a.clear();
+                    this.debug('response error: %o', error.response || error.message || error);
+                    const status = ((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) || error.code;
+                    const shouldRetry = this.retryStrategy.shouldRetry(error, attempt, this.retries);
+                    if (shouldRetry) {
+                        const delayMs = this.retryStrategy.getDelay(error, attempt);
+                        this.debug('Error: %s. Retrying in %dms (attempt %d).', status, delayMs, attempt);
+                        attempt++;
+                        return new Promise((resolve) => setTimeout(resolve, delayMs)).then(retryer);
+                    }
+                    else {
+                        return Promise.reject(error);
+                    }
+                }));
+            });
+            return retryer();
+        });
+    }
+}

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,129 @@
+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 { DictionaryServiceBase } from './dictionary-service';
+import { siteNameError, languageError } from '../graphql/app-root-query';
+import debug from '../debug';
+/** @private */
+export const queryError = 'Valid value for rootItemId not provided and failed to auto-resolve app root item.';
+/** @default */
+const siteQuery = /* GraphQL */ `
+  query DictionarySiteQuery(
+    $siteName: String!
+    $language: String!
+    $pageSize: Int = 500
+    $after: String
+  ) {
+    site {
+      siteInfo(site: $siteName) {
+        dictionary(language: $language, first: $pageSize, after: $after) {
+          pageInfo {
+            endCursor
+            hasNext
+          }
+          results {
+            key
+            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();
+    }
+    /**
+     * Fetches dictionary data for internalization. Uses search query by default
+     * @param {string} language the language to fetch
+     * @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;
+            }
+            const phrases = yield this.fetchWithSiteQuery(language);
+            this.setCacheValue(cacheKey, phrases);
+            return phrases;
+        });
+    }
+    /**
+     * Fetches dictionary data with site query
+     * This is the default behavior for XMCloud deployments. Uses `siteQuery` to retrieve data.
+     * @param {string} language the language to fetch
+     * @returns {Promise<DictionaryPhrases>} dictionary phrases
+     */
+    fetchWithSiteQuery(language) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const phrases = {};
+            debug.dictionary('fetching dictionary data for %s %s', language, this.options.siteName);
+            let results = [];
+            let hasNext = true;
+            let after = '';
+            if (!this.options.siteName) {
+                throw new RangeError(siteNameError);
+            }
+            if (!language) {
+                throw new RangeError(languageError);
+            }
+            while (hasNext) {
+                const fetchResponse = yield this.graphQLClient.request(siteQuery, {
+                    siteName: this.options.siteName,
+                    language,
+                    pageSize: this.options.pageSize,
+                    after,
+                });
+                if ((_b = (_a = fetchResponse === null || fetchResponse === void 0 ? void 0 : fetchResponse.site) === null || _a === void 0 ? void 0 : _a.siteInfo) === null || _b === void 0 ? void 0 : _b.dictionary) {
+                    results = results.concat(fetchResponse.site.siteInfo.dictionary.results);
+                    after = fetchResponse.site.siteInfo.dictionary.pageInfo.endCursor;
+                    hasNext = fetchResponse.site.siteInfo.dictionary.pageInfo.hasNext;
+                }
+                else {
+                    hasNext = false;
+                }
+            }
+            results.forEach((item) => (phrases[item.key] = item.value));
+            return phrases;
+        });
+    }
+    /**
+     * Gets a GraphQL client that can make requests to the API. Uses graphql-request as the default
+     * library for fetching graphql data (@see GraphQLRequestClient). Override this method if you
+     * want to use something else.
+     * @returns {GraphQLClient} implementation
+     */
+    getGraphQLClient() {
+        if (!this.options.clientFactory) {
+            throw new Error('clientFactory needs to be provided when initializing GraphQL client.');
+        }
+        return this.options.clientFactory({
+            debugger: debug.dictionary,
+            retries: this.options.retries,
+            retryStrategy: this.options.retryStrategy,
+        });
+    }
+}

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,9 @@
+// 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 { DefaultRetryStrategy, GraphQLRequestClient, } from './graphql-request-client';
+export { MemoryCacheClient } from './cache-client';
+export { ClientError } from 'graphql-request';
+export { NativeDataFetcher, } from './native-fetcher';
+export { constants };