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

package/dist/cjs/utils/editing.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleEditorAnchors = exports.resetEditorChromes = exports.isEditorActive = exports.HorizonEditor = exports.ChromeRediscoveryGlobalFunctionName = exports.ExperienceEditor = void 0;
+const is_server_1 = __importDefault(require("./is-server"));
+/**
+ * Static utility class for Sitecore Experience Editor
+ */
+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 (is_server_1.default()) {
+            return false;
+        }
+        // eslint-disable-next-line
+        const sc = window.Sitecore;
+        return Boolean(sc && sc.PageModes && sc.PageModes.ChromeManager);
+    }
+    static resetChromes() {
+        if (is_server_1.default()) {
+            return;
+        }
+        window.Sitecore.PageModes.ChromeManager.resetChromes();
+    }
+}
+exports.ExperienceEditor = ExperienceEditor;
+/**
+ * Copy of chrome rediscovery contract from Horizon (chrome-rediscovery.contract.ts)
+ */
+exports.ChromeRediscoveryGlobalFunctionName = {
+    name: 'Sitecore.Horizon.ResetChromes',
+};
+/**
+ * Static utility class for Sitecore Horizon Editor
+ */
+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 (is_server_1.default()) {
+            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 (is_server_1.default()) {
+            return;
+        }
+        // Reset chromes in Horizon
+        window[exports.ChromeRediscoveryGlobalFunctionName.name] &&
+            window[exports.ChromeRediscoveryGlobalFunctionName.name]();
+    }
+}
+exports.HorizonEditor = HorizonEditor;
+/**
+ * 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
+ */
+const isEditorActive = () => {
+    return ExperienceEditor.isActive() || HorizonEditor.isActive();
+};
+exports.isEditorActive = isEditorActive;
+/**
+ * Resets Sitecore editor "chromes"
+ */
+const resetEditorChromes = () => {
+    if (ExperienceEditor.isActive()) {
+        ExperienceEditor.resetChromes();
+    }
+    else if (HorizonEditor.isActive()) {
+        HorizonEditor.resetChromes();
+    }
+};
+exports.resetEditorChromes = resetEditorChromes;
+/**
+ * @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
+ */
+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);
+    }
+};
+exports.handleEditorAnchors = handleEditorAnchors;

package/dist/cjs/utils/env.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseEnvValue = void 0;
+/**
+ * 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
+ */
+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;
+};
+exports.tryParseEnvValue = tryParseEnvValue;

