@croct/sdk 0.10.0 → 0.11.0-alpha

package/context.js

@@ -1,70 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
-var token_1 = require("./token");
-var tab_1 = require("./tab");
-var uuid_1 = require("./uuid");
+const token_1 = require("./token");
+const tab_1 = require("./tab");
+const uuid_1 = require("./uuid");
 function tokenEquals(left, right) {
     return left === right || (left !== null && right !== null && left.toString() === right.toString());
 }
-var Context = /** @class */ (function () {
-    function Context(tab, tokenStore, eventDispatcher) {
+class Context {
+    constructor(tab, tokenStore, eventDispatcher) {
         this.tab = tab;
         this.tokenStore = tokenStore;
         this.eventDispatcher = eventDispatcher;
         this.lastToken = tokenStore.getToken();
         this.syncToken = this.syncToken.bind(this);
     }
-    Context.load = function (_a) {
-        var cache = _a.cache, tokenScope = _a.tokenScope, eventDispatcher = _a.eventDispatcher, urlSanitizer = _a.urlSanitizer;
-        var tabId = cache.tabId.get();
-        var newTab = false;
+    static load({ cache, tokenScope, eventDispatcher, urlSanitizer }) {
+        let tabId = cache.tabId.get();
+        let newTab = false;
         if (tabId === null) {
             tabId = (0, uuid_1.uuid4)(true);
             newTab = true;
         }
-        var tab = new tab_1.Tab(tabId, newTab, urlSanitizer);
+        const tab = new tab_1.Tab(tabId, newTab, urlSanitizer);
         cache.tabId.clear();
-        tab.addListener('unload', function () { return cache.tabId.put(tab.id); });
+        tab.addListener('unload', () => cache.tabId.put(tab.id));
         switch (tokenScope) {
             case 'isolated':
                 return new Context(tab, new token_1.InMemoryTokenStore(), eventDispatcher);
             case 'global': {
-                var context = new Context(tab, new token_1.CachedTokenStore(cache.browserToken), eventDispatcher);
+                const context = new Context(tab, new token_1.CachedTokenStore(cache.browserToken), eventDispatcher);
                 cache.browserToken.addListener(context.syncToken);
                 return context;
             }
             case 'contextual': {
-                var primaryStorage_1 = new token_1.CachedTokenStore(cache.tabToken);
-                var secondaryStorage_1 = new token_1.CachedTokenStore(cache.browserToken);
+                const primaryStorage = new token_1.CachedTokenStore(cache.tabToken);
+                const secondaryStorage = new token_1.CachedTokenStore(cache.browserToken);
                 if (tab.isNew) {
-                    primaryStorage_1.setToken(secondaryStorage_1.getToken());
+                    primaryStorage.setToken(secondaryStorage.getToken());
                 }
-                tab.addListener('visibilityChange', function (event) {
+                tab.addListener('visibilityChange', event => {
                     if (event.detail.visible) {
-                        secondaryStorage_1.setToken(primaryStorage_1.getToken());
+                        secondaryStorage.setToken(primaryStorage.getToken());
                     }
                 });
-                return new Context(tab, new token_1.ReplicatedTokenStore(primaryStorage_1, secondaryStorage_1), eventDispatcher);
+                return new Context(tab, new token_1.ReplicatedTokenStore(primaryStorage, secondaryStorage), eventDispatcher);
             }
         }
-    };
-    Context.prototype.getTab = function () {
+    }
+    getTab() {
         return this.tab;
-    };
-    Context.prototype.isAnonymous = function () {
-        var token = this.getToken();
+    }
+    isAnonymous() {
+        const token = this.getToken();
         return token == null || token.isAnonymous();
-    };
-    Context.prototype.getUser = function () {
-        var token = this.getToken();
+    }
+    getUser() {
+        const token = this.getToken();
         return token == null ? null : token.getSubject();
-    };
-    Context.prototype.getToken = function () {
+    }
+    getToken() {
         return this.tokenStore.getToken();
-    };
-    Context.prototype.setToken = function (token) {
-        var oldToken = this.lastToken;
+    }
+    setToken(token) {
+        const oldToken = this.lastToken;
         this.lastToken = token;
         this.tokenStore.setToken(token);
         if (!tokenEquals(oldToken, token)) {
@@ -73,10 +72,10 @@ var Context = /** @class */ (function () {
                 newToken: token,
             });
         }
-    };
-    Context.prototype.syncToken = function () {
-        var newToken = this.tokenStore.getToken();
-        var oldToken = this.lastToken;
+    }
+    syncToken() {
+        const newToken = this.tokenStore.getToken();
+        const oldToken = this.lastToken;
         if (!tokenEquals(oldToken, newToken)) {
             this.lastToken = newToken;
             this.eventDispatcher.dispatch('tokenChanged', {
@@ -84,7 +83,6 @@ var Context = /** @class */ (function () {
                 newToken: newToken,
             });
         }
-    };
-    return Context;
-}());
+    }
+}
 exports.Context = Context;

package/error.js

@@ -11,7 +11,7 @@ function extractMessage(error) {
     return 'unknown error';
 }
 function formatMessage(error) {
-    var message = extractMessage(error);
+    const message = extractMessage(error);
     if (message.length === 0) {
         return message;
     }
@@ -19,7 +19,7 @@ function formatMessage(error) {
 }
 exports.formatMessage = formatMessage;
 function formatCause(error) {
-    var message = formatMessage(error);
+    const message = formatMessage(error);
     if (message.length === 0) {
         return message;
     }

package/evaluator.d.ts

@@ -1,45 +1,47 @@
 import { JsonObject, JsonValue } from '@croct/json';
-import { TokenProvider } from './token';
+import { Token } from './token';
 import { Location } from './sourceLocation';
-import { CidAssigner } from './cid';
-export declare type Configuration = {
-    appId: string;
-    endpointUrl?: string;
-    tokenProvider: TokenProvider;
-    cidAssigner: CidAssigner;
-};
-export declare type Campaign = {
+export type Campaign = {
     name?: string;
     source?: string;
     medium?: string;
     term?: string;
     content?: string;
 };
-export declare type Page = {
-    title: string;
+export type Page = {
     url: string;
+    title?: string;
     referrer?: string;
 };
-export declare type EvaluationContext = {
-    timezone?: string;
+export type EvaluationContext = {
+    timeZone?: string;
     campaign?: Campaign;
     page?: Page;
     attributes?: JsonObject;
 };
-export declare type EvaluationOptions = {
+type AllowedFetchOptions = Exclude<keyof RequestInit, 'method' | 'body' | 'headers' | 'signal'>;
+type ExtraFetchOptions<T extends keyof RequestInit = AllowedFetchOptions> = Pick<RequestInit, T> & {
+    [key in Exclude<keyof RequestInit, T>]?: never;
+} & Record<string, any>;
+export type EvaluationOptions = {
+    clientId?: string;
+    clientIp?: string;
+    userAgent?: string;
+    userToken?: Token | string;
     timeout?: number;
     context?: EvaluationContext;
+    extra?: ExtraFetchOptions;
 };
 export declare enum EvaluationErrorType {
     TIMEOUT = "https://croct.help/api/evaluation#timeout",
     UNEXPECTED_ERROR = "https://croct.help/api/evaluation#unexpected-error",
-    INVALID_EXPRESSION = "https://croct.help/api/evaluation#invalid-expression",
-    TOO_COMPLEX_EXPRESSION = "https://croct.help/api/evaluation#too-complex-expression",
+    INVALID_QUERY = "https://croct.help/api/evaluation#invalid-query",
+    TOO_COMPLEX_QUERY = "https://croct.help/api/evaluation#too-complex-query",
     EVALUATION_FAILED = "https://croct.help/api/evaluation#evaluation-failed",
     UNALLOWED_RESULT = "https://croct.help/api/evaluation#unallowed-result",
     UNSERIALIZABLE_RESULT = "https://croct.help/api/evaluation#unserializable-result"
 }
-export declare type ErrorResponse = {
+export type ErrorResponse = {
     type: EvaluationErrorType;
     title: string;
     status: number;
@@ -49,21 +51,28 @@ export declare class EvaluationError<T extends ErrorResponse = ErrorResponse> ex
     readonly response: T;
     constructor(response: T);
 }
-declare type ExpressionErrorDetail = {
+type QueryErrorDetail = {
     cause: string;
     location: Location;
 };
-export declare type ExpressionErrorResponse = ErrorResponse & {
-    errors: ExpressionErrorDetail[];
+export type QueryErrorResponse = ErrorResponse & {
+    errors: QueryErrorDetail[];
 };
-export declare class ExpressionError extends EvaluationError<ExpressionErrorResponse> {
-    constructor(response: ExpressionErrorResponse);
+export declare class QueryError extends EvaluationError<QueryErrorResponse> {
+    constructor(response: QueryErrorResponse);
 }
+export type Configuration = {
+    appId?: string;
+    apiKey?: string;
+    endpointUrl?: string;
+};
 export declare class Evaluator {
-    static readonly MAX_EXPRESSION_LENGTH: number;
+    static readonly MAX_QUERY_LENGTH: number;
     private readonly configuration;
+    private readonly endpoint;
     constructor(configuration: Configuration);
-    evaluate(expression: string, options?: EvaluationOptions): Promise<JsonValue>;
+    evaluate(query: string, options?: EvaluationOptions): Promise<JsonValue>;
     private fetch;
+    toJSON(): never;
 }
 export {};

package/evaluator.js

@@ -1,138 +1,147 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Evaluator = exports.ExpressionError = exports.EvaluationError = exports.EvaluationErrorType = void 0;
-var tslib_1 = require("tslib");
-var constants_1 = require("./constants");
-var error_1 = require("./error");
-var sourceLocation_1 = require("./sourceLocation");
+exports.Evaluator = exports.QueryError = exports.EvaluationError = exports.EvaluationErrorType = void 0;
+const constants_1 = require("./constants");
+const error_1 = require("./error");
+const sourceLocation_1 = require("./sourceLocation");
 var EvaluationErrorType;
 (function (EvaluationErrorType) {
     EvaluationErrorType["TIMEOUT"] = "https://croct.help/api/evaluation#timeout";
     EvaluationErrorType["UNEXPECTED_ERROR"] = "https://croct.help/api/evaluation#unexpected-error";
-    EvaluationErrorType["INVALID_EXPRESSION"] = "https://croct.help/api/evaluation#invalid-expression";
-    EvaluationErrorType["TOO_COMPLEX_EXPRESSION"] = "https://croct.help/api/evaluation#too-complex-expression";
+    EvaluationErrorType["INVALID_QUERY"] = "https://croct.help/api/evaluation#invalid-query";
+    EvaluationErrorType["TOO_COMPLEX_QUERY"] = "https://croct.help/api/evaluation#too-complex-query";
     EvaluationErrorType["EVALUATION_FAILED"] = "https://croct.help/api/evaluation#evaluation-failed";
     EvaluationErrorType["UNALLOWED_RESULT"] = "https://croct.help/api/evaluation#unallowed-result";
     EvaluationErrorType["UNSERIALIZABLE_RESULT"] = "https://croct.help/api/evaluation#unserializable-result";
 })(EvaluationErrorType = exports.EvaluationErrorType || (exports.EvaluationErrorType = {}));
-var EvaluationError = /** @class */ (function (_super) {
-    tslib_1.__extends(EvaluationError, _super);
-    function EvaluationError(response) {
-        var _this = _super.call(this, response.title) || this;
-        _this.response = response;
-        Object.setPrototypeOf(_this, EvaluationError.prototype);
-        return _this;
+class EvaluationError extends Error {
+    constructor(response) {
+        super(response.title);
+        this.response = response;
+        Object.setPrototypeOf(this, EvaluationError.prototype);
     }
-    return EvaluationError;
-}(Error));
+}
 exports.EvaluationError = EvaluationError;
-var ExpressionError = /** @class */ (function (_super) {
-    tslib_1.__extends(ExpressionError, _super);
-    function ExpressionError(response) {
-        var _this = _super.call(this, response) || this;
-        Object.setPrototypeOf(_this, ExpressionError.prototype);
-        return _this;
+class QueryError extends EvaluationError {
+    constructor(response) {
+        super(response);
+        Object.setPrototypeOf(this, QueryError.prototype);
     }
-    return ExpressionError;
-}(EvaluationError));
-exports.ExpressionError = ExpressionError;
-var Evaluator = /** @class */ (function () {
-    function Evaluator(configuration) {
-        var _a;
-        this.configuration = tslib_1.__assign(tslib_1.__assign({}, configuration), { endpointUrl: (_a = configuration.endpointUrl) !== null && _a !== void 0 ? _a : constants_1.EVALUATION_ENDPOINT_URL });
+}
+exports.QueryError = QueryError;
+class Evaluator {
+    constructor(configuration) {
+        if ((configuration.appId === undefined) === (configuration.apiKey === undefined)) {
+            throw new Error('Either the application ID or the API key must be provided.');
+        }
+        const { endpointUrl, apiKey } = configuration;
+        // eslint-disable-next-line prefer-template -- Better readability
+        this.endpoint = (endpointUrl !== null && endpointUrl !== void 0 ? endpointUrl : constants_1.EVALUATION_ENDPOINT_URL).replace(/\/+$/, '')
+            + (apiKey === undefined ? '/client' : '/external')
+            + '/web/evaluate';
+        this.configuration = configuration;
     }
-    Evaluator.prototype.evaluate = function (expression, options) {
-        if (options === void 0) { options = {}; }
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var length, response, endpoint;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                length = (0, sourceLocation_1.getLength)(expression);
-                if (length > Evaluator.MAX_EXPRESSION_LENGTH) {
-                    response = {
-                        title: 'The expression is too complex.',
-                        status: 422,
-                        type: EvaluationErrorType.TOO_COMPLEX_EXPRESSION,
-                        detail: "The expression must be at most ".concat(Evaluator.MAX_EXPRESSION_LENGTH, " characters long, ")
-                            + "but it is ".concat(length, " characters long."),
-                        errors: [{
-                                cause: 'The expression is longer than expected.',
-                                location: (0, sourceLocation_1.getLocation)(expression, 0, Math.max(length - 1, 0)),
-                            }],
+    evaluate(query, options = {}) {
+        const length = (0, sourceLocation_1.getLength)(query);
+        if (length > Evaluator.MAX_QUERY_LENGTH) {
+            const response = {
+                title: 'The query is too complex.',
+                status: 422,
+                type: EvaluationErrorType.TOO_COMPLEX_QUERY,
+                detail: `The query must be at most ${Evaluator.MAX_QUERY_LENGTH} characters long, `
+                    + `but it is ${length} characters long.`,
+                errors: [{
+                        cause: 'The query is longer than expected.',
+                        location: (0, sourceLocation_1.getLocation)(query, 0, Math.max(length - 1, 0)),
+                    }],
+            };
+            return Promise.reject(new QueryError(response));
+        }
+        const body = {
+            query: query,
+        };
+        if (options.context !== undefined) {
+            body.context = options.context;
+        }
+        return new Promise((resolve, reject) => {
+            const abortController = new AbortController();
+            if (options.timeout !== undefined) {
+                setTimeout(() => {
+                    const response = {
+                        title: 'Maximum evaluation timeout reached before evaluation could complete.',
+                        type: EvaluationErrorType.TIMEOUT,
+                        detail: `The evaluation took more than ${options.timeout}ms to complete.`,
+                        status: 408, // Request Timeout
                     };
-                    return [2 /*return*/, Promise.reject(new ExpressionError(response))];
+                    abortController.abort();
+                    reject(new EvaluationError(response));
+                }, options.timeout);
+            }
+            const promise = this.fetch(body, abortController.signal, options);
+            promise.then(response => response.json()
+                .then(data => {
+                if (response.ok) {
+                    return resolve(data);
                 }
-                endpoint = new URL(this.configuration.endpointUrl);
-                endpoint.searchParams.append('expression', expression);
-                if (options.context !== undefined) {
-                    endpoint.searchParams.append('context', JSON.stringify(options.context));
+                const errorResponse = data;
+                switch (errorResponse.type) {
+                    case EvaluationErrorType.INVALID_QUERY:
+                    case EvaluationErrorType.EVALUATION_FAILED:
+                    case EvaluationErrorType.TOO_COMPLEX_QUERY:
+                        reject(new QueryError(errorResponse));
+                        break;
+                    default:
+                        reject(new EvaluationError(errorResponse));
+                        break;
                 }
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        if (options.timeout !== undefined) {
-                            window.setTimeout(function () {
-                                var response = {
-                                    title: 'Maximum evaluation timeout reached before evaluation could complete.',
-                                    type: EvaluationErrorType.TIMEOUT,
-                                    detail: "The evaluation took more than ".concat(options.timeout, "ms to complete."),
-                                    status: 408, // Request Timeout
-                                };
-                                reject(new EvaluationError(response));
-                            }, options.timeout);
-                        }
-                        var promise = _this.fetch(endpoint.toString());
-                        promise.then(function (response) {
-                            if (response.ok) {
-                                response.json().then(resolve);
-                                return;
-                            }
-                            response.json().then(function (result) {
-                                var errorResponse = result;
-                                switch (errorResponse.type) {
-                                    case EvaluationErrorType.INVALID_EXPRESSION:
-                                    case EvaluationErrorType.EVALUATION_FAILED:
-                                    case EvaluationErrorType.TOO_COMPLEX_EXPRESSION:
-                                        reject(new ExpressionError(errorResponse));
-                                        break;
-                                    default:
-                                        reject(new EvaluationError(errorResponse));
-                                        break;
-                                }
-                            });
-                        }, function (error) {
-                            var errorResponse = {
-                                title: (0, error_1.formatMessage)(error),
-                                type: EvaluationErrorType.UNEXPECTED_ERROR,
-                                detail: 'Please try again or contact Croct support if the error persists.',
-                                status: 500, // Internal Server Error
-                            };
-                            reject(new EvaluationError(errorResponse));
-                        });
-                    })];
-            });
-        });
-    };
-    Evaluator.prototype.fetch = function (endpoint) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, tokenProvider, cidAssigner, appId, token, cid, headers;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this.configuration, tokenProvider = _a.tokenProvider, cidAssigner = _a.cidAssigner, appId = _a.appId;
-                        token = tokenProvider.getToken();
-                        return [4 /*yield*/, cidAssigner.assignCid()];
-                    case 1:
-                        cid = _b.sent();
-                        headers = tslib_1.__assign({ 'X-App-Id': appId, 'X-Client-Id': cid }, (token !== null && { 'X-Token': token.toString() }));
-                        return [2 /*return*/, window.fetch(endpoint.toString(), {
-                                method: 'GET',
-                                headers: headers,
-                                credentials: 'include',
-                            })];
+            }))
+                .catch(error => {
+                if (!abortController.signal.aborted) {
+                    reject(new EvaluationError({
+                        title: (0, error_1.formatMessage)(error),
+                        type: EvaluationErrorType.UNEXPECTED_ERROR,
+                        detail: 'Please try again or contact Croct support if the error persists.',
+                        status: 500, // Internal Server Error
+                    }));
                 }
             });
         });
-    };
-    Evaluator.MAX_EXPRESSION_LENGTH = constants_1.MAX_EXPRESSION_LENGTH;
-    return Evaluator;
-}());
+    }
+    fetch(body, signal, options) {
+        const { appId, apiKey } = this.configuration;
+        const { clientId, clientIp, userAgent, userToken } = options;
+        const headers = new Headers();
+        if (apiKey !== undefined) {
+            headers.set('X-Api-Key', apiKey);
+        }
+        else if (appId !== undefined) {
+            headers.set('X-App-Id', appId);
+        }
+        if (clientId !== undefined) {
+            headers.set('X-Client-Id', clientId);
+        }
+        if (clientIp !== undefined) {
+            headers.set('X-Client-Ip', clientIp);
+        }
+        if (userToken !== undefined) {
+            headers.set('X-Token', userToken.toString());
+        }
+        if (userAgent !== undefined) {
+            headers.set('User-Agent', userAgent);
+        }
+        return fetch(this.endpoint, {
+            credentials: 'omit',
+            ...options.extra,
+            method: 'POST',
+            headers: headers,
+            signal: signal,
+            body: JSON.stringify(body),
+        });
+    }
+    toJSON() {
+        // Prevent sensitive configuration from being serialized
+        throw new Error('Unserializable value.');
+    }
+}
 exports.Evaluator = Evaluator;
+Evaluator.MAX_QUERY_LENGTH = constants_1.MAX_QUERY_LENGTH;

package/eventManager.d.ts

@@ -1,7 +1,7 @@
 export interface EventListener<T> {
     (event: T): void;
 }
-export declare type EventMap = Record<string, Record<string, any>>;
+export type EventMap = Record<string, Record<string, any>>;
 export interface EventDispatcher<TEvents extends EventMap> {
     dispatch<T extends keyof TEvents>(eventName: T, event: TEvents[T]): void;
 }

package/eventManager.js

@@ -1,32 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SynchronousEventManager = void 0;
-var SynchronousEventManager = /** @class */ (function () {
-    function SynchronousEventManager() {
+class SynchronousEventManager {
+    constructor() {
         this.listeners = {};
     }
-    SynchronousEventManager.prototype.addListener = function (type, listener) {
+    addListener(type, listener) {
         var _a;
-        var listeners = (_a = this.listeners[type]) !== null && _a !== void 0 ? _a : [];
+        const listeners = (_a = this.listeners[type]) !== null && _a !== void 0 ? _a : [];
         listeners.push(listener);
         this.listeners[type] = listeners;
-    };
-    SynchronousEventManager.prototype.removeListener = function (eventName, listener) {
-        var listeners = this.listeners[eventName];
+    }
+    removeListener(eventName, listener) {
+        const listeners = this.listeners[eventName];
         if (listeners === undefined) {
             return;
         }
-        var index = listeners.indexOf(listener);
+        const index = listeners.indexOf(listener);
         if (index >= 0) {
             listeners.splice(index, 1);
         }
-    };
-    SynchronousEventManager.prototype.dispatch = function (eventName, event) {
-        var listeners = this.listeners[eventName];
+    }
+    dispatch(eventName, event) {
+        const listeners = this.listeners[eventName];
         if (listeners !== undefined) {
-            listeners.forEach(function (listener) { return listener(event); });
+            listeners.forEach(listener => listener(event));
         }
-    };
-    return SynchronousEventManager;
-}());
+    }
+}
 exports.SynchronousEventManager = SynchronousEventManager;

package/facade/contentFetcherFacade.d.ts

@@ -0,0 +1,27 @@
+import { JsonObject } from '@croct/json';
+import { ContentFetcher, FetchResponse } from '../contentFetcher';
+import { ContextFactory } from './evaluatorFacade';
+import { TokenProvider } from '../token';
+import { CidAssigner } from '../cid';
+export type FetchOptions = {
+    version?: `${number}` | number;
+    preferredLocale?: string;
+    timeout?: number;
+    attributes?: JsonObject;
+};
+export type Configuration = {
+    contentFetcher: ContentFetcher;
+    contextFactory: ContextFactory;
+    previewTokenProvider: TokenProvider;
+    userTokenProvider: TokenProvider;
+    cidAssigner: CidAssigner;
+};
+export declare class ContentFetcherFacade {
+    private readonly fetcher;
+    private readonly contextFactory;
+    private readonly previewTokenProvider;
+    private readonly userTokenProvider;
+    private readonly cidAssigner;
+    constructor(configuration: Configuration);
+    fetch<P extends JsonObject>(slotId: string, options?: FetchOptions): Promise<FetchResponse<P>>;
+}

package/facade/contentFetcherFacade.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentFetcherFacade = void 0;
+const error_1 = require("../error");
+const schema_1 = require("../schema");
+function validate(options) {
+    try {
+        schema_1.fetchOptionsSchema.validate(options);
+    }
+    catch (violation) {
+        throw new Error(`Invalid options: ${(0, error_1.formatCause)(violation)}`);
+    }
+}
+class ContentFetcherFacade {
+    constructor(configuration) {
+        this.fetcher = configuration.contentFetcher;
+        this.previewTokenProvider = configuration.previewTokenProvider;
+        this.userTokenProvider = configuration.userTokenProvider;
+        this.cidAssigner = configuration.cidAssigner;
+        this.contextFactory = configuration.contextFactory;
+    }
+    async fetch(slotId, options = {}) {
+        var _a, _b;
+        if (typeof slotId !== 'string' || slotId.length === 0) {
+            throw new Error('The slot ID must be a non-empty string.');
+        }
+        validate(options);
+        return this.fetcher.fetch(slotId, {
+            static: false,
+            clientId: await this.cidAssigner.assignCid(),
+            userToken: (_a = this.userTokenProvider.getToken()) !== null && _a !== void 0 ? _a : undefined,
+            previewToken: (_b = this.previewTokenProvider.getToken()) !== null && _b !== void 0 ? _b : undefined,
+            version: options.version,
+            preferredLocale: options.preferredLocale,
+            context: this.contextFactory.createContext(options.attributes),
+            timeout: options.timeout,
+        });
+    }
+}
+exports.ContentFetcherFacade = ContentFetcherFacade;