@sitecore-jss/sitecore-jss-nextjs 21.7.0-canary.6 → 21.7.0-canary.61

package/dist/esm/middleware/personalize-middleware.js

@@ -8,10 +8,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { NextResponse } from 'next/server';
-import { GraphQLPersonalizeService, getPersonalizedRewrite, PosResolver, } from '@sitecore-jss/sitecore-jss/personalize';
+import { GraphQLPersonalizeService, getPersonalizedRewrite, } from '@sitecore-jss/sitecore-jss/personalize';
 import { debug } from '@sitecore-jss/sitecore-jss';
 import { MiddlewareBase } from './middleware';
-import { initServer } from '@sitecore/engage';
+import { init, personalize } from '@sitecore-cloudsdk/personalize/server';
 /**
  * Middleware / handler to support Sitecore Personalize
  */
@@ -23,7 +23,6 @@ export class PersonalizeMiddleware extends MiddlewareBase {
         super(config);
         this.config = config;
         this.handler = (req, res) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
             const pathname = req.nextUrl.pathname;
             const language = this.getLanguage(req);
             const hostname = this.getHostHeader(req) || this.defaultHostname;
@@ -59,30 +58,20 @@ export class PersonalizeMiddleware extends MiddlewareBase {
                 debug.personalize('skipped (no personalization configured)');
                 return response;
             }
-            const engageServer = this.initializeEngageServer(hostname, site, language);
-            // creates the browser ID cookie on the server side
-            // and includes the cookie in the response header
-            try {
-                yield engageServer.handleCookie(req, response, timeout);
-            }
-            catch (error) {
-                debug.personalize('skipped (browser id generation failed)');
-                throw error;
-            }
+            yield this.initPersonalizeServer({
+                hostname,
+                siteName: site.name,
+                request: req,
+                response,
+            });
             const params = this.getExperienceParams(req);
-            debug.personalize('executing experience for %s %s %o', personalizeInfo.contentId, params);
-            const personalizationData = {
-                channel: this.config.cdpConfig.channel || 'WEB',
-                currency: (_a = this.config.cdpConfig.currency) !== null && _a !== void 0 ? _a : 'USA',
-                friendlyId: personalizeInfo.contentId,
-                params,
-                language,
-            };
+            debug.personalize('executing experience for %s %o', personalizeInfo.contentId, params);
             let variantId;
-            // Execute targeted experience in CDP
+            // Execute targeted experience in Personalize SDK
             // eslint-disable-next-line no-useless-catch
             try {
-                variantId = (yield engageServer.personalize(personalizationData, req, timeout)).variantId;
+                const personalization = yield this.personalize({ personalizeInfo, params, language, timeout }, req);
+                variantId = personalization.variantId;
             }
             catch (error) {
                 throw error;
@@ -129,17 +118,29 @@ export class PersonalizeMiddleware extends MiddlewareBase {
             }
         });
     }
-    initializeEngageServer(hostName, site, language) {
-        const engageServer = initServer({
-            clientKey: this.config.cdpConfig.clientKey,
-            targetURL: this.config.cdpConfig.endpoint,
-            pointOfSale: this.config.getPointOfSale
-                ? this.config.getPointOfSale(site, language)
-                : PosResolver.resolve(site, language),
-            cookieDomain: hostName,
-            forceServerCookieMode: true,
+    initPersonalizeServer({ hostname, siteName, request, response, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield init({
+                sitecoreEdgeUrl: this.config.cdpConfig.sitecoreEdgeUrl,
+                sitecoreEdgeContextId: this.config.cdpConfig.sitecoreEdgeContextId,
+                siteName,
+                cookieDomain: hostname,
+                enableServerCookie: true,
+            }, request, response);
+        });
+    }
+    personalize({ params, personalizeInfo, language, timeout, }, request) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const personalizationData = {
+                channel: this.config.cdpConfig.channel || 'WEB',
+                currency: (_a = this.config.cdpConfig.currency) !== null && _a !== void 0 ? _a : 'USD',
+                friendlyId: personalizeInfo.contentId,
+                params,
+                language,
+            };
+            return (yield personalize(personalizationData, request, timeout));
         });