package/dist/cjs/utils/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapButtonToCommand = exports.DefaultEditFrameButtonIds = exports.DefaultEditFrameButtons = exports.DefaultEditFrameButton = exports.handleEditorAnchors = exports.resetEditorChromes = exports.isEditorActive = exports.HorizonEditor = exports.ExperienceEditor = exports.tryParseEnvValue = exports.isTimeoutError = exports.isAbsoluteUrl = exports.resolveUrl = exports.isServer = void 0;
+var is_server_1 = require("./is-server");
+Object.defineProperty(exports, "isServer", { enumerable: true, get: function () { return __importDefault(is_server_1).default; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "resolveUrl", { enumerable: true, get: function () { return utils_1.resolveUrl; } });
+Object.defineProperty(exports, "isAbsoluteUrl", { enumerable: true, get: function () { return utils_1.isAbsoluteUrl; } });
+Object.defineProperty(exports, "isTimeoutError", { enumerable: true, get: function () { return utils_1.isTimeoutError; } });
+var env_1 = require("./env");
+Object.defineProperty(exports, "tryParseEnvValue", { enumerable: true, get: function () { return env_1.tryParseEnvValue; } });
+var editing_1 = require("./editing");
+Object.defineProperty(exports, "ExperienceEditor", { enumerable: true, get: function () { return editing_1.ExperienceEditor; } });
+Object.defineProperty(exports, "HorizonEditor", { enumerable: true, get: function () { return editing_1.HorizonEditor; } });
+Object.defineProperty(exports, "isEditorActive", { enumerable: true, get: function () { return editing_1.isEditorActive; } });
+Object.defineProperty(exports, "resetEditorChromes", { enumerable: true, get: function () { return editing_1.resetEditorChromes; } });
+Object.defineProperty(exports, "handleEditorAnchors", { enumerable: true, get: function () { return editing_1.handleEditorAnchors; } });
+var edit_frame_1 = require("./edit-frame");
+Object.defineProperty(exports, "DefaultEditFrameButton", { enumerable: true, get: function () { return edit_frame_1.DefaultEditFrameButton; } });
+Object.defineProperty(exports, "DefaultEditFrameButtons", { enumerable: true, get: function () { return edit_frame_1.DefaultEditFrameButtons; } });
+Object.defineProperty(exports, "DefaultEditFrameButtonIds", { enumerable: true, get: function () { return edit_frame_1.DefaultEditFrameButtonIds; } });
+Object.defineProperty(exports, "mapButtonToCommand", { enumerable: true, get: function () { return edit_frame_1.mapButtonToCommand; } });

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Determines whether the current execution context is server-side
+ * @returns true if executing server-side
+ */
+function isServer() {
+    return !(typeof window !== 'undefined' && window.document);
+}
+exports.default = isServer;

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

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

package/dist/cjs/utils/utils.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTimeoutError = exports.isAbsoluteUrl = exports.resolveUrl = void 0;
+const is_server_1 = __importDefault(require("./is-server"));
+/**
+ * note: encodeURIComponent is available via browser (window) or natively in node.js
+ * if you use another js engine for server-side rendering you may not have native encodeURIComponent
+ * and would then need to install a package for that functionality
+ * @param {ParsedUrlQueryInput} params query string parameters
+ * @returns {string} query string
+ */
+function getQueryString(params) {
+    return Object.keys(params)
+        .map((k) => `${encodeURIComponent(k)}=${encodeURIComponent(String(params[k]))}`)
+        .join('&');
+}
+/**
+ * Resolves a base URL that may contain query string parameters and an additional set of query
+ * string parameters into a unified string representation.
+ * @param {string} urlBase the base URL that may contain query string parameters
+ * @param {ParsedUrlQueryInput} params query string parameters
+ * @returns a URL string
+ * @throws {RangeError} if the provided url is an empty string
+ */
+function resolveUrl(urlBase, params = {}) {
+    if (!urlBase) {
+        throw new RangeError('url must be a non-empty string');
+    }
+    // This is a better way to work with URLs since it handles different user input
+    // edge cases. This works in Node and all browser except IE11.
+    // https://developer.mozilla.org/en-US/docs/Web/API/URL
+    // TODO: Verify our browser support requirements.
+    if (is_server_1.default()) {
+        const url = new URL(urlBase);
+        for (const key in params) {
+            if ({}.hasOwnProperty.call(params, key)) {
+                url.searchParams.append(key, String(params[key]));
+            }
+        }
+        const result = url.toString();
+        return result;
+    }
+    const qs = getQueryString(params);
+    const result = urlBase.indexOf('?') !== -1 ? `${urlBase}&${qs}` : `${urlBase}?${qs}`;
+    return result;
+}
+exports.resolveUrl = resolveUrl;
+const isAbsoluteUrl = (url) => {
+    if (!url) {
+        return false;
+    }
+    if (typeof url !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+    return /^[a-z][a-z0-9+.-]*:/.test(url);
+};
+exports.isAbsoluteUrl = isAbsoluteUrl;
+/**
+ * Indicates whether the error is a timeout error
+ * @param {unknown} error error
+ * @returns {boolean} is timeout error
+ */
+const isTimeoutError = (error) => {
+    var _a;
+    return ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 408 || error.name === 'AbortError';
+};
+exports.isTimeoutError = isTimeoutError;

package/dist/esm/cache-client.js

@@ -0,0 +1,50 @@
+import { Cache } from 'memory-cache';
+/**
+ * Default cache configuration
+ */
+const DEFAULTS = Object.freeze({
+    cacheTimeout: 60,
+    cacheEnabled: true,
+});
+/**
+ * A cache client that uses the 'memory-cache' library (https://github.com/ptarjan/node-cache).
+ * 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 data being cached.
+ * @mixin
+ */
+export class MemoryCacheClient {
+    /**
+     * Initializes a new instance of @see MemoryCacheClient using the provided @see CacheOptions
+     * @param {CacheOptions} options Configuration options
+     */
+    constructor(options) {
+        var _a;
+        this.options = options;
+        this.cache = new Cache();
+        this.options.cacheTimeout = ((_a = this.options.cacheTimeout) !== null && _a !== void 0 ? _a : DEFAULTS.cacheTimeout) * 1000;
+        if (this.options.cacheEnabled === undefined) {
+            this.options.cacheEnabled = DEFAULTS.cacheEnabled;
+        }
+    }
+    /**
+     * Retrieves a value from the cache.
+     * @template T The type of data being cached.
+     * @param {string} key The cache key.
+     * @returns The cache value as {T}, or null if the specified key is not found in the cache.
+     */
+    getCacheValue(key) {
+        return this.options.cacheEnabled ? this.cache.get(key) : null;
+    }
+    /**
+     * Adds a value to the cache for the specified cache key.
+     * @template T The type of data being cached.
+     * @param {string} key The cache key.
+     * @param {T} value The value to cache.
+     * @returns The value added to the cache.
+     */
+    setCacheValue(key, value) {
+        return this.options.cacheEnabled
+            ? this.cache.put(key, value, this.options.cacheTimeout)
+            : value;
+    }
+}

package/dist/esm/constants.js

@@ -0,0 +1,9 @@
+export var SitecoreTemplateId;
+(function (SitecoreTemplateId) {
+    // /sitecore/templates/Foundation/JavaScript Services/App
+    SitecoreTemplateId["JssApp"] = "061cba1554744b918a0617903b102b82";
+    // /sitecore/templates/System/Dictionary/Dictionary entry
+    SitecoreTemplateId["DictionaryEntry"] = "6d1cd89719364a3aa511289a94c2a7b1";
+})(SitecoreTemplateId || (SitecoreTemplateId = {}));
+export const siteNameError = 'The siteName cannot be empty';
+export const SITECORE_EDGE_URL_DEFAULT = 'https://edge-platform.sitecorecloud.io';

package/dist/esm/debug.js

@@ -0,0 +1,36 @@
+var _a;
+import debug from 'debug';
+import isServer from './utils/is-server';
+const rootNamespace = 'sitecore-jss';
+// On server/node side, allow switching from the built-in
+// `%o` (pretty-print single line) and `%O` (pretty-print multiple line)
+// with a `DEBUG_MULTILINE` environment variable.
+if (isServer() &&
+    ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.DEBUG_MULTILINE) === 'true' &&
+    debug.formatters.o &&
+    debug.formatters.O) {
+    debug.formatters.o = debug.formatters.O;
+}
+/**
+ * Enable debug logging dynamically
+ * @param {string} namespaces space-separated list of namespaces to enable
+ */
+export const enableDebug = (namespaces) => debug.enable(namespaces);
+/**
+ * Default Sitecore JSS 'debug' module debuggers. Uses namespace prefix 'sitecore-jss:'.
+ * See {@link https://www.npmjs.com/package/debug} for details.
+ */
+export default {
+    common: debug(`${rootNamespace}:common`),
+    http: debug(`${rootNamespace}:http`),
+    layout: debug(`${rootNamespace}:layout`),
+    dictionary: debug(`${rootNamespace}:dictionary`),
+    editing: debug(`${rootNamespace}:editing`),
+    sitemap: debug(`${rootNamespace}:sitemap`),
+    multisite: debug(`${rootNamespace}:multisite`),
+    robots: debug(`${rootNamespace}:robots`),
+    redirects: debug(`${rootNamespace}:redirects`),
+    personalize: debug(`${rootNamespace}:personalize`),
+    errorpages: debug(`${rootNamespace}:errorpages`),
+    revalidate: debug(`${rootNamespace}:revalidate`),
+};

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) {
+    var _a, _b, _c, _d, _e, _f;
+    return __awaiter(this, void 0, void 0, function* () {
+        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,8 @@
+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}`;

package/dist/esm/graphql/index.js

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

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

@@ -0,0 +1,56 @@
+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());
+    });
+};
+/**
+ * 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) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            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,99 @@
+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';
+/**
+ * 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 = {}) {
+        this.endpoint = endpoint;
+        this.headers = {};
+        if (clientConfig.apiKey) {
+            this.headers.sc_apikey = clientConfig.apiKey;
+        }
+        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 = clientConfig.retries || 0;
+        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
+     */
+    request(query, variables) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let retriesLeft = this.retries;
+            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: this.headers,
+                    query,
+                    variables,
+                });
+                const startTimestamp = Date.now();
+                const fetchWithOptionalTimeout = [this.client.request(query, variables)];
+                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) => {
+                    var _a, _b, _c, _d;
+                    (_a = this.abortTimeout) === null || _a === void 0 ? void 0 : _a.clear();
+                    this.debug('response error: %o', error.response || error.message || error);
+                    if (((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) === 429 && retriesLeft > 0) {
+                        const rawHeaders = (_d = (_c = error) === null || _c === void 0 ? void 0 : _c.response) === null || _d === void 0 ? void 0 : _d.headers;
+                        const delaySeconds = rawHeaders && rawHeaders.get('Retry-After')
+                            ? Number.parseInt(rawHeaders.get('Retry-After'), 10)
+                            : 1;
+                        this.debug('Error: Rate limit reached for GraphQL endpoint. Retrying in %ds. Retries left: %d', delaySeconds, retriesLeft);
+                        retriesLeft--;
+                        return new Promise((resolve) => setTimeout(resolve, delaySeconds * 1000)).then(retryer);
+                    }
+                    else {
+                        return Promise.reject(error);
+                    }
+                });
+            });
+            return retryer();
+        });
+    }
+}