@croct/plug 0.10.2 → 0.11.0-alpha.2

package/constants.d.ts

@@ -1,3 +1,5 @@
 export declare const CDN_URL = "https://cdn.croct.io/js/v1/lib/plug.js";
 export declare const PLAYGROUND_ORIGIN = "https://play.croct.com";
 export declare const PLAYGROUND_CONNECT_URL = "https://play.croct.com/connect.html";
+export declare const PREVIEW_WIDGET_ORIGIN = "https://cdn.croct.io";
+export declare const PREVIEW_WIDGET_URL = "https://cdn.croct.io/js/v1/lib/plug/widget-0.11.0-alpha.2.html";

package/constants.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PLAYGROUND_CONNECT_URL = exports.PLAYGROUND_ORIGIN = exports.CDN_URL = void 0;
+exports.PREVIEW_WIDGET_URL = exports.PREVIEW_WIDGET_ORIGIN = exports.PLAYGROUND_CONNECT_URL = exports.PLAYGROUND_ORIGIN = exports.CDN_URL = void 0;
 exports.CDN_URL = 'https://cdn.croct.io/js/v1/lib/plug.js';
 exports.PLAYGROUND_ORIGIN = 'https://play.croct.com';
 exports.PLAYGROUND_CONNECT_URL = 'https://play.croct.com/connect.html';
+exports.PREVIEW_WIDGET_ORIGIN = 'https://cdn.croct.io';
+exports.PREVIEW_WIDGET_URL = 'https://cdn.croct.io/js/v1/lib/plug/widget-0.11.0-alpha.2.html';

package/eap.d.ts