-        return engageServer;
     }
     getExperienceParams(req) {
         const utm = {

package/dist/esm/middleware/redirects-middleware.js

@@ -12,7 +12,8 @@ import { NextResponse } from 'next/server';
 import { GraphQLRedirectsService, REDIRECT_TYPE_301, REDIRECT_TYPE_302, REDIRECT_TYPE_SERVER_TRANSFER, } from '@sitecore-jss/sitecore-jss/site';
 import { debug } from '@sitecore-jss/sitecore-jss';
 import { MiddlewareBase } from './middleware';
-const REGEXP_CONTEXT_SITE_LANG = new RegExp(/\$siteLang/, 'gi');
+const REGEXP_CONTEXT_SITE_LANG = new RegExp(/\$siteLang/, 'i');
+const REGEXP_ABSOLUTE_URL = new RegExp('^(?:[a-z]+:)?//', 'i');
 /**
  * Middleware / handler fetches all redirects from Sitecore instance by grapqhl service
  * compares with current url and redirects to target url
@@ -52,25 +53,35 @@ export class RedirectsMiddleware extends MiddlewareBase {
                     return res || NextResponse.next();
                 }
                 // Find context site language and replace token
-                if (REGEXP_CONTEXT_SITE_LANG.test(existsRedirect.target)) {
+                if (REGEXP_CONTEXT_SITE_LANG.test(existsRedirect.target) &&
+                    !(REGEXP_ABSOLUTE_URL.test(existsRedirect.target) &&
+                        existsRedirect.target.includes(hostname))) {
                     existsRedirect.target = existsRedirect.target.replace(REGEXP_CONTEXT_SITE_LANG, site.language);
                 }
                 const url = req.nextUrl.clone();
-                const absoluteUrlRegex = new RegExp('^(?:[a-z]+:)?//', 'i');
-                if (absoluteUrlRegex.test(existsRedirect.target)) {
+                if (REGEXP_ABSOLUTE_URL.test(existsRedirect.target)) {
                     url.href = existsRedirect.target;
                     url.locale = req.nextUrl.locale;
                 }
                 else {
+                    const source = `${url.pathname}${url.search}`;
                     url.search = existsRedirect.isQueryStringPreserved ? url.search : '';
                     const urlFirstPart = existsRedirect.target.split('/')[1];
                     if (this.locales.includes(urlFirstPart)) {
                         url.locale = urlFirstPart;
                         existsRedirect.target = existsRedirect.target.replace(`/${urlFirstPart}`, '');
                     }
-                    url.pathname = url.pathname
+                    const target = source
                         .replace(regexParser(existsRedirect.pattern), existsRedirect.target)
-                        .replace(/^\/\//, '/');
+                        .replace(/^\/\//, '/')
+                        .split('?');
+                    url.pathname = target[0];
+                    if (target[1]) {
+                        const newParams = new URLSearchParams(target[1]);
+                        for (const [key, val] of newParams.entries()) {
+                            url.searchParams.append(key, val);
+                        }
+                    }
                 }
                 const redirectUrl = decodeURIComponent(url.href);
                 /** return Response redirect with http code of redirect type **/
@@ -135,13 +146,17 @@ export class RedirectsMiddleware extends MiddlewareBase {
             const redirects = yield this.redirectsService.fetchRedirects(siteName);
             const tragetURL = req.nextUrl.pathname;
             const targetQS = req.nextUrl.search || '';
-            return redirects.length
-                ? redirects.find((redirect) => {
+            const language = this.getLanguage(req);
+            const modifyRedirects = structuredClone(redirects);
+            return modifyRedirects.length
+                ? modifyRedirects.find((redirect) => {
+                    redirect.pattern = redirect.pattern.replace(RegExp(`^[^]?/${language}/`, 'gi'), '');
                     redirect.pattern = `/^\/${redirect.pattern
                         .replace(/^\/|\/$/g, '')
                         .replace(/^\^\/|\/\$$/g, '')
                         .replace(/^\^|\$$/g, '')
-                        .replace(/\$\/gi$/g, '')}$/gi`;
+                        .replace(/(?<!\\)\?/g, '\\?')
+                        .replace(/\$\/gi$/g, '')}[\/]?$/gi`;
                     return ((regexParser(redirect.pattern).test(tragetURL) ||
                         regexParser(redirect.pattern).test(`${tragetURL}${targetQS}`) ||
                         regexParser(redirect.pattern).test(`/${req.nextUrl.locale}${tragetURL}`) ||

package/dist/esm/revalidate/index.js

@@ -0,0 +1 @@
+export { RevalidateMiddleware } from './revalidate-middleware';

package/dist/esm/revalidate/revalidate-middleware.js

@@ -0,0 +1,212 @@
+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 { I18NConfig } from 'next/dist/server/config-shared';
+import { GraphQLPersonalizeService, getPersonalizedRewrite, } from '@sitecore-jss/sitecore-jss/personalize';
+import { getSiteRewrite } from '@sitecore-jss/sitecore-jss/site';
+import { debug } from '@sitecore-jss/sitecore-jss';
+var EntityDefinition;
+(function (EntityDefinition) {
+    EntityDefinition["LayoutData"] = "LayoutData";
+    EntityDefinition["Item"] = "Item";
+})(EntityDefinition || (EntityDefinition = {}));
+/**
+ * Middleware / handler for on-demand ISR (e.g. '/api/revalidate').
+ */
+export class RevalidateMiddleware {
+    constructor(config) {
+        this.config = config;
+        this.handler = (req, res) => __awaiter(this, void 0, void 0, function* () {
+            // filter out updated paths and language from request.body
+            const filteredUpdates = this.getFilteredUpdates(req);
+            if (this.isEmpty(filteredUpdates)) {
+                // nothing to revalidate
+                return res.status(204).json({ message: 'No updates to revalidate' });
+            }
+            // extract only paths from filtered updates object
+            const paths = this.extractPaths(filteredUpdates);
+            const pathsToRevalidate = [];
+            // when personalization is configured and when both multiSite and personalization are configured
+            if (this.config.personalize) {
+                const personalizeInfo = yield this.getPersonalizedResults(filteredUpdates);
+                if (this.config.multiSite) {
+                    this.handleMultiSitePersonalization(personalizeInfo, pathsToRevalidate, this.getPathName, this.getSiteName);
+                }
+                else {
+                    this.handleNonMultiSitePersonalization(personalizeInfo, pathsToRevalidate, this.getPathName);
+                }
+            }
+            // when only multiSite is configured
+            if (this.config.multiSite && !this.config.personalize) {
+                const multiSitePaths = paths.map((path) => getSiteRewrite(this.getPathName(path), { siteName: this.getSiteName(path) }));
+                pathsToRevalidate.push(...multiSitePaths);
+            }
+            // when both multiSite and personalization are not configured
+            if (!this.config.multiSite && !this.config.personalize) {
+                const defaultPaths = paths.map((path) => this.getPathName(path));
+                pathsToRevalidate.push(...defaultPaths);
+            }
+            // when other locales are configured besides defaultLocale
+            if (!this.isEmpty(filteredUpdates)) {
+                const filteredLanguage = [...new Set(filteredUpdates.map(({ language }) => language))].join(',');
+                if (this.config.localePrefix) {
+                    const language = this.config.localePrefix(filteredLanguage);
+                    if (language) {
+                        yield Promise.all(pathsToRevalidate.map((path) => res.revalidate(`/${language}` + path)));
+                    }
+                }
+            }
+            yield Promise.all(pathsToRevalidate.map((path) => res.revalidate(path)));
+            debug.revalidate(`revalidated paths: ${pathsToRevalidate.join(', ')}`);
+        });
+        this.personalizeService = new GraphQLPersonalizeService({
+            clientFactory: config.clientFactory,
+        });
+    }
+    /**
+     * Generates a Next.js API route handler that executes a revalidation process.
+     * @returns The route handler function for handling Next.js API requests.
+     */
+    getHandler() {
+        return (req, res) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.handler(req, res);
+                return res.status(200).json({ revalidated: true });
+            }
+            catch (error) {
+                console.log('Error Revalidating:');
+                console.log(error);
+                return res.status(500).json({ revalidated: false });
+            }
+        });
+    }
+    /**
+     * Gets personalized results for the updated paths
+     * @param {UpdatedPaths[]} filteredUpdates Updated paths
+     */
+    getPersonalizedResults(filteredUpdates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const personalizedResults = [];
+            const nonPersonalizedResults = [];
+            yield Promise.all(filteredUpdates.map((update) => __awaiter(this, void 0, void 0, function* () {
+                const siteName = this.getSiteName(update.path);
+                const pathName = this.getPathName(update.path);
+                const personalizeInfo = yield this.personalizeService.getPersonalizeInfo(pathName, update.language, siteName);
+                if (personalizeInfo && personalizeInfo.variantIds.length > 0) {
+                    personalizeInfo.variantIds.forEach((variantId) => {
+                        personalizedResults.push({
+                            path: update.path,
+                            variantId,
+                        });
+                    });
+                }
+                else {
+                    // Collect paths without personalized info
+                    nonPersonalizedResults.push({
+                        path: update.path,
+                    });
+                }
+            })));
+            return {
+                personalized: personalizedResults,
+                nonPersonalized: nonPersonalizedResults,
+            };
+        });
+    }
+    isEmpty(data) {
+        return data.length === 0;
+    }
+    /**
+     * Extracts the paths from the updated paths
+     * @param {UpdatedPaths[]} filteredUpdates Updated paths
+     * @returns {string[]} paths
+     */
+    extractPaths(filteredUpdates) {
+        return filteredUpdates.map((update) => update.path);
+    }
+    /**
+     * Gets the site name from the path name
+     * @param {string} pathname Path name
+     * @returns {string} site name
+     */
+    getSiteName(pathname) {
+        let siteName = '';
+        const path = pathname.endsWith('/') ? pathname : pathname + '/';
+        const result = path.match('(.*?)\\/');
+        if (result && result[1] !== '') {
+            siteName = result[1];
+        }
+        return siteName;
+    }
+    /**
+     * Gets the path name from the full path
+     * @param {string} fullPath Full path
+     * @returns {string} path name
+     */
+    getPathName(fullPath) {
+        const pathParts = fullPath.split('/').filter((part) => part !== '');
+        if (pathParts.length >= 2) {
+            const siteName = `/${pathParts[0]}/`;
+            const path = `/${pathParts.slice(1).join('/')}`;
+            return path.startsWith(siteName) ? path.slice(siteName.length) : path;
+        }
+        return '/';
+    }
+    extractSiteName(path) {
+        const siteName = path.split('/')[0];
+        return siteName;
+    }
+    /**
+     * Filters out the updated paths and language from the request body
+     * @param {NextApiRequest} req Next.js API request
+     * @returns {UpdatedPaths[]} updated paths
+     */
+    getFilteredUpdates(req) {
+        var _a, _b;
+        if (!((_a = req.body) === null || _a === void 0 ? void 0 : _a.updates) || this.isEmpty(req.body.updates)) {
+            return [];
+        }
+        return (_b = req.body) === null || _b === void 0 ? void 0 : _b.updates.filter((update) => update.entity_definition === EntityDefinition.LayoutData && update.entity_culture).map((update) => {
+            if (update.identifier === 'website/') {
+                return null;
+            }
+            return {
+                path: update.identifier,
+                language: update.entity_culture,
+            };
+        }).filter(Boolean);
+    }
+    handleMultiSitePersonalization(personalizeInfo, pathsToRevalidate, getPathName, getSiteName) {
+        if (personalizeInfo.personalized.length > 0) {
+            const personalizedRewrite = personalizeInfo.personalized.map((info) => {
+                return getPersonalizedRewrite(getSiteRewrite(getPathName(info.path), { siteName: getSiteName(info.path) }), {
+                    variantId: info.variantId,
+                });
+            });
+            pathsToRevalidate.push(...personalizedRewrite);
+        }
+        if (personalizeInfo.nonPersonalized.length > 0) {
+            const nonPersonalizedRewrite = personalizeInfo.nonPersonalized.map((info) => {
+                return getSiteRewrite(getPathName(info.path), {
+                    siteName: getSiteName(info.path),
+                });
+            });
+            pathsToRevalidate.push(...nonPersonalizedRewrite);
+        }
+    }
+    handleNonMultiSitePersonalization(personalizeInfo, pathsToRevalidate, getPathName) {
+        const nonMultiSitePersonalizedRewrite = personalizeInfo.personalized.map((info) => {
+            return getPersonalizedRewrite(getPathName(info.path), { variantId: info.variantId });
+        });
+        const nonMultiSiteNonPersonalizedRewrite = personalizeInfo.nonPersonalized.map((info) => {
+            return this.getPathName(info.path);
+        });
+        pathsToRevalidate.push(...nonMultiSitePersonalizedRewrite, ...nonMultiSiteNonPersonalizedRewrite);
+    }
+}

package/dist/esm/utils/utils.js

@@ -1,4 +1,3 @@
-import chalk from 'chalk';
 import { isEditorActive, resetEditorChromes } from '@sitecore-jss/sitecore-jss/utils';
 /**
  * Get the publicUrl.
@@ -7,27 +6,19 @@ import { isEditorActive, resetEditorChromes } from '@sitecore-jss/sitecore-jss/u
  * VERCEL_URL is provided by Vercel in case if we are in Preview deployment (deployment based on the custom branch),
  * preview deployment has unique url, we don't know exact url.
  * Similarly, DEPLOY_URL is provided by Netlify and would give us the deploy URL
+ * In production non-editing environments it is desirable to use relative urls, so in that case set PUBLIC_URL = ''
  */
 export const getPublicUrl = () => {
-    if (process.env.NETLIFY && process.env.DEPLOY_URL)
-        return process.env.DEPLOY_URL;
-    if (process.env.VERCEL_URL)
-        return `https://${process.env.VERCEL_URL}`;
     let url = process.env.PUBLIC_URL;
     if (url === undefined) {
-        console.warn(`${chalk.yellow.bold('Warning:')} An PUBLIC_URL environment variable is not defined. Falling back to http://localhost:3000.`);
+        if (process.env.NETLIFY && process.env.DEPLOY_URL)
+            return process.env.DEPLOY_URL;
+        if (process.env.VERCEL_URL)
+            return `https://${process.env.VERCEL_URL}`;
         url = 'http://localhost:3000';
     }
-    else {
-        try {
-            new URL(url);
-        }
-        catch (error) {
-            throw new Error(`The PUBLIC_URL environment variable '${url}' is not a valid URL.`);
-        }
-    }
     // Ensure no trailing slash
-    return url.toString().replace(/\/$/, '');
+    return url.replace(/\/$/, '');
 };
 /**
  * Since Sitecore editors do not support Fast Refresh:

package/package.json

@@ -1,21 +1,20 @@
 {
   "name": "@sitecore-jss/sitecore-jss-nextjs",
-  "version": "21.7.0-canary.6",
+  "version": "21.7.0-canary.61",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "sideEffects": false,
   "scripts": {
     "build": "npm run clean && tsc -p tsconfig.json && tsc -p tsconfig-esm.json",
     "clean": "del-cli dist types",
-    "lint": "eslint ./src/**/*.tsx ./src/**/*.ts",
+    "lint": "eslint \"./src/**/*.tsx\" \"./src/**/*.ts\"",
     "test": "mocha --require ./test/setup.js \"./src/**/*.test.ts\" \"./src/**/*.test.tsx\" --exit",
     "prepublishOnly": "npm run build",
     "coverage": "nyc npm test",
-    "generate-docs": "npx typedoc --plugin typedoc-plugin-markdown --readme none --out ../../ref-docs/sitecore-jss-nextjs --entryPoints src/index.ts --entryPoints src/monitoring/index.ts --entryPoints src/editing/index.ts --entryPoints src/middleware/index.ts --githubPages false"
+    "generate-docs": "npx typedoc --plugin typedoc-plugin-markdown --readme none --out ../../ref-docs/sitecore-jss-nextjs --entryPoints src/index.ts --entryPoints src/monitoring/index.ts --entryPoints src/editing/index.ts --entryPoints src/middleware/index.ts --entryPoints src/context/index.ts --entryPoints src/utils/index.ts --entryPoints src/site/index.ts --entryPoints src/graphql/index.ts --entryPoints src/revalidate/index.ts --githubPages false"
   },
   "engines": {
-    "node": ">=12",
-    "npm": ">=6"
+    "node": ">=18"
   },
   "author": {
     "name": "Sitecore Corporation",
@@ -30,7 +29,7 @@
     "url": "https://github.com/sitecore/jss/issues"
   },
   "devDependencies": {
-    "@sitecore/engage": "^1.4.1",
+    "@sitecore-cloudsdk/personalize": "^0.1.1",
     "@types/chai": "^4.3.4",
     "@types/chai-as-promised": "^7.1.5",
     "@types/chai-string": "^1.4.2",
@@ -55,7 +54,7 @@
     "eslint-plugin-react": "^7.32.1",
     "jsdom": "^21.1.0",
     "mocha": "^10.2.0",
-    "next": "^13.4.16",
+    "next": "^14.1.0",
     "nock": "^13.3.0",
     "nyc": "^15.1.0",
     "react": "^18.2.0",
@@ -66,15 +65,16 @@
     "typescript": "~4.9.4"
   },
   "peerDependencies": {
-    "@sitecore/engage": "^1.4.1",
-    "next": "^13.4.16",
+    "@sitecore-cloudsdk/events": "^0.1.1",
+    "@sitecore-cloudsdk/personalize": "^0.1.1",
+    "next": "^14.1.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
   "dependencies": {
-    "@sitecore-jss/sitecore-jss": "^21.7.0-canary.6",
-    "@sitecore-jss/sitecore-jss-dev-tools": "^21.7.0-canary.6",
-    "@sitecore-jss/sitecore-jss-react": "^21.7.0-canary.6",
+    "@sitecore-jss/sitecore-jss": "^21.7.0-canary.61",
+    "@sitecore-jss/sitecore-jss-dev-tools": "^21.7.0-canary.61",
+    "@sitecore-jss/sitecore-jss-react": "^21.7.0-canary.61",
     "@vercel/kv": "^0.2.1",
     "node-html-parser": "^6.1.4",
     "prop-types": "^15.8.1",
@@ -83,7 +83,7 @@
   },
   "description": "",
   "types": "types/index.d.ts",
-  "gitHead": "3468861efc54046977809988c5a6d0745a40aacb",
+  "gitHead": "cc2bf3228ef6492eb9c6b2702d763ec44eaf189b",
   "files": [
     "dist",
     "types",

package/revalidate.d.ts

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

package/revalidate.js

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

package/types/components/NextImage.d.ts

@@ -1,8 +1,7 @@
 /// <reference types="@types/react" />
 import React from 'react';
 import { ImageProps } from '@sitecore-jss/sitecore-jss-react';
-import { ImageLoader, ImageProps as NextImageProperties } from 'next/image';
+import { ImageProps as NextImageProperties } from 'next/image';
 type NextImageProps = Omit<ImageProps, 'media'> & Partial<NextImageProperties>;
-export declare const sitecoreLoader: ImageLoader;
 export declare const NextImage: React.FC<NextImageProps>;
 export {};

package/types/context/context.d.ts

@@ -0,0 +1,116 @@
+import { LayoutServicePageState } from '@sitecore-jss/sitecore-jss-react';
+/**
+ * Software Development Kit (SDK) instance
+ */
+export type SDK<SDKType = unknown> = {
+    /**
+     * The Software Development Kit (SDK) library instance
+     */
+    sdk: SDKType;
+    /**
+     * Initializes the Software Development Kit (SDK)
+     */
+    init: (props: InitSDKProps) => Promise<void>;
+};
+/**
+ * Software Development Kits (SDKs) to be initialized
+ */
+type SDKModulesType = Record<string, SDK>;
+/**
+ * Properties that are passed to the Context.
+ */
+export interface ContextInitProps {
+    /**
+     * Your Sitecore site name
+     */
+    siteName?: string;
+    /**
+     * Sitecore page state (normal, preview, edit)
+     */
+    pageState?: LayoutServicePageState;
+}
+/**
+ * Configuration that is passed to the Context.
+ */
+export interface ContextConfig<SDKModules extends SDKModulesType> {
+    /**
+     * Your Sitecore Edge URL
+     */
+    sitecoreEdgeUrl: string;
+    /**
+     * Your Sitecore Edge Context ID
+     */
+    sitecoreEdgeContextId: string;
+    /**
+     * Your Sitecore site name
+     */
+    siteName: string;
+    /**
+     * Software Development Kits (SDKs) to be initialized
+     */
+    sdks: {
+        [module in keyof SDKModules]: SDKModules[module];
+    };
+}
+/**
+ * Properties that are passed to the Software Development Kit (SDK) initialization function.
+ */
+type InitSDKProps = Omit<ContextConfig<SDKModulesType>, 'sdks'>;
+/**
+ * Context instance that is used to initialize the application Context and associated Software Development Kits (SDKs).
+ */
+export declare class Context<SDKModules extends SDKModulesType> {
+    protected props: ContextConfig<SDKModules>;
+    /**
+     * Indicates whether the Context and SDK(s) have been initialized
+     */
+    isInitialized: boolean;
+    /**
+     * The Sitecore Edge URL
+     */
+    readonly sitecoreEdgeUrl: string;
+    /**
+     * The Sitecore Edge Context ID
+     */
+    readonly sitecoreEdgeContextId: string;
+    /**
+     * The Sitecore site name
+     */
+    siteName: string;
+    /**
+     * Sitecore page state (normal, preview, edit)
+     */
+    pageState: LayoutServicePageState;
+    /**
+     * Software Development Kits (SDKs) to be initialized
+     */
+    readonly sdks: {
+        [module in keyof SDKModules]?: SDKModules[module]['sdk'];
+    };
+    /**
+     * Promises for the SDKs
+     */
+    protected sdkPromises: {
+        [module in keyof SDKModules]?: Promise<SDKModules[module]['sdk']>;
+    };
+    protected sdkErrors: {
+        [module in keyof SDKModules]?: string;
+    };
+    constructor(props: ContextConfig<SDKModules>);
+    init(props?: ContextInitProps): void;
+    /**
+     * Retrieves the Software Development Kit (SDK) instance, ensuring it is initialized before returning
+     *
+     * @param {string} name SDK name
+     * @returns initialized SDK
+     */
+    getSDK: <T extends keyof SDKModules>(name: T) => Promise<SDKModules[T]["sdk"]>;
+    /**
+     * Initializes the Software Development Kit (SDK)
+     *
+     * @param {T} name SDK name
+     * @returns {void}
+     */
+    protected initSDK<T extends keyof SDKModules>(name: T): void;
+}
+export {};

package/types/context/index.d.ts

@@ -0,0 +1 @@
+export { Context, ContextConfig, SDK } from './context';