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

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,222 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeURLSearchParams = exports.escapeNonSpecialQuestionMarks = exports.areURLSearchParamsEqual = exports.isRegexOrUrl = exports.enforceCors = exports.getAllowedOriginsFromEnv = exports.isTimeoutError = exports.isAbsoluteUrl = void 0;
+exports.resolveUrl = resolveUrl;
+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 ((0, 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;
+}
+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;
+/**
+ * Converts a string value in a regex pattern allowing wildcard matching
+ * @param {string} pattern input with wildcards i.e. site.*.com
+ * @returns {string} modified string that can be used as regexp input
+ */
+const convertToWildcardRegex = (pattern) => {
+    return ('^' +
+        pattern
+            .replace(/\//g, '\\/')
+            .replace(/\./g, '\\.')
+            .replace(/\*/g, '.*') +
+        '$');
+};
+/**
+ * Gets allowed origins from JSS_ALLOWED_ORIGINS env variable
+ * @returns {string[]} list of allowed origins from JSS_ALLOWED_ORIGINS env variable
+ */
+const getAllowedOriginsFromEnv = () => process.env.JSS_ALLOWED_ORIGINS
+    ? process.env.JSS_ALLOWED_ORIGINS.replace(' ', '').split(',')
+    : [];
+exports.getAllowedOriginsFromEnv = getAllowedOriginsFromEnv;
+/**
+ * Tests origin from incoming request against allowed origins list that can be
+ * set in JSS's JSS_ALLOWED_ORIGINS env variable, passed via allowedOrigins param and/or
+ * be already set in Access-Control-Allow-Origin by other logic.
+ * Applies Access-Control-Allow-Origin and Access-Control-Allow-Methods on match
+ * Also applies Access-Control-Allow-Headers for preflight requests
+ * @param {IncomingMessage} req incoming request
+ * @param {OutgoingMessage} res response to set CORS headers for
+ * @param {string[]} [allowedOrigins] additional list of origins to test against
+ * @returns true if incoming origin matches the allowed lists, false when it does not
+ */
+const enforceCors = (req, res, allowedOrigins) => {
+    // origin in not present for non-CORS requests (e.g. server-side) - so we skip the checks
+    if (!req.headers.origin) {
+        return true;
+    }
+    // 3 sources of allowed origins are considered:
+    // the env value
+    const defaultAllowedOrigins = (0, exports.getAllowedOriginsFromEnv)();
+    // the allowedOrigins prop
+    allowedOrigins = defaultAllowedOrigins.concat(allowedOrigins || []);
+    // and the existing CORS header, if present (i.e. set by nextjs config)
+    const presetCors = res.getHeader('Access-Control-Allow-Origin');
+    if (presetCors) {
+        allowedOrigins.push(presetCors);
+    }
+    const origin = req.headers.origin;
+    if (origin &&
+        allowedOrigins.some((allowedOrigin) => origin === allowedOrigin || new RegExp(convertToWildcardRegex(allowedOrigin)).test(origin))) {
+        res.setHeader('Access-Control-Allow-Origin', origin);
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, DELETE, PUT, PATCH');
+        // set the allowed headers for preflight requests
+        if (req.method === 'OPTIONS') {
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        }
+        return true;
+    }
+    return false;
+};
+exports.enforceCors = enforceCors;
+/**
+ * Determines whether the given input is a regular expression or resembles a URL.
+ * @param {string} input - The input string to evaluate.
+ * @returns {'regex' | 'url'} - Returns 'url' if the input looks like a URL, otherwise 'regex'.
+ */
+const isRegexOrUrl = (input) => {
+    // Remove the trailing slash.
+    input = input.slice(0, -1);
+    // Check if the string resembles a URL.
+    const isUrlLike = /^\/[a-zA-Z0-9\-\/]+(\?([a-zA-Z0-9\-_]+=[a-zA-Z0-9\-_]+)(&[a-zA-Z0-9\-_]+=[a-zA-Z0-9\-_]+)*)?$/.test(input);
+    if (isUrlLike) {
+        return 'url';
+    }
+    // If it doesn't resemble a URL, it's likely a regular expression.
+    return 'regex';
+};
+exports.isRegexOrUrl = isRegexOrUrl;
+/**
+ * Compares two URLSearchParams objects to determine if they are equal.
+ * @param {URLSearchParams} params1 - The first set of URL search parameters.
+ * @param {URLSearchParams} params2 - The second set of URL search parameters.
+ * @returns {boolean} - Returns true if the parameters are equal, otherwise false.
+ */
+const areURLSearchParamsEqual = (params1, params2) => {
+    // Generates a sorted string representation of URL search parameters.
+    const getSortedParamsString = (params) => {
+        return [...params.entries()]
+            .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+            .map(([key, value]) => `${key}=${value}`)
+            .join('&');
+    };
+    // Compare the sorted strings of both parameter sets.
+    return getSortedParamsString(params1) === getSortedParamsString(params2);
+};
+exports.areURLSearchParamsEqual = areURLSearchParamsEqual;
+/**
+ * Escapes non-special "?" characters in a string or regex.
+ * - For regular strings, it escapes all unescaped "?" characters by adding a backslash (`\`).
+ * - For regex patterns (strings enclosed in `/.../`), it analyzes each "?" to determine if it has special meaning
+ *   (e.g., `?` in `(abc)?`, `.*?`, `(?!...)`) or is just a literal character. Only literal "?" characters are escaped.
+ * @param {string} input - The input string or regex pattern.
+ * @returns {string} - The modified string or regex with non-special "?" characters escaped.
+ */
+const escapeNonSpecialQuestionMarks = (input) => {
+    const regexPattern = /(?<!\\)\?/g; // Match unescaped "?" characters
+    const negativeLookaheadPattern = /\(\?!$/; // Detect the start of a Negative Lookahead pattern
+    const specialRegexSymbols = /[.*+)\[\]|\(]$/; // Check for special regex symbols before "?"
+    let result = '';
+    let lastIndex = 0;
+    let match;
+    while ((match = regexPattern.exec(input)) !== null) {
+        const index = match.index; // Position of the "?" in the string
+        const before = input.slice(lastIndex, index); // Context before the "?"
+        // Check if "?" is part of a Negative Lookahead
+        const isNegativeLookahead = negativeLookaheadPattern.test(before.slice(-3));
+        // Check if "?" follows a special regex symbol
+        const isSpecialRegexSymbol = specialRegexSymbols.test(before.slice(-1));
+        if (isNegativeLookahead || isSpecialRegexSymbol) {
+            // If it's a special case, keep the "?" as is
+            result += input.slice(lastIndex, index + 1);
+        }
+        else {
+            // Otherwise, escape the "?"
+            result += input.slice(lastIndex, index) + '\\?';
+        }
+        lastIndex = index + 1; // Move to the next part of the string
+    }
+    // Append the remaining part of the string
+    result += input.slice(lastIndex);
+    return result;
+};
+exports.escapeNonSpecialQuestionMarks = escapeNonSpecialQuestionMarks;
+/**
+ * Merges two URLSearchParams objects. If both objects contain the same key, the value from the second object overrides the first.
+ * @param {URLSearchParams} params1 - The first set of URL search parameters.
+ * @param {URLSearchParams} params2 - The second set of URL search parameters.
+ * @returns {string} - A string representation of the merged URL search parameters.
+ */
+const mergeURLSearchParams = (params1, params2) => {
+    const merged = new URLSearchParams();
+    // Add all keys and values from the first object.
+    for (const [key, value] of params1.entries()) {
+        merged.set(key, value);
+    }
+    // Add all keys and values from the second object, replacing existing ones.
+    for (const [key, value] of params2.entries()) {
+        merged.set(key, value);
+    }
+    return merged.toString();
+};
+exports.mergeURLSearchParams = mergeURLSearchParams;

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,10 @@
+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';
+export const HIDDEN_RENDERING_NAME = 'Hidden Rendering';

package/dist/esm/data-fetcher.js

@@ -0,0 +1,28 @@
+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 { resolveUrl } from './utils/utils';
+export class ResponseError extends Error {
+    constructor(message, response) {
+        super(message);
+        Object.setPrototypeOf(this, ResponseError.prototype);
+        this.response = response;
+    }
+}
+/**
+ * @param {string} url the URL to request; may include query string
+ * @param {HttpDataFetcher<T> | NativeDataFetcherFunction<T>} fetcher the fetcher to use to perform the request
+ * @param {ParsedUrlQueryInput} params the query string parameters to send with the request
+ */
+export function fetchData(url_1, fetcher_1) {
+    return __awaiter(this, arguments, void 0, function* (url, fetcher, params = {}) {
+        const response = yield fetcher(resolveUrl(url, params));
+        return response.data;
+    });
+}

package/dist/esm/debug.js

@@ -0,0 +1,36 @@
+var _a;
+import debug from 'debug';
+import isServer from './utils/is-server';
+const rootNamespace = 'core';
+// 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 'core:'.
+ * 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`),
+    proxy: debug(`${rootNamespace}:proxy`),
+};

package/dist/esm/editing/component-library.js

@@ -0,0 +1,98 @@
+/**
+ * Event to be sent when report status to component library
+ */
+export const COMPONENT_LIBRARY_STATUS_EVENT_NAME = 'component:status';
+/**
+ * Enumeration of statuses for the component library.
+ */
+export var ComponentLibraryStatus;
+(function (ComponentLibraryStatus) {
+    ComponentLibraryStatus["READY"] = "ready";
+    ComponentLibraryStatus["RENDERED"] = "rendered";
+})(ComponentLibraryStatus || (ComponentLibraryStatus = {}));
+/**
+ * Adds the browser-side event handler for 'component:update' message used in Component Library
+ * The event should update a component on page by uid, with fields and params from event args
+ * @param {ComponentRendering} rootComponent root component displayed for Component Library page
+ * @param {Function} successCallback  callback to be called after successful component update
+ */
+export const addComponentUpdateHandler = (rootComponent, successCallback) => {
+    if (!window)
+        return;
+    const handler = (e) => updateComponentHandler(e, rootComponent, successCallback);
+    window.addEventListener('message', handler);
+    // the power to remove handler outside of this function, if needed
+    const unsubscribe = () => {
+        window.removeEventListener('message', handler);
+    };
+    return unsubscribe;
+};
+const validateOrigin = (event) => {
+    // TODO: use `EDITING_ALLOWED_ORIGINS.concat(getAllowedOriginsFromEnv())` later
+    // nextjs's JSS_ALLOWED_ORIGINS is not available on the client, need to use NEXT_PUBLIC_ variable, but it's a breaking change for Deploy
+    const allowedOrigins = ['*'];
+    return allowedOrigins.some((origin) => origin === event.origin ||
+        new RegExp('^' + origin.replace('.', '\\.').replace(/\*/g, '.*') + '$').test(event.origin));
+};
+export const updateComponentHandler = (e, rootComponent, successCallback) => {
+    var _a;
+    const eventArgs = e.data;
+    if (!e.origin || !eventArgs || eventArgs.name !== 'component:update') {
+        // avoid extra noise in logs
+        if (!validateOrigin(e)) {
+            console.debug('Component Library: event skipped: message %s from origin %s', eventArgs.name, e.origin);
+        }
+        return;
+    }
+    if (!((_a = eventArgs.details) === null || _a === void 0 ? void 0 : _a.uid)) {
+        console.debug('Received component:update event without uid, aborting event handler...');
+        return;
+    }
+    const findComponent = (root) => {
+        var _a, _b;
+        if (((_a = root.uid) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === ((_b = eventArgs.details) === null || _b === void 0 ? void 0 : _b.uid.toLowerCase()))
+            return root;
+        if (root.placeholders) {
+            for (const plhName of Object.keys(root.placeholders)) {
+                for (const rendering of root.placeholders[plhName]) {
+                    const result = findComponent(rendering);
+                    if (result)
+                        return result;
+                }
+            }
+        }
+        return null;
+    };
+    const updateComponent = findComponent(rootComponent);
+    if (updateComponent) {
+        console.debug('Found component with uid %s to update. Update fields: %o. Update params: %o.', eventArgs.details.uid, eventArgs.details.fields, eventArgs.details.params);
+        if (eventArgs.details.fields) {
+            updateComponent.fields = Object.assign(Object.assign({}, updateComponent.fields), eventArgs.details.fields);
+        }
+        if (eventArgs.details.params) {
+            updateComponent.params = Object.assign(Object.assign({}, updateComponent.params), eventArgs.details.params);
+        }
+        if (successCallback)
+            successCallback(rootComponent);
+    }
+    else {
+        console.debug('Rendering with uid %s not found', eventArgs.details.uid);
+    }
+    // strictly for testing
+    return rootComponent;
+};
+/**
+ * Generates a ComponentLibraryStatusEvent with the given status and uid.
+ * @param {ComponentLibraryStatus} status - The status of rendering.
+ * @param {string} uid - The unique identifier for the event.
+ * @returns An object representing the ComponentLibraryStatusEvent.
+ */
+export function getComponentLibraryStatusEvent(status, uid) {
+    return {
+        name: COMPONENT_LIBRARY_STATUS_EVENT_NAME,
+        message: {
+            status,
+            uid,
+        },
+    };
+}

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

@@ -0,0 +1,179 @@
+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 { LayoutKind } from './models';
+/**
+ * The dictionary query default page size.
+ */
+const PAGE_SIZE = 1000;
+/**
+ * GraphQL query for fetching editing data.
+ */
+export const query = /* GraphQL */ `
+ query EditingQuery(
+    $siteName: String!
+    $itemId: String!
+    $language: String!
+    $version: String
+    $after: String
+    $pageSize: Int = ${PAGE_SIZE}
+) {
+    item(path: $itemId, language: $language, version: $version) {
+      rendered
+    }
+    site {
+      siteInfo(site: $siteName) {
+        dictionary(language: $language, first: $pageSize, after: $after) {
+          results {
+            key
+            value
+          }
+          pageInfo {
+            endCursor
+            hasNext
+          }
+        }
+      }
+    }
+  }
+`;
+/**
+ * GraphQL query for fetching dictionary data.
+ * This query is used when the dictionary data is paginated.
+ */
+export const dictionaryQuery = /* GraphQL */ `
+  query EditingDictionaryQuery(
+    $siteName: String!
+    $language: String!
+    $after: String
+    $pageSize: Int = ${PAGE_SIZE}
+  ) {
+    site {
+      siteInfo(site: $siteName) {
+        dictionary(language: $language, first: $pageSize, after: $after) {
+          results {
+            key
+            value
+          }
+          pageInfo {
+            endCursor
+            hasNext
+          }
+        }
+      }
+    }
+  }
+`;
+/**
+ * Service for fetching editing data from Sitecore using the Sitecore's GraphQL API.
+ * Expected to be used in XMCloud Pages preview (editing) Metadata Edit Mode.
+ */
+export class GraphQLEditingService {
+    /**
+     * Fetch layout data using the Sitecore GraphQL endpoint.
+     * @param {GraphQLLayoutServiceConfig} serviceConfig configuration
+     */
+    constructor(serviceConfig) {
+        this.serviceConfig = serviceConfig;
+        this.graphQLClient = this.getGraphQLClient();
+    }
+    /**
+     * Fetches editing data. Provides the layout data and dictionary phrases
+     * @param {object} variables - The parameters for fetching editing data.
+     * @param {string} variables.siteName - The site name.
+     * @param {string} variables.itemId - The item id (path) to fetch layout data for.
+     * @param {string} variables.language - The language to fetch layout data for.
+     * @param {string} [variables.version] - The version of the item (optional).
+     * @param {LayoutKind} [variables.layoutKind] - The final or shared layout variant.
+     * @returns {Promise} The layout data and dictionary phrases.
+     */
+    fetchEditingData(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ siteName, itemId, language, version, layoutKind = LayoutKind.Final, }) {
+            var _b, _c, _d;
+            debug.editing('fetching editing data for %s %s %s %s', siteName, itemId, language, version, layoutKind);
+            if (!siteName) {
+                throw new RangeError('The site name must be a non-empty string');
+            }
+            if (!language) {
+                throw new RangeError('The language must be a non-empty string');
+            }
+            let dictionaryResults = [];
+            let hasNext = true;
+            let after = '';
+            const editingData = yield this.graphQLClient.request(query, {
+                siteName,
+                itemId,
+                version,
+                language,
+            }, {
+                headers: {
+                    sc_layoutKind: layoutKind,
+                },
+            });
+            if ((_c = (_b = editingData === null || editingData === void 0 ? void 0 : editingData.site) === null || _b === void 0 ? void 0 : _b.siteInfo) === null || _c === void 0 ? void 0 : _c.dictionary) {
+                dictionaryResults = editingData.site.siteInfo.dictionary.results;
+                hasNext = editingData.site.siteInfo.dictionary.pageInfo.hasNext;
+                after = editingData.site.siteInfo.dictionary.pageInfo.endCursor;
+            }
+            else {
+                hasNext = false;
+            }
+            const dictionary = yield this.fetchDictionaryData({ siteName, language }, dictionaryResults, hasNext, after);
+            return {
+                layoutData: ((_d = editingData === null || editingData === void 0 ? void 0 : editingData.item) === null || _d === void 0 ? void 0 : _d.rendered) || {
+                    sitecore: {
+                        context: { pageEditing: true, language },
+                        route: null,
+                    },
+                },
+                dictionary,
+            };
+        });
+    }
+    fetchDictionaryData(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ siteName, language, }, initDictionary = [], hasNext = true, after) {
+            var _b, _c;
+            let dictionaryResults = initDictionary;
+            const dictionary = {};
+            while (hasNext) {
+                const data = yield this.graphQLClient.request(dictionaryQuery, {
+                    siteName,
+                    language,
+                    after,
+                });
+                if ((_c = (_b = data === null || data === void 0 ? void 0 : data.site) === null || _b === void 0 ? void 0 : _b.siteInfo) === null || _c === void 0 ? void 0 : _c.dictionary) {
+                    dictionaryResults = dictionaryResults.concat(data.site.siteInfo.dictionary.results);
+                    hasNext = data.site.siteInfo.dictionary.pageInfo.hasNext;
+                    after = data.site.siteInfo.dictionary.pageInfo.endCursor;
+                }
+                else {
+                    hasNext = false;
+                }
+            }
+            dictionaryResults.forEach((item) => (dictionary[item.key] = item.value));
+            return dictionary;
+        });
+    }
+    /**
+     * Gets a GraphQL client that can make requests to the API.
+     * @returns {GraphQLClient} implementation
+     */
+    getGraphQLClient() {
+        if (!this.serviceConfig.clientFactory) {
+            throw new Error('clientFactory needs to be provided when initializing GraphQL client.');
+        }
+        return this.serviceConfig.clientFactory({
+            debugger: debug.editing,
+            headers: {
+                sc_editMode: 'true',
+            },
+        });
+    }
+}

package/dist/esm/editing/index.js

@@ -0,0 +1,5 @@
+export { GraphQLEditingService } from './graphql-editing-service';
+export { DEFAULT_PLACEHOLDER_UID, PagesEditor, isEditorActive, resetEditorChromes, getJssPagesClientData, EDITING_ALLOWED_ORIGINS, QUERY_PARAM_EDITING_SECRET, PAGES_EDITING_MARKER, } from './utils';
+export { RestComponentLayoutService, } from './rest-component-layout-service';
+export { LayoutKind, MetadataKind } from './models';
+export { addComponentUpdateHandler, ComponentLibraryStatus, getComponentLibraryStatusEvent, } from './component-library';