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

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@sitecore-content-sdk/core",
+  "version": "0.1.0-beta.1",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "npm run clean && tsc -p tsconfig.json && tsc -p tsconfig-esm.json",
+    "clean": "del-cli dist types",
+    "lint": "eslint \"./src/**/*.ts\"",
+    "test": "mocha \"./src/**/*.test.ts\"",
+    "prepublishOnly": "npm run build",
+    "coverage": "nyc npm test",
+    "generate-docs": "npx typedoc --plugin typedoc-plugin-markdown --outputFileStrategy Members --parametersFormat table --readme none --out ../../ref-docs/core --entryPoints src/index.ts --entryPoints src/graphql/index.ts --entryPoints src/i18n/index.ts --entryPoints src/layout/index.ts --entryPoints src/media/index.ts --entryPoints src/personalize/index.ts --entryPoints src/site/index.ts --entryPoints src/tracking/index.ts --entryPoints src/utils/index.ts --entryPoints src/editing/index.ts --githubPages false"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "author": {
+    "name": "Sitecore Corporation",
+    "url": "https://jss.sitecore.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Sitecore/jss"
+  },
+  "license": "Apache-2.0",
+  "homepage": "https://jss.sitecore.com",
+  "bugs": {
+    "url": "https://github.com/sitecore/jss/issues"
+  },
+  "devDependencies": {
+    "@types/chai": "^5.0.1",
+    "@types/chai-spies": "^1.0.6",
+    "@types/chai-string": "^1.4.5",
+    "@types/debug": "^4.1.12",
+    "@types/memory-cache": "^0.2.6",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^22.12.0",
+    "@types/sinon": "^17.0.3",
+    "@types/url-parse": "1.4.11",
+    "chai": "^4.2.0",
+    "chai-spies": "^1.1.0",
+    "chai-string": "^1.5.0",
+    "del-cli": "^6.0.0",
+    "eslint": "^8.56.0",
+    "eslint-plugin-jsdoc": "48.7.0",
+    "mocha": "^11.1.0",
+    "nock": "14.0.0-beta.7",
+    "nyc": "^17.1.0",
+    "sinon": "^19.0.2",
+    "tslib": "^2.8.1",
+    "tsx": "^4.19.2",
+    "typescript": "~5.7.3"
+  },
+  "dependencies": {
+    "debug": "^4.4.0",
+    "graphql": "^16.10.0",
+    "graphql-request": "^6.1.0",
+    "memory-cache": "^0.2.0",
+    "url-parse": "^1.5.10"
+  },
+  "description": "",
+  "types": "types/index.d.ts",
+  "gitHead": "11e6c0ce4b6bcaf8a5ddffa39a921c8dd145e603",
+  "files": [
+    "dist",
+    "types",
+    "/*.js",
+    "/*.d.ts"
+  ]
+}

package/personalize.d.ts

@@ -0,0 +1 @@
+export * from './types/personalize/index';

package/personalize.js

@@ -0,0 +1 @@
+module.exports = require('./dist/cjs/personalize/index');

package/site.d.ts

@@ -0,0 +1 @@
+export * from './types/site/index';

package/site.js

@@ -0,0 +1 @@
+module.exports = require('./dist/cjs/site/index');

package/types/cache-client.d.ts