@@ -1,8 +1,8 @@
-import { SlotId, FetchResponse } from './fetch';
-import { NullableJsonObject } from './sdk/json';
-import { Plug } from './plug';
+import { VersionedSlotId } from './slot';
+import { JsonObject } from './sdk/json';
+import { LegacyFetchResponse, Plug } from './plug';
 export interface EapFeatures {
-    fetch<P extends NullableJsonObject, I extends SlotId = SlotId>(this: Plug, slotId: I): Promise<FetchResponse<I, P>>;
+    fetch<P extends JsonObject, I extends VersionedSlotId>(this: Plug, slotId: I): Promise<LegacyFetchResponse<I, P>>;
 }
 interface EapHooks extends EapFeatures {
     initialize(this: Plug): void;

package/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var plug_1 = require("./plug");
+const plug_1 = require("./plug");
 /* eslint-disable-next-line import/no-default-export -- Should be default export */
 exports.default = new plug_1.GlobalPlug();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@croct/plug",
-  "version": "0.10.2",
+  "version": "0.11.0-alpha.2",
   "description": "A fully-featured devkit for building natively personalized applications.",
   "license": "MIT",
   "author": {
@@ -34,27 +34,24 @@
   },
   "dependencies": {
     "@croct/json": "^1.1.0",
-    "@croct/sdk": "^0.10.0",
+    "@croct/sdk": "^0.11.0-alpha",
     "tslib": "^2.2.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.14.3",
-    "@babel/preset-env": "^7.14.2",
-    "@babel/preset-typescript": "^7.13.0",
-    "@croct/eslint-plugin": "^0.6.2",
-    "@rollup/plugin-commonjs": "^19.0.0",
-    "@rollup/plugin-node-resolve": "^13.0.0",
-    "@rollup/plugin-replace": "^2.4.2",
-    "@rollup/plugin-typescript": "^8.2.1",
-    "@types/jest": "^26.0.23",
+    "@croct/eslint-plugin": "^0.6.3",
+    "@rollup/plugin-commonjs": "^23.0.2",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@rollup/plugin-replace": "^5.0.1",
+    "@rollup/plugin-terser": "^0.1.0",
+    "@rollup/plugin-typescript": "^9.0.2",
+    "@types/jest": "^29.2.2",
     "@typescript-eslint/parser": "^5.30.0",
-    "babel-jest": "^26.6.3",
-    "eslint": "^8.18.0",
-    "jest": "^26.6.3",
-    "rollup": "^2.48.0",
-    "rollup-plugin-terser": "^7.0.2",
-    "ts-jest": "^26.5.6",
-    "typescript": "^4.2.4"
+    "eslint": "^8.27.0",
+    "jest": "^29.3.1",
+    "jest-environment-jsdom": "^29.3.1",
+    "rollup": "^3.3.0",
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.9.3"
   },
   "browserslist": [
     "last 1 version"

package/playground.d.ts

@@ -4,7 +4,7 @@ import { Campaign, Page } from '@croct/sdk/evaluator';
 import { Plugin, PluginFactory } from './plugin';
 import { Logger, SdkEventSubscriber, Tab } from './sdk';
 import { TokenProvider } from './sdk/token';
-export declare type Configuration = {
+export type Configuration = {
     appId: string;
     connectionId?: string;
     sdkVersion: string;
@@ -16,7 +16,7 @@ export declare type Configuration = {
     tokenProvider: TokenProvider;
     logger: Logger;
 };
-export declare type SyncPayload = {
+export type SyncPayload = {
     appId: string;
     connectionId: string;
     sdkVersion: string;
@@ -48,7 +48,7 @@ export declare class PlaygroundPlugin implements Plugin {
     private syncToken;
     private createContext;
 }
-export declare type Options = {
+export type Options = {
     connectionId?: string;
 };
 export declare const factory: PluginFactory<Options>;

package/playground.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.factory = exports.PlaygroundPlugin = void 0;
-var error_1 = require("@croct/sdk/error");
-var evaluatorFacade_1 = require("@croct/sdk/facade/evaluatorFacade");
-var constants_1 = require("./constants");
-var CONNECTION_PARAMETER = '__cplay';
-var PlaygroundPlugin = /** @class */ (function () {
-    function PlaygroundPlugin(configuration) {
+const error_1 = require("@croct/sdk/error");
+const evaluatorFacade_1 = require("@croct/sdk/facade/evaluatorFacade");
+const constants_1 = require("./constants");
+const CONNECTION_PARAMETER = '__cplay';
+class PlaygroundPlugin {
+    constructor(configuration) {
         this.sdkVersion = configuration.sdkVersion;
         this.appId = configuration.appId;
         this.connectionId = configuration.connectionId;
@@ -18,31 +18,30 @@ var PlaygroundPlugin = /** @class */ (function () {
         this.tokenProvider = configuration.tokenProvider;
         this.logger = configuration.logger;
     }
-    PlaygroundPlugin.prototype.enable = function () {
-        var _this = this;
-        var connectionId = this.resolveConnectionId();
+    enable() {
+        const connectionId = this.resolveConnectionId();
         if (connectionId === null) {
             return;
         }
-        this.syncListener = function () { return _this.cidAssigner
+        this.syncListener = () => this.cidAssigner
             .assignCid()
-            .then(function (cid) {
-            _this.syncToken(connectionId, cid);
+            .then(cid => {
+            this.syncToken(connectionId, cid);
         })
-            .catch(function (error) {
-            _this.logger.warn("Sync failed: ".concat((0, error_1.formatCause)(error)));
-        }); };
+            .catch(error => {
+            this.logger.warn(`Sync failed: ${(0, error_1.formatCause)(error)}`);
+        });
         this.eventSubscriber.addListener('tokenChanged', this.syncListener);
         this.tab.addListener('urlChange', this.syncListener);
         return this.syncListener();
-    };
-    PlaygroundPlugin.prototype.resolveConnectionId = function () {
+    }
+    resolveConnectionId() {
         if (this.connectionId !== undefined) {
             this.logger.debug('Connection ID passed in configuration');
             return this.connectionId;
         }
-        var url = new URL(this.tab.url);
-        var connectionId = url.searchParams.get(CONNECTION_PARAMETER);
+        const url = new URL(this.tab.url);
+        let connectionId = url.searchParams.get(CONNECTION_PARAMETER);
         if (connectionId === null || connectionId === '') {
             this.logger.debug('No connection ID found in URL');
             connectionId = this.storage.getItem('connectionId');
@@ -54,17 +53,16 @@ var PlaygroundPlugin = /** @class */ (function () {
         this.logger.debug('Connection ID found in URL');
         this.storage.setItem('connectionId', connectionId);
         return connectionId;
-    };
-    PlaygroundPlugin.prototype.disable = function () {
+    }
+    disable() {
         if (this.syncListener !== undefined) {
             this.eventSubscriber.removeListener('tokenChanged', this.syncListener);
             this.tab.removeListener('urlChange', this.syncListener);
             delete this.syncListener;
         }
-    };
-    PlaygroundPlugin.prototype.syncToken = function (connectionId, cid) {
-        var _this = this;
-        var iframe = document.createElement('iframe');
+    }
+    syncToken(connectionId, cid) {
+        const iframe = document.createElement('iframe');
         iframe.setAttribute('src', constants_1.PLAYGROUND_CONNECT_URL);
         iframe.setAttribute('sandbox', 'allow-scripts allow-same-origin');
         iframe.style.visibility = 'hidden';
@@ -72,17 +70,17 @@ var PlaygroundPlugin = /** @class */ (function () {
         iframe.style.border = '0';
         iframe.style.width = '0';
         iframe.style.height = '0';
-        var context = this.createContext();
-        iframe.onload = function () {
+        const context = this.createContext();
+        iframe.onload = () => {
             var _a, _b;
             if (iframe.contentWindow === null) {
                 if (document.body.contains(iframe)) {
                     document.body.removeChild(iframe);
                 }
-                _this.logger.warn('Sync handshake failed');
+                this.logger.warn('Sync handshake failed');
                 return;
             }
-            var listener = function (event) {
+            const listener = (event) => {
                 if (event.origin !== constants_1.PLAYGROUND_ORIGIN || event.data !== connectionId) {
                     return;
                 }
@@ -90,24 +88,24 @@ var PlaygroundPlugin = /** @class */ (function () {
                 if (document.body.contains(iframe)) {
                     document.body.removeChild(iframe);
                 }
-                _this.logger.debug('Sync completed');
+                this.logger.debug('Sync completed');
             };
             window.addEventListener('message', listener);
-            var payload = {
-                appId: _this.appId,
+            const payload = {
+                appId: this.appId,
                 connectionId: connectionId,
-                sdkVersion: _this.sdkVersion,
-                tabId: _this.tab.id,
+                sdkVersion: this.sdkVersion,
+                tabId: this.tab.id,
                 cid: cid,
-                token: (_b = (_a = _this.tokenProvider
+                token: (_b = (_a = this.tokenProvider
                     .getToken()) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : null,
                 context: context,
             };
             iframe.contentWindow.postMessage(payload, constants_1.PLAYGROUND_ORIGIN);
-            _this.logger.debug('Waiting for sync acknowledgment...');
+            this.logger.debug('Waiting for sync acknowledgment...');
         };
         this.logger.debug('Sync started');
-        var connect = function () {
+        const connect = () => {
             document.body.appendChild(iframe);
         };
         if (document.body === null) {
@@ -116,33 +114,32 @@ var PlaygroundPlugin = /** @class */ (function () {
         else {
             connect();
         }
-    };
-    PlaygroundPlugin.prototype.createContext = function () {
-        var _a = this.contextFactory.createContext(), page = _a.page, campaign = _a.campaign, timezone = _a.timezone;
-        var context = {};
+    }
+    createContext() {
+        const { page, campaign, timeZone } = this.contextFactory.createContext();
+        const context = {};
         if (page !== undefined) {
             context.page = page;
         }
         if (campaign !== undefined) {
             context.campaign = campaign;
         }
-        if (timezone !== undefined) {
-            context.timezone = timezone;
+        if (timeZone !== undefined) {
+            context.timeZone = timeZone;
         }
         return context;
-    };
-    return PlaygroundPlugin;
-}());
+    }
+}
 exports.PlaygroundPlugin = PlaygroundPlugin;
-var factory = function (props) {
-    var sdk = props.sdk, options = props.options;
+const factory = (props) => {
+    const { sdk, options } = props;
     return new PlaygroundPlugin({
         sdkVersion: sdk.version,
         appId: sdk.appId,
         connectionId: options.connectionId,
         tab: sdk.tab,
         storage: sdk.getTabStorage(),
-        tokenProvider: sdk.tokenStore,
+        tokenProvider: sdk.userTokenStore,
         cidAssigner: sdk.cidAssigner,
         contextFactory: new evaluatorFacade_1.TabContextFactory(sdk.tab),
         eventSubscriber: sdk.eventManager,

package/plug.d.ts

@@ -1,20 +1,34 @@
 import { SessionFacade } from '@croct/sdk/facade/sessionFacade';
 import { UserFacade } from '@croct/sdk/facade/userFacade';
 import { TrackerFacade } from '@croct/sdk/facade/trackerFacade';
-import { EvaluatorFacade, EvaluationOptions } from '@croct/sdk/facade/evaluatorFacade';
+import { EvaluationOptions, EvaluatorFacade } from '@croct/sdk/facade/evaluatorFacade';
 import { Configuration as SdkFacadeConfiguration } from '@croct/sdk/facade/sdkFacade';
 import { Optional } from '@croct/sdk/utilityTypes';
 import { ExternalTrackingEvent as ExternalEvent, ExternalTrackingEventPayload as ExternalEventPayload, ExternalTrackingEventType as ExternalEventType } from '@croct/sdk/trackingEvents';
+import { FetchOptions as BaseFetchOptions } from '@croct/sdk/facade/contentFetcherFacade';
 import { PluginFactory } from './plugin';
 import { EapFeatures } from './eap';
-import { SlotId, FetchResponse, FetchOptions } from './fetch';
-import { NullableJsonObject, JsonValue } from './sdk/json';
+import { VersionedSlotId, SlotContent } from './slot';
+import { JsonValue, JsonObject } from './sdk/json';
 export interface PluginConfigurations {
     [key: string]: any;
 }
-export declare type Configuration = Optional<SdkFacadeConfiguration, 'appId'> & {
+export type Configuration = Optional<SdkFacadeConfiguration, 'appId'> & {
     plugins?: PluginConfigurations;
 };
+export type FetchOptions = Omit<BaseFetchOptions, 'version'>;
+export type FetchResponse<I extends VersionedSlotId, C extends JsonObject = JsonObject> = {
+    content: SlotContent<I, C>;
+};
+/**
+ * @internal
+ */
+export type LegacyFetchResponse<I extends VersionedSlotId, C extends JsonObject = JsonObject> = FetchResponse<I, C> & {
+    /**
+     * @deprecated Use `content` instead.
+     */
+    payload: SlotContent<I, C>;
+};
 export interface Plug extends EapFeatures {
     readonly tracker: TrackerFacade;
     readonly user: UserFacade;
@@ -31,6 +45,7 @@ export interface Plug extends EapFeatures {
     unsetToken(): void;
     track<T extends ExternalEventType>(type: T, payload: ExternalEventPayload<T>): Promise<ExternalEvent<T>>;
     evaluate<T extends JsonValue>(expression: string, options?: EvaluationOptions): Promise<T>;
+    fetch<P extends JsonObject, I extends VersionedSlotId>(slotId: I, options?: FetchOptions): Promise<LegacyFetchResponse<I, P>>;
     unplug(): Promise<void>;
 }
 export declare class GlobalPlug implements Plug {
@@ -59,10 +74,7 @@ export declare class GlobalPlug implements Plug {
     track<T extends ExternalEventType>(type: T, payload: ExternalEventPayload<T>): Promise<ExternalEvent<T>>;
     evaluate<T extends JsonValue>(expression: string, options?: EvaluationOptions): Promise<T>;
     test(expression: string, options?: EvaluationOptions): Promise<boolean>;
-    /**
-     * This API is unstable and subject to change in future releases.
-     */
-    fetch<P extends NullableJsonObject, I extends SlotId = SlotId>(slotId: I, options?: FetchOptions): Promise<FetchResponse<I, P>>;
+    get fetch(): Plug['fetch'];
     unplug(): Promise<void>;
     private eap;
 }

package/plug.js

@@ -1,87 +1,92 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlobalPlug = void 0;
-var tslib_1 = require("tslib");
-var sdkFacade_1 = require("@croct/sdk/facade/sdkFacade");
-var error_1 = require("@croct/sdk/error");
-var validation_1 = require("@croct/sdk/validation");
-var token_1 = require("@croct/sdk/token");
-var sdk_1 = require("@croct/sdk");
-var constants_1 = require("./constants");
-var playground_1 = require("./playground");
-var PLUGIN_NAMESPACE = 'Plugin';
+const sdkFacade_1 = require("@croct/sdk/facade/sdkFacade");
+const error_1 = require("@croct/sdk/error");
+const validation_1 = require("@croct/sdk/validation");
+const token_1 = require("@croct/sdk/token");
+const sdk_1 = require("@croct/sdk");
+const constants_1 = require("./constants");
+const playground_1 = require("./playground");
+const preview_1 = require("./preview");
+const PLUGIN_NAMESPACE = 'Plugin';
 function detectAppId() {
-    var script = window.document.querySelector("script[src^='".concat(constants_1.CDN_URL, "']"));
+    const script = window.document.querySelector(`script[src^='${constants_1.CDN_URL}']`);
     if (!(script instanceof HTMLScriptElement)) {
         return null;
     }
     return (new URL(script.src)).searchParams.get('appId');
 }
-var GlobalPlug = /** @class */ (function () {
-    function GlobalPlug() {
-        var _this = this;
-        this.pluginFactories = { playground: playground_1.factory };
+class GlobalPlug {
+    constructor() {
+        this.pluginFactories = {
+            playground: playground_1.factory,
+            preview: preview_1.factory,
+        };
         this.plugins = {};
-        this.ready = new Promise(function (resolve) {
-            _this.initialize = resolve;
+        this.ready = new Promise(resolve => {
+            this.initialize = resolve;
         });
     }
-    GlobalPlug.prototype.extend = function (name, plugin) {
+    extend(name, plugin) {
         if (this.pluginFactories[name] !== undefined) {
-            throw new Error("Another plugin is already registered with name \"".concat(name, "\"."));
+            throw new Error(`Another plugin is already registered with name "${name}".`);
         }
         this.pluginFactories[name] = plugin;
-    };
-    GlobalPlug.prototype.plug = function (configuration) {
-        var e_1, _a;
-        var _this = this;
-        var _b, _c, _d, _e;
-        if (configuration === void 0) { configuration = {}; }
+    }
+    plug(configuration = {}) {
+        var _a, _b, _c, _d;
         if (this.instance !== undefined) {
-            var logger_1 = this.instance.getLogger();
-            logger_1.info('Croct is already plugged in.');
+            const logger = this.instance.getLogger();
+            logger.info('Croct is already plugged in.');
             return;
         }
-        var detectedAppId = detectAppId();
-        var configuredAppId = (_b = configuration.appId) !== null && _b !== void 0 ? _b : null;
+        const detectedAppId = detectAppId();
+        const configuredAppId = (_a = configuration.appId) !== null && _a !== void 0 ? _a : null;
         if (detectedAppId !== null && configuredAppId !== null && detectedAppId !== configuredAppId) {
             throw new Error('The specified app ID and the auto-detected app ID are conflicting. '
                 + 'There is no need to specify an app ID when using an application-specific tag. '
                 + 'Please try again omitting the "appId" option.');
         }
-        var appId = detectedAppId !== null && detectedAppId !== void 0 ? detectedAppId : configuredAppId;
+        const appId = detectedAppId !== null && detectedAppId !== void 0 ? detectedAppId : configuredAppId;
         if (appId === null) {
             throw new Error('The app ID must be specified when it cannot be auto-detected. '
                 + 'Please try again specifying the "appId" option.');
         }
-        var plugins = configuration.plugins, test = configuration.test, sdkConfiguration = tslib_1.__rest(configuration, ["plugins", "test"]);
-        var sdk = sdkFacade_1.SdkFacade.init(tslib_1.__assign(tslib_1.__assign({}, sdkConfiguration), { appId: appId, test: test !== null && test !== void 0 ? test : (typeof process === 'object' && (((_c = process.env) === null || _c === void 0 ? void 0 : _c.CROCT_TEST_MODE) !== undefined
+        const { plugins, test, ...sdkConfiguration } = configuration;
+        const sdk = sdkFacade_1.SdkFacade.init({
+            ...sdkConfiguration,
+            appId: appId,
+            test: test !== null && test !== void 0 ? test : (typeof process === 'object' && (((_b = process.env) === null || _b === void 0 ? void 0 : _b.CROCT_TEST_MODE) !== undefined
                 ? process.env.CROCT_TEST_MODE === 'true'
-                : ((_d = process.env) === null || _d === void 0 ? void 0 : _d.NODE_ENV) === 'test')) }));
+                : ((_c = process.env) === null || _c === void 0 ? void 0 : _c.NODE_ENV) === 'test')),
+        });
         this.instance = sdk;
-        var logger = this.instance.getLogger();
+        const logger = this.instance.getLogger();
         if (detectedAppId === configuredAppId) {
             logger.warn('It is strongly recommended omitting the "appId" option when using '
                 + 'the application-specific tag as it is detected automatically.');
         }
-        var pending = [];
-        var _loop_1 = function (name_1, options) {
-            logger.debug("Initializing plugin \"".concat(name_1, "\"..."));
-            var factory = this_1.pluginFactories[name_1];
+        const pending = [];
+        const defaultEnabledPlugins = Object.fromEntries(Object.keys(this.pluginFactories)
+            .map(name => [name, true]));
+        for (const [name, options] of Object.entries({ ...defaultEnabledPlugins, ...plugins })) {
+            logger.debug(`Initializing plugin "${name}"...`);
+            const factory = this.pluginFactories[name];
             if (factory === undefined) {
-                logger.error("Plugin \"".concat(name_1, "\" is not registered."));
-                return "continue";
+                logger.error(`Plugin "${name}" is not registered.`);
+                continue;
             }
             if (typeof options !== 'boolean' && (options === null || typeof options !== 'object')) {
-                logger.error("Invalid options for plugin \"".concat(name_1, "\", ")
-                    + "expected either boolean or object but got ".concat((0, validation_1.describe)(options)));
-                return "continue";
+                logger.error(`Invalid options for plugin "${name}", `
+                    + `expected either boolean or object but got ${(0, validation_1.describe)(options)}`);
+                continue;
             }
             if (options === false) {
-                logger.warn("Plugin \"".concat(name_1, "\" is declared but not enabled"));
-                return "continue";
+                logger.warn(`Plugin "${name}" is declared but not enabled`);
+                continue;
             }
-            var args = {
+            const args = {
                 options: options === true ? {} : options,
                 sdk: {
                     version: sdk_1.VERSION,
@@ -91,266 +96,185 @@ var GlobalPlug = /** @class */ (function () {
                     user: sdk.user,
                     session: sdk.session,
                     tab: sdk.context.getTab(),
-                    tokenStore: {
+                    userTokenStore: {
                         getToken: sdk.getToken.bind(sdk),
                         setToken: sdk.setToken.bind(sdk),
                     },
+                    previewTokenStore: sdk.previewTokenStore,
                     cidAssigner: sdk.cidAssigner,
                     eventManager: sdk.eventManager,
-                    getLogger: function () {
-                        var namespace = [];
-                        for (var _i = 0; _i < arguments.length; _i++) {
-                            namespace[_i] = arguments[_i];
-                        }
-                        return sdk.getLogger.apply(sdk, tslib_1.__spreadArray([PLUGIN_NAMESPACE, name_1], tslib_1.__read(namespace), false));
-                    },
-                    getTabStorage: function () {
-                        var namespace = [];
-                        for (var _i = 0; _i < arguments.length; _i++) {
-                            namespace[_i] = arguments[_i];
-                        }
-                        return (sdk.getTabStorage.apply(sdk, tslib_1.__spreadArray([PLUGIN_NAMESPACE, name_1], tslib_1.__read(namespace), false)));
-                    },
-                    getBrowserStorage: function () {
-                        var namespace = [];
-                        for (var _i = 0; _i < arguments.length; _i++) {
-                            namespace[_i] = arguments[_i];
-                        }
-                        return (sdk.getBrowserStorage.apply(sdk, tslib_1.__spreadArray([PLUGIN_NAMESPACE, name_1], tslib_1.__read(namespace), false)));
-                    },
+                    getLogger: (...namespace) => sdk.getLogger(PLUGIN_NAMESPACE, name, ...namespace),
+                    getTabStorage: (...namespace) => (sdk.getTabStorage(PLUGIN_NAMESPACE, name, ...namespace)),
+                    getBrowserStorage: (...namespace) => (sdk.getBrowserStorage(PLUGIN_NAMESPACE, name, ...namespace)),
                 },
             };
-            var plugin = void 0;
+            let plugin;
             try {
                 plugin = factory(args);
             }
             catch (error) {
-                logger.error("Failed to initialize plugin \"".concat(name_1, "\": ").concat((0, error_1.formatCause)(error)));
-                return "continue";
+                logger.error(`Failed to initialize plugin "${name}": ${(0, error_1.formatCause)(error)}`);
+                continue;
             }
-            logger.debug("Plugin \"".concat(name_1, "\" initialized"));
+            logger.debug(`Plugin "${name}" initialized`);
             if (typeof plugin !== 'object') {
-                return "continue";
+                continue;
             }
-            this_1.plugins[name_1] = plugin;
-            var promise = plugin.enable();
+            this.plugins[name] = plugin;
+            const promise = plugin.enable();
             if (!(promise instanceof Promise)) {
-                logger.debug("Plugin \"".concat(name_1, "\" enabled"));
-                return "continue";
-            }
-            pending.push(promise.then(function () { return logger.debug("Plugin \"".concat(name_1, "\" enabled")); })
-                .catch(function (error) { return logger.error("Failed to enable plugin \"".concat(name_1, "\": ").concat((0, error_1.formatCause)(error))); }));
-        };
-        var this_1 = this;
-        try {
-            for (var _f = tslib_1.__values(Object.entries(tslib_1.__assign({ playground: true }, plugins))), _g = _f.next(); !_g.done; _g = _f.next()) {
-                var _h = tslib_1.__read(_g.value, 2), name_1 = _h[0], options = _h[1];
-                _loop_1(name_1, options);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+                logger.debug(`Plugin "${name}" enabled`);
+                continue;
             }
-            finally { if (e_1) throw e_1.error; }
+            pending.push(promise.then(() => logger.debug(`Plugin "${name}" enabled`))
+                .catch(error => logger.error(`Failed to enable plugin "${name}": ${(0, error_1.formatCause)(error)}`)));
         }
-        var initializeEap = (_e = window.croctEap) === null || _e === void 0 ? void 0 : _e.initialize;
+        const initializeEap = (_d = window.croctEap) === null || _d === void 0 ? void 0 : _d.initialize;
         if (typeof initializeEap === 'function') {
             initializeEap.call(this);
         }
-        Promise.all(pending).then(function () {
-            _this.initialize();
+        Promise.all(pending)
+            .then(() => {
+            this.initialize();
             logger.debug('Initialization complete');
         });
-    };
-    Object.defineProperty(GlobalPlug.prototype, "initialized", {
-        get: function () {
-            return this.instance !== undefined;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GlobalPlug.prototype, "plugged", {
-        get: function () {
-            var _this = this;
-            return this.ready.then(function () { return _this; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GlobalPlug.prototype, "flushed", {
-        get: function () {
-            var _this = this;
-            return this.tracker
-                .flushed
-                .then(function () { return _this; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GlobalPlug.prototype, "sdk", {
-        get: function () {
-            if (this.instance === undefined) {
-                throw new Error('Croct is not plugged in.');
-            }
-            return this.instance;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GlobalPlug.prototype, "tracker", {
-        get: function () {
-            return this.sdk.tracker;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GlobalPlug.prototype, "evaluator", {
-        get: function () {
-            return this.sdk.evaluator;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GlobalPlug.prototype, "user", {
-        get: function () {
-            return this.sdk.user;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GlobalPlug.prototype, "session", {
-        get: function () {
-            return this.sdk.session;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    GlobalPlug.prototype.isAnonymous = function () {
+    }
+    get initialized() {
+        return this.instance !== undefined;
+    }
+    get plugged() {
+        return this.ready.then(() => this);
+    }
+    get flushed() {
+        return this.tracker
+            .flushed
+            .then(() => this);
+    }
+    get sdk() {
+        if (this.instance === undefined) {
+            throw new Error('Croct is not plugged in.');
+        }
+        return this.instance;
+    }
+    get tracker() {
+        return this.sdk.tracker;
+    }
+    get evaluator() {
+        return this.sdk.evaluator;
+    }
+    get user() {
+        return this.sdk.user;
+    }
+    get session() {
+        return this.sdk.session;
+    }
+    isAnonymous() {
         return this.sdk
             .context
             .isAnonymous();
-    };
-    GlobalPlug.prototype.getUserId = function () {
+    }
+    getUserId() {
         return this.sdk
             .context
             .getUser();
-    };
-    GlobalPlug.prototype.identify = function (userId) {
+    }
+    identify(userId) {
         if (typeof userId !== 'string') {
             throw new Error('The user ID must be a string. Read more on https://croct.help/plug-js/id-conversion');
         }
         this.sdk.identify(userId);
-    };
-    GlobalPlug.prototype.anonymize = function () {
+    }
+    anonymize() {
         this.sdk.anonymize();
-    };
-    GlobalPlug.prototype.setToken = function (token) {
+    }
+    setToken(token) {
         this.sdk.setToken(token_1.Token.parse(token));
-    };
-    GlobalPlug.prototype.unsetToken = function () {
+    }
+    unsetToken() {
         this.sdk.unsetToken();
-    };
-    GlobalPlug.prototype.track = function (type, payload) {
+    }
+    track(type, payload) {
         return this.sdk
             .tracker
             .track(type, payload);
-    };
-    GlobalPlug.prototype.evaluate = function (expression, options) {
-        if (options === void 0) { options = {}; }
+    }
+    evaluate(expression, options = {}) {
         return this.sdk
             .evaluator
             .evaluate(expression, options);
-    };
-    GlobalPlug.prototype.test = function (expression, options) {
-        if (options === void 0) { options = {}; }
+    }
+    test(expression, options = {}) {
         return this.evaluate(expression, options)
-            .then(function (result) { return result === true; });
-    };
-    /**
-     * This API is unstable and subject to change in future releases.
-     */
-    GlobalPlug.prototype.fetch = function (slotId, options) {
-        if (options === void 0) { options = {}; }
-        return this.eap('fetch').call(this, slotId, options);
-    };
-    GlobalPlug.prototype.unplug = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, instance, plugins, logger, pending, _loop_2, _b, _c, _d, pluginName, controller;
-            var e_2, _e;
-            var _this = this;
-            return tslib_1.__generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        if (this.instance === undefined) {
-                            return [2 /*return*/];
-                        }
-                        _a = this, instance = _a.instance, plugins = _a.plugins;
-                        logger = this.sdk.getLogger();
-                        pending = [];
-                        _loop_2 = function (pluginName, controller) {
-                            if (typeof controller.disable !== 'function') {
-                                return "continue";
-                            }
-                            logger.debug("Disabling plugin \"".concat(pluginName, "\"..."));
-                            var promise = controller.disable();
-                            if (!(promise instanceof Promise)) {
-                                logger.debug("Plugin \"".concat(pluginName, "\" disabled"));
-                                return "continue";
-                            }
-                            pending.push(promise.then(function () { return logger.debug("Plugin \"".concat(pluginName, "\" disabled")); })
-                                .catch(function (error) { return logger.error("Failed to disable \"".concat(pluginName, "\": ").concat((0, error_1.formatCause)(error))); }));
-                        };
-                        try {
-                            for (_b = tslib_1.__values(Object.entries(plugins)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                                _d = tslib_1.__read(_c.value, 2), pluginName = _d[0], controller = _d[1];
-                                _loop_2(pluginName, controller);
-                            }
-                        }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                        finally {
-                            try {
-                                if (_c && !_c.done && (_e = _b.return)) _e.call(_b);
-                            }
-                            finally { if (e_2) throw e_2.error; }
-                        }
-                        // Reset
-                        delete this.instance;
-                        this.plugins = {};
-                        this.ready = new Promise(function (resolve) {
-                            _this.initialize = resolve;
-                        });
-                        return [4 /*yield*/, Promise.all(pending)];
-                    case 1:
-                        _f.sent();
-                        _f.label = 2;
-                    case 2:
-                        _f.trys.push([2, , 4, 5]);
-                        return [4 /*yield*/, instance.close()];
-                    case 3:
-                        _f.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        logger.info('🔌 Croct has been unplugged.');
-                        return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
-                }
-            });
+            .then(result => result === true);
+    }
+    get fetch() {
+        return this.eap('fetch', (slotId, options = {}) => {
+            const [id, version] = slotId.split('@');
+            const logger = this.sdk.getLogger();
+            return this.sdk
+                .contentFetcher
+                .fetch(id, {
+                ...options,
+                version: version === 'latest' ? undefined : version,
+            })
+                .then(response => ({
+                get payload() {
+                    logger.warn('Accessing the "payload" property of the fetch response is deprecated'
+                        + ' and will be removed in a future version. Use the "content" property instead.');
+                    return response.content;
+                },
+                content: response.content,
+            }));
+        });
+    }
+    async unplug() {
+        if (this.instance === undefined) {
+            return;
+        }
+        const { instance, plugins } = this;
+        const logger = this.sdk.getLogger();
+        const pending = [];
+        for (const [pluginName, controller] of Object.entries(plugins)) {
+            if (typeof controller.disable !== 'function') {
+                continue;
+            }
+            logger.debug(`Disabling plugin "${pluginName}"...`);
+            const promise = controller.disable();
+            if (!(promise instanceof Promise)) {
+                logger.debug(`Plugin "${pluginName}" disabled`);
+                continue;
+            }
+            pending.push(promise.then(() => logger.debug(`Plugin "${pluginName}" disabled`))
+                .catch(error => logger.error(`Failed to disable "${pluginName}": ${(0, error_1.formatCause)(error)}`)));
+        }
+        // Reset
+        delete this.instance;
+        this.plugins = {};
+        this.ready = new Promise(resolve => {
+            this.initialize = resolve;
         });
-    };
-    GlobalPlug.prototype.eap = function (feature) {
-        var logger = this.sdk.getLogger();
-        var eap = window.croctEap;
-        var method = typeof eap === 'object' ? eap[feature] : undefined;
+        await Promise.all(pending);
+        try {
+            await instance.close();
+        }
+        finally {
+            logger.info('🔌 Croct has been unplugged.');
+        }
+    }
+    eap(feature, api) {
+        const eap = window.croctEap;
+        const method = typeof eap === 'object' ? eap[feature] : undefined;
         if (typeof method !== 'function') {
-            throw new Error("The ".concat(feature, " feature is currently available only to accounts participating in our ")
-                + 'Early-Access Program (EAP). Please contact your Customer Success Manager or email eap@croct.com '
-                + 'to check your account eligibility.');
+            return api;
         }
-        logger.warn("The ".concat(feature, " API is still unstable and subject to change in future releases."));
-        return method;
-    };
-    return GlobalPlug;
-}());
+        return method.bind(new Proxy(this, {
+            get: (plug, property) => {
+                if (property === feature) {
+                    return api;
+                }
+                return plug[property];
+            },
+        }));
+    }
+}
 exports.GlobalPlug = GlobalPlug;

package/plugin.d.ts

@@ -10,7 +10,8 @@ export interface PluginSdk {
     readonly user: UserFacade;
     readonly session: SessionFacade;
     readonly tab: Tab;
-    readonly tokenStore: TokenStore;
+    readonly userTokenStore: TokenStore;
+    readonly previewTokenStore: TokenStore;
     readonly cidAssigner: CidAssigner;
     readonly eventManager: SdkEventManager;
     getLogger(...namespace: string[]): Logger;

package/preview.d.ts

@@ -0,0 +1,22 @@
+import { Logger } from './sdk';
+import { Plugin, PluginFactory } from './plugin';
+import { TokenStore } from './sdk/token';
+export type Configuration = {
+    tokenStore: TokenStore;
+    logger: Logger;
+};
+export declare class PreviewPlugin implements Plugin {
+    private static readonly PREVIEW_PARAMS;
+    private readonly tokenStore;
+    private readonly logger;
+    private readonly widgetId;
+    constructor(configuration: Configuration);
+    enable(): void;
+    disable(): void;
+    private updateToken;
+    private getWidgetUrl;
+    private getWidgetParams;
+    private insertWidget;
+    private createWidget;
+}
+export declare const factory: PluginFactory;

package/preview.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factory = exports.PreviewPlugin = void 0;
+const error_1 = require("@croct/sdk/error");
+const uuid_1 = require("@croct/sdk/uuid");
+const token_1 = require("./sdk/token");
+const constants_1 = require("./constants");
+const PREVIEW_PARAMETER = 'croct-preview';
+const PREVIEW_EXIT = 'exit';
+class PreviewPlugin {
+    constructor(configuration) {
+        this.widgetId = `croct-preview:${(0, uuid_1.uuid4)()}`;
+        this.tokenStore = configuration.tokenStore;
+        this.logger = configuration.logger;
+    }
+    enable() {
+        const url = new URL(window.location.href);
+        const previewData = url.searchParams.get(PREVIEW_PARAMETER);
+        if (previewData !== null) {
+            this.updateToken(previewData);
+            // Remove the token from the URL
+            url.searchParams.delete(PREVIEW_PARAMETER);
+            window.history.replaceState({}, '', url.toString());
+        }
+        const token = this.tokenStore.getToken();
+        if (token !== null) {
+            this.insertWidget(this.getWidgetUrl(token));
+        }
+    }
+    disable() {
+        var _a;
+        (_a = document.getElementById(this.widgetId)) === null || _a === void 0 ? void 0 : _a.remove();
+    }
+    updateToken(data) {
+        if (data === PREVIEW_EXIT) {
+            this.logger.debug('Exiting preview mode.');
+            this.tokenStore.setToken(null);
+            return;
+        }
+        try {
+            let token = token_1.Token.parse(data);
+            const { exp } = token.getPayload();
+            if (exp !== undefined && exp <= Date.now() / 1000) {
+                this.logger.debug('Preview token expired.');
+                token = null;
+            }
+            this.tokenStore.setToken(token);
+        }
+        catch (error) {
+            this.tokenStore.setToken(null);
+            this.logger.warn(`Invalid preview token: ${(0, error_1.formatCause)(error)}`);
+        }
+    }
+    getWidgetUrl(token) {
+        const params = this.getWidgetParams(token);
+        let queryString = params.toString();
+        if (queryString !== '') {
+            queryString = `?${queryString}`;
+        }
+        return `${constants_1.PREVIEW_WIDGET_URL}${queryString}`;
+    }
+    getWidgetParams(token) {
+        const { metadata = {} } = token.getPayload();
+        const params = new URLSearchParams();
+        if (metadata === null || typeof metadata !== 'object' || Array.isArray(metadata)) {
+            return params;
+        }
+        for (const [key, param] of Object.entries(PreviewPlugin.PREVIEW_PARAMS)) {
+            const value = metadata[key];
+            if (typeof value === 'string') {
+                params.set(param, value);
+            }
+        }
+        return params;
+    }
+    insertWidget(url) {
+        const widget = this.createWidget(url);
+        window.addEventListener('message', event => {
+            if (event.origin !== constants_1.PREVIEW_WIDGET_ORIGIN) {
+                return;
+            }
+            switch (event.data.type) {
+                case 'croct:preview:leave': {
+                    this.tokenStore.setToken(null);
+                    const exitUrl = new URL(window.location.href);
+                    exitUrl.searchParams.set(PREVIEW_PARAMETER, PREVIEW_EXIT);
+                    window.location.replace(exitUrl.toString());
+                    break;
+                }
+                case 'croct:preview:resize':
+                    widget.style.width = `${event.data.width}px`;
+                    widget.style.height = `${event.data.height}px`;
+                    break;
+            }
+        });
+        document.body.prepend(widget);
+    }
+    createWidget(url) {
+        const widget = document.createElement('iframe');
+        widget.setAttribute('id', this.widgetId);
+        widget.setAttribute('src', url);
+        widget.setAttribute('sandbox', 'allow-scripts allow-same-origin');
+        widget.style.position = 'fixed';
+        widget.style.width = '0px';
+        widget.style.height = '0px';
+        widget.style.right = '0';
+        widget.style.bottom = '0';
+        widget.style.border = '0';
+        widget.style.overflow = 'hidden';
+        widget.style.zIndex = '2147483647';
+        return widget;
+    }
+}
+exports.PreviewPlugin = PreviewPlugin;
+PreviewPlugin.PREVIEW_PARAMS = {
+    experienceName: 'experience',
+    experimentName: 'experiment',
+    audienceName: 'audience',
+    variantName: 'variant',
+};
+const factory = (props) => {
+    const { sdk } = props;
+    return new PreviewPlugin({
+        tokenStore: props.sdk.previewTokenStore,
+        logger: sdk.getLogger(),
+    });
+};
+exports.factory = factory;

package/sdk/evaluation.d.ts

@@ -1,2 +1,2 @@
 export { EvaluatorFacade, EvaluationOptions } from '@croct/sdk/facade/evaluatorFacade';
-export { EvaluationError, EvaluationErrorType, ExpressionError } from '@croct/sdk/evaluator';
+export { EvaluationError, EvaluationErrorType, QueryError } from '@croct/sdk/evaluator';

package/sdk/evaluation.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpressionError = exports.EvaluationErrorType = exports.EvaluationError = exports.EvaluatorFacade = void 0;
+exports.QueryError = exports.EvaluationErrorType = exports.EvaluationError = exports.EvaluatorFacade = void 0;
 var evaluatorFacade_1 = require("@croct/sdk/facade/evaluatorFacade");
 Object.defineProperty(exports, "EvaluatorFacade", { enumerable: true, get: function () { return evaluatorFacade_1.EvaluatorFacade; } });
 var evaluator_1 = require("@croct/sdk/evaluator");
 Object.defineProperty(exports, "EvaluationError", { enumerable: true, get: function () { return evaluator_1.EvaluationError; } });
 Object.defineProperty(exports, "EvaluationErrorType", { enumerable: true, get: function () { return evaluator_1.EvaluationErrorType; } });
-Object.defineProperty(exports, "ExpressionError", { enumerable: true, get: function () { return evaluator_1.ExpressionError; } });
+Object.defineProperty(exports, "QueryError", { enumerable: true, get: function () { return evaluator_1.QueryError; } });

package/sdk/index.d.ts

@@ -6,7 +6,7 @@ export { UserFacade } from '@croct/sdk/facade/userFacade';
 export { Tab } from '@croct/sdk/tab';
 export { CidAssigner } from '@croct/sdk/cid';
 export { SdkEventType, SdkEvent } from '@croct/sdk/sdkEvents';
-export declare type SdkEventListener<T extends SdkEventType> = EventListener<SdkEventMap[T]>;
-export declare type SdkEventDispatcher = EventDispatcher<Record<string, Record<string, any>>>;
-export declare type SdkEventSubscriber = EventSubscriber<SdkEventMap>;
-export declare type SdkEventManager = EventManager<SdkEventMap, Record<string, Record<string, any>>>;
+export type SdkEventListener<T extends SdkEventType> = EventListener<SdkEventMap[T]>;
+export type SdkEventDispatcher = EventDispatcher<Record<string, Record<string, any>>>;
+export type SdkEventSubscriber = EventSubscriber<SdkEventMap>;
+export type SdkEventManager = EventManager<SdkEventMap, Record<string, Record<string, any>>>;

package/sdk/json.d.ts

@@ -1,3 +1,3 @@
 import { JsonObject } from '@croct/json';
 export * from '@croct/json/mutable';
-export declare type NullableJsonObject = JsonObject | null;
+export type NullableJsonObject = JsonObject | null;

package/sdk/json.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
+const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("@croct/json/mutable"), exports);

package/sdk/token.d.ts

@@ -1 +1 @@
-export { Token, Claims, Headers, TokenProvider, TokenStore } from '@croct/sdk/token';
+export { Token, TokenPayload, Headers, TokenProvider, TokenStore } from '@croct/sdk/token';

package/sdk/tracking.d.ts

@@ -3,4 +3,4 @@ import { TrackingEvent, TrackingEventType } from '@croct/sdk/trackingEvents';
 export { TrackerFacade } from '@croct/sdk/facade/trackerFacade';
 export { EventListener } from '@croct/sdk/tracker';
 export { TrackingEvent, TrackingEventType, ExternalTrackingEvent, ExternalTrackingEventPayload, ExternalTrackingEventType, } from '@croct/sdk/trackingEvents';
-export declare type EventInfo<T extends TrackingEventType> = SdkEventInfo<TrackingEvent<T>>;
+export type EventInfo<T extends TrackingEventType> = SdkEventInfo<TrackingEvent<T>>;

package/sdk/validation.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
+const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("@croct/sdk/validation"), exports);
 tslib_1.__exportStar(require("@croct/sdk/error"), exports);

package/slot.d.ts

@@ -0,0 +1,21 @@
+import { JsonObject } from '@croct/json';
+export interface SlotMap {
+}
+type LatestSlotVersionMap = {
+    [K in keyof SlotMap]: {
+        latest: SlotMap[K];
+    };
+};
+export interface VersionedSlotMap extends LatestSlotVersionMap {
+}
+type LatestAlias = 'latest';
+export type SlotId = keyof VersionedSlotMap extends never ? string : keyof VersionedSlotMap;
+export type SlotVersion<I extends SlotId = SlotId> = LatestAlias | (I extends keyof VersionedSlotMap ? keyof VersionedSlotMap[I] : never);
+export type VersionedSlotId<I extends SlotId = SlotId> = I | {
+    [K in SlotId]: `${K}@${SlotVersion<K> & string}`;
+}[I];
+type VersionedSlotContent<I extends SlotId, V extends string = LatestAlias, C extends JsonObject = JsonObject> = I extends keyof VersionedSlotMap ? (V extends keyof VersionedSlotMap[I] ? VersionedSlotMap[I][V] : C) : C;
+export type ExtractSlotVersion<I extends string> = I extends `${string}@${infer V}` ? (LatestAlias extends V ? LatestAlias : (V extends `${number}` ? V : never)) : LatestAlias;
+export type ExtractSlotId<I extends string> = I extends `${infer V}@${string}` ? V : I;
+export type SlotContent<I extends VersionedSlotId, C extends JsonObject = JsonObject> = VersionedSlotContent<ExtractSlotId<I>, ExtractSlotVersion<I>, C>;
+export {};

package/fetch.d.ts

@@ -1,12 +0,0 @@
-import { NullableJsonObject, JsonObject } from './sdk/json';
-export interface SlotMap {
-}
-export declare type FetchOptions = {
-    timeout?: number;
-    attributes?: JsonObject;
-};
-export declare type SlotId = keyof SlotMap extends never ? string : keyof SlotMap;
-export declare type SlotContent<I extends SlotId> = I extends keyof SlotMap ? SlotMap[I] : NullableJsonObject;
-export declare type FetchResponse<I extends SlotId, P extends NullableJsonObject = NullableJsonObject> = {
-    payload: SlotContent<I> & P;
-};