@@ -0,0 +1,64 @@
+/**
+ * An interface for cache clients.
+ * @template T The type of data being cached.
+ */
+export interface CacheClient<T> {
+    /**
+     * Adds a value to the cache for the specified cache key.
+     * @param {string} key The cache key.
+     * @param {T} value The value to cache.
+     * @returns The value added to the cache.
+     */
+    setCacheValue(key: string, value: T): T;
+    /**
+     * Retrieves a value from the cache.
+     * @param {string} key The cache key.
+     * @returns The cache value as {T}, or null if the specified key was not found in the cache.
+     */
+    getCacheValue(key: string): T | null;
+}
+/**
+ * Minimum configuration options for classes that implement @see CacheClient
+ */
+export interface CacheOptions {
+    /**
+     * Enable/disable caching mechanism
+     * @default true
+     */
+    cacheEnabled?: boolean;
+    /**
+     * Cache timeout (sec)
+     * @default 60
+     */
+    cacheTimeout?: number;
+}
+/**
+ * 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 declare class MemoryCacheClient<T> implements CacheClient<T> {
+    options: CacheOptions;
+    private cache;
+    /**
+     * Initializes a new instance of @see MemoryCacheClient using the provided @see CacheOptions
+     * @param {CacheOptions} options Configuration options
+     */
+    constructor(options: CacheOptions);
+    /**
+     * 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: string): T | 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: string, value: T): T;
+}

package/types/constants.d.ts

@@ -0,0 +1,7 @@
+export declare enum SitecoreTemplateId {
+    JssApp = "061cba1554744b918a0617903b102b82",
+    DictionaryEntry = "6d1cd89719364a3aa511289a94c2a7b1"
+}
+export declare const siteNameError = "The siteName cannot be empty";
+export declare const SITECORE_EDGE_URL_DEFAULT = "https://edge-platform.sitecorecloud.io";
+export declare const HIDDEN_RENDERING_NAME = "Hidden Rendering";

package/types/data-fetcher.d.ts

@@ -0,0 +1,34 @@
+import { NativeDataFetcherFunction } from './native-fetcher';
+import { ParsedUrlQueryInput } from 'querystring';
+/**
+ * Response data for an HTTP request sent to an API
+ * @template T the type of data model requested
+ */
+export interface HttpResponse<T> {
+    /** HTTP status code of the response (i.e. 200, 404) */
+    status: number;
+    /** HTTP status text of the response (i.e. 'OK', 'Bad Request') */
+    statusText: string;
+    /** Response content */
+    data: T;
+}
+/**
+ * Describes functions that fetch data asynchronously (i.e. from an API endpoint).
+ * This interface conforms to 'fetch' public API, but is adaptable to other HTTP libraries and
+ * fetch polyfills.
+ * The interface implementation must:
+ * - Support SSR
+ * - Comply with the rules of REST by returning appropriate response status codes when there is an error instead of throwing exceptions.
+ * - Send HTTP POST requests if `data` param is specified; GET is suggested but not required for data-less requests
+ */
+export type HttpDataFetcher<T> = (url: string, data?: unknown) => Promise<HttpResponse<T>>;
+export declare class ResponseError extends Error {
+    response: HttpResponse<unknown>;
+    constructor(message: string, response: HttpResponse<unknown>);
+}
+/**
+ * @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 declare function fetchData<T>(url: string, fetcher: HttpDataFetcher<T> | NativeDataFetcherFunction<T>, params?: ParsedUrlQueryInput): Promise<T>;

package/types/debug.d.ts

@@ -0,0 +1,26 @@
+import debug from 'debug';
+export type Debugger = debug.Debugger;
+/**
+ * Enable debug logging dynamically
+ * @param {string} namespaces space-separated list of namespaces to enable
+ */
+export declare const enableDebug: (namespaces: string) => void;
+/**
+ * Default Sitecore JSS 'debug' module debuggers. Uses namespace prefix 'core:'.
+ * See {@link https://www.npmjs.com/package/debug} for details.
+ */
+declare const _default: {
+    common: debug.Debugger;
+    http: debug.Debugger;
+    layout: debug.Debugger;
+    dictionary: debug.Debugger;
+    editing: debug.Debugger;
+    sitemap: debug.Debugger;
+    multisite: debug.Debugger;
+    robots: debug.Debugger;
+    redirects: debug.Debugger;
+    personalize: debug.Debugger;
+    errorpages: debug.Debugger;
+    proxy: debug.Debugger;
+};
+export default _default;

package/types/editing/component-library.d.ts

@@ -0,0 +1,48 @@
+import { ComponentRendering, Field, GenericFieldValue } from '../layout/models';
+/**
+ * Event to be sent when report status to component library
+ */
+export declare const COMPONENT_LIBRARY_STATUS_EVENT_NAME = "component:status";
+/**
+ * Represents an event indicating the status of a component in the library.
+ */
+export interface ComponentLibraryStatusEvent {
+    name: typeof COMPONENT_LIBRARY_STATUS_EVENT_NAME;
+    message: {
+        status: 'ready' | 'rendered';
+        uid: string;
+    };
+}
+/**
+ * Enumeration of statuses for the component library.
+ */
+export declare enum ComponentLibraryStatus {
+    READY = "ready",
+    RENDERED = "rendered"
+}
+/**
+ * Event args for Component Library `update` event
+ */
+export interface ComponentUpdateEventArgs {
+    name: string;
+    details?: {
+        uid: string;
+        params?: Record<string, string>;
+        fields?: Record<string, Field<GenericFieldValue>>;
+    };
+}
+/**
+ * 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 declare const addComponentUpdateHandler: (rootComponent: ComponentRendering, successCallback?: (updatedRootComponent: ComponentRendering) => void) => (() => void) | undefined;
+export declare const updateComponentHandler: (e: MessageEvent, rootComponent: ComponentRendering, successCallback?: (updatedRootComponent: ComponentRendering) => void) => ComponentRendering<import("../layout/models").ComponentFields> | undefined;
+/**
+ * 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 declare function getComponentLibraryStatusEvent(status: ComponentLibraryStatus, uid: string): ComponentLibraryStatusEvent;

package/types/editing/graphql-editing-service.d.ts

@@ -0,0 +1,90 @@
+import { PageInfo } from '../graphql';
+import { GraphQLClient, GraphQLRequestClientFactory } from '../graphql-request-client';
+import { DictionaryPhrases } from '../i18n';
+import { LayoutServiceData } from '../layout';
+import { LayoutKind } from './models';
+/**
+ * GraphQL query for fetching editing data.
+ */
+export declare const query = "\n query EditingQuery(\n    $siteName: String!\n    $itemId: String!\n    $language: String!\n    $version: String\n    $after: String\n    $pageSize: Int = 1000\n) {\n    item(path: $itemId, language: $language, version: $version) {\n      rendered\n    }\n    site {\n      siteInfo(site: $siteName) {\n        dictionary(language: $language, first: $pageSize, after: $after) {\n          results {\n            key\n            value\n          }\n          pageInfo {\n            endCursor\n            hasNext\n          }\n        }\n      }\n    }\n  }\n";
+/**
+ * GraphQL query for fetching dictionary data.
+ * This query is used when the dictionary data is paginated.
+ */
+export declare const dictionaryQuery = "\n  query EditingDictionaryQuery(\n    $siteName: String!\n    $language: String!\n    $after: String\n    $pageSize: Int = 1000\n  ) {\n    site {\n      siteInfo(site: $siteName) {\n        dictionary(language: $language, first: $pageSize, after: $after) {\n          results {\n            key\n            value\n          }\n          pageInfo {\n            endCursor\n            hasNext\n          }\n        }\n      }\n    }\n  }\n";
+/**
+ * Response from the GraphQL Dictionary query.
+ */
+export type GraphQLDictionaryQueryResponse = {
+    site: {
+        siteInfo: {
+            dictionary: {
+                results: {
+                    key: string;
+                    value: string;
+                }[];
+                pageInfo: PageInfo;
+            };
+        };
+    };
+};
+/**
+ * Response from the GraphQL Editing query.
+ */
+export type GraphQLEditingQueryResponse = GraphQLDictionaryQueryResponse & {
+    item: {
+        rendered: LayoutServiceData;
+    };
+};
+export interface GraphQLEditingServiceConfig {
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+}
+/**
+ * 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 declare class GraphQLEditingService {
+    serviceConfig: GraphQLEditingServiceConfig;
+    private graphQLClient;
+    /**
+     * Fetch layout data using the Sitecore GraphQL endpoint.
+     * @param {GraphQLLayoutServiceConfig} serviceConfig configuration
+     */
+    constructor(serviceConfig: GraphQLEditingServiceConfig);
+    /**
+     * 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({ siteName, itemId, language, version, layoutKind, }: {
+        siteName: string;
+        itemId: string;
+        language: string;
+        version?: string;
+        layoutKind?: LayoutKind;
+    }): Promise<{
+        layoutData: LayoutServiceData;
+        dictionary: DictionaryPhrases;
+    }>;
+    fetchDictionaryData({ siteName, language, }: {
+        siteName: string;
+        language: string;
+    }, initDictionary?: {
+        key: string;
+        value: string;
+    }[], hasNext?: boolean, after?: string): Promise<DictionaryPhrases>;
+    /**
+     * Gets a GraphQL client that can make requests to the API.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+}

package/types/editing/index.d.ts

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

package/types/editing/models.d.ts

@@ -0,0 +1,52 @@
+import { LayoutServicePageState } from '../layout';
+/**
+ * Query parameters appended to the page route URL
+ * Appended when XMCloud Pages preview (editing) mode is used
+ * `mode` is a special case as it serves editing and component library both
+ */
+export interface EditingRenderQueryParams {
+    [key: string]: unknown;
+    secret: string;
+    sc_lang: string;
+    sc_itemid: string;
+    sc_site: string;
+    route: string;
+    mode: Exclude<LayoutServicePageState, 'normal'> | 'library';
+    sc_layoutKind?: LayoutKind;
+    sc_variant?: string;
+    sc_version?: string;
+}
+/**
+ * Query parameters appended for Component Library functionaity.
+ * Used when a single component is rendered in Pages.
+ */
+export interface RenderComponentQueryParams {
+    [key: string]: unknown;
+    secret: string;
+    sc_lang: string;
+    sc_itemid: string;
+    sc_renderingId: string;
+    sc_uid: string;
+    sc_site: string;
+    mode: 'library';
+    sc_variant?: string;
+    sc_version?: string;
+}
+/**
+ * Represents the Editing Layout variant.
+ * - shared - shared layout
+ * - final - final layout
+ */
+export declare enum LayoutKind {
+    Final = "final",
+    Shared = "shared"
+}
+/**
+ * Represents the kind of metadata element.
+ * - open - starting chrome element
+ * - close - closing chrome element
+ */
+export declare enum MetadataKind {
+    Open = "open",
+    Close = "close"
+}

package/types/editing/rest-component-layout-service.d.ts

@@ -0,0 +1,100 @@
+import { LayoutServiceData, EditMode } from '../layout/models';
+import { IncomingMessage, ServerResponse } from 'http';
+import { HttpDataFetcher } from '../data-fetcher';
+/**
+ * Data fetcher resolver in order to provide custom data fetcher
+ * @param {IncomingMessage} [req] Request instance
+ * @param {ServerResponse} [res] Response instance
+ */
+export type DataFetcherResolver = <T>(req?: IncomingMessage, res?: ServerResponse) => HttpDataFetcher<T>;
+export type RestLayoutServiceConfig = {
+    /**
+     * Your Sitecore instance hostname that is the backend for JSS
+     */
+    apiHost: string;
+    /**
+     * The Sitecore SSC API key your app uses
+     */
+    apiKey: string;
+    /**
+     * The JSS application name
+     */
+    siteName: string;
+    /**
+     * Enables/disables analytics tracking for the Layout Service invocation (default is true).
+     * More than likely, this would be set to false for SSG/hybrid implementations, and the
+     * JSS tracker would instead be used on the client-side: {@link https://jss.sitecore.com/docs/fundamentals/services/tracking}
+     * @default true
+     */
+    tracking?: boolean;
+    /**
+     * Function that handles fetching API data
+     */
+    dataFetcherResolver?: DataFetcherResolver;
+    /**
+     * Layout Service "named" configuration
+     */
+    configurationName?: string;
+};
+/**
+ * Params for requesting component data from service in Component Library mode
+ */
+export interface ComponentLayoutRequestParams {
+    /**
+     * Item id to be used as context for rendering the component
+     */
+    itemId: string;
+    /**
+     * Component identifier. Can be either taken from item's layout details or
+     * an arbitrary one (component renderingId and datasource would be used for identification then)
+     */
+    componentUid: string;
+    /**
+     * language to render component in
+     */
+    language?: string;
+    /**
+     * optional component datasource
+     */
+    dataSourceId?: string;
+    /**
+     * ID of the component definition rendering item in Sitecore
+     */
+    renderingId?: string;
+    /**
+     * version of the context item (latest by default)
+     */
+    version?: string;
+    /**
+     * edit mode to be rendered component in. Component is rendered in normal mode by default
+     */
+    editMode?: EditMode;
+    /**
+     * site name to be used as context for rendering the component
+     */
+    siteName?: string;
+}
+/**
+ * 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 declare class RestComponentLayoutService {
+    private config;
+    constructor(config: RestLayoutServiceConfig);
+    fetchComponentData(params: ComponentLayoutRequestParams, req?: IncomingMessage, res?: ServerResponse): Promise<LayoutServiceData>;
+    protected getFetcher: (req?: IncomingMessage, res?: ServerResponse) => HttpDataFetcher<LayoutServiceData> | ((url: string, data?: RequestInit) => Promise<import("..").NativeDataFetcherResponse<LayoutServiceData>>);
+    /**
+     * Resolves layout service url
+     * @param {string} apiType which layout service API to call ('render' or 'placeholder')
+     * @returns the layout service url
+     */
+    protected resolveLayoutServiceUrl(apiType: string): string;
+    /**
+     * Provides default @see NativeDataFetcher data fetcher
+     * @param {IncomingMessage} [req] Request instance
+     * @returns default fetcher
+     */
+    protected getDefaultFetcher: <T>(req?: IncomingMessage) => (url: string, data?: RequestInit) => Promise<import("..").NativeDataFetcherResponse<T>>;
+    protected getComponentFetchParams(params: ComponentLayoutRequestParams): any;
+}

package/types/editing/utils.d.ts

@@ -0,0 +1,70 @@
+import { Field, GenericFieldValue } from '../layout/models';
+/**
+ * Default value of uid for root placeholder when uid is not present.
+ */
+export declare const DEFAULT_PLACEHOLDER_UID = "00000000-0000-0000-0000-000000000000";
+/**
+ * Query parameter for editing secret
+ */
+export declare 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 declare const PAGES_EDITING_MARKER = "jss-hrz-editing";
+/**
+ * Default allowed origins for editing requests. This is used to enforce CORS, CSP headers.
+ */
+export declare const EDITING_ALLOWED_ORIGINS: string[];
+/**
+ * Event args for Component Library `update` event
+ */
+export interface ComponentUpdateEventArgs {
+    name: string;
+    details?: {
+        uid: string;
+        params?: Record<string, string>;
+        fields?: Record<string, Field<GenericFieldValue>>;
+    };
+}
+/**
+ * Application metadata
+ */
+export interface Metadata {
+    packages: {
+        [key: string]: string;
+    };
+}
+/**
+ * Copy of chrome rediscovery contract from Horizon (chrome-rediscovery.contract.ts)
+ */
+export declare const ChromeRediscoveryGlobalFunctionName: {
+    name: string;
+};
+/**
+ * Static utility class for Sitecore Pages Editor
+ */
+export declare 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(): boolean;
+    static resetChromes(): void;
+}
+/**
+ * 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 declare const isEditorActive: () => boolean;
+/**
+ * Resets Sitecore editor "chromes"
+ */
+export declare const resetEditorChromes: () => void;
+/**
+ * Gets extra JSS clientData scripts to render in XMC Pages in addition to clientData from Pages itself
+ * @returns {Record} collection of clientData
+ */
+export declare const getJssPagesClientData: () => Record<string, Record<string, unknown>>;

package/types/graphql/app-root-query.d.ts

@@ -0,0 +1,32 @@
+import { GraphQLClient } from '../graphql-request-client';
+/** @private */
+export declare const siteNameError = "The site name must be a non-empty string";
+/** @private */
+export declare const languageError = "The language must be a non-empty string";
+/**
+ * The schema of data returned in response to an app root query request
+ */
+export type AppRootQueryResult = {
+    layout: {
+        homePage: {
+            rootItem: {
+                id: string;
+            }[];
+        };
+    };
+};
+/**
+ * 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 declare function getAppRootId(client: GraphQLClient, siteName: string, language: string, jssAppTemplateId?: string): Promise<string | null>;

package/types/graphql/graphql-edge-proxy.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 declare const getEdgeProxyContentUrl: (sitecoreEdgeContextId: string, sitecoreEdgeUrl?: string) => string;
+/**
+ * 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 declare const getEdgeProxyFormsUrl: (sitecoreEdgeContextId: string, formId: string, sitecoreEdgeUrl?: string) => string;

package/types/graphql/index.d.ts

@@ -0,0 +1,4 @@
+export { getAppRootId, AppRootQueryResult } from './app-root-query';
+export { RetryStrategy, DefaultRetryStrategy, GraphQLClientError, GraphQLClient, GraphQLRequestClient, GraphQLRequestClientConfig, GraphQLRequestClientFactory, GraphQLRequestClientFactoryConfig, } from '../graphql-request-client';
+export { SearchQueryResult, SearchQueryVariables, SearchServiceConfig, SearchQueryService, PageInfo, } from './search-service';
+export { getEdgeProxyContentUrl, getEdgeProxyFormsUrl } from './graphql-edge-proxy';