@croct/sdk 0.9.1 → 0.11.0-alpha

package/channel/socketChannel.js

@@ -1,102 +1,102 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SocketChannel = void 0;
-var tslib_1 = require("tslib");
-var logging_1 = require("../logging");
-var error_1 = require("../error");
-var SocketChannel = /** @class */ (function () {
-    function SocketChannel(_a) {
-        var _b, _c, _d;
-        var url = _a.url, logger = _a.logger, options = tslib_1.__rest(_a, ["url", "logger"]);
+const logging_1 = require("../logging");
+const error_1 = require("../error");
+class SocketChannel {
+    constructor({ url, logger, ...options }) {
+        var _a, _b, _c;
         this.listeners = [];
         this.closed = false;
         this.url = url;
         this.logger = logger !== null && logger !== void 0 ? logger : new logging_1.NullLogger();
-        this.options = tslib_1.__assign(tslib_1.__assign({}, options), { closeTimeout: (_b = options.closeTimeout) !== null && _b !== void 0 ? _b : 5000, connectionTimeout: (_c = options.connectionTimeout) !== null && _c !== void 0 ? _c : 10000, protocols: (_d = options.protocols) !== null && _d !== void 0 ? _d : [] });
+        this.options = {
+            ...options,
+            closeTimeout: (_a = options.closeTimeout) !== null && _a !== void 0 ? _a : 5000,
+            connectionTimeout: (_b = options.connectionTimeout) !== null && _b !== void 0 ? _b : 10000,
+            protocols: (_c = options.protocols) !== null && _c !== void 0 ? _c : [],
+        };
     }
-    Object.defineProperty(SocketChannel.prototype, "connected", {
-        get: function () {
-            if (this.connection === undefined) {
-                return Promise.resolve(false);
-            }
-            return this.connection.then(function () { return true; }, function () { return false; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    SocketChannel.prototype.publish = function (message) {
-        var _this = this;
-        return this.connect().then(function (socket) {
+    get connected() {
+        if (this.connection === undefined) {
+            return Promise.resolve(false);
+        }
+        return this.connection.then(() => true, () => false);
+    }
+    publish(message) {
+        return this.connect().then(socket => {
             socket.send(message);
-            _this.logger.debug('Message sent.');
+            this.logger.debug('Message sent.');
         });
-    };
-    SocketChannel.prototype.subscribe = function (listener) {
+    }
+    subscribe(listener) {
         if (!this.listeners.includes(listener)) {
             this.listeners.push(listener);
         }
-    };
-    SocketChannel.prototype.unsubscribe = function (listener) {
-        var index = this.listeners.indexOf(listener);
+    }
+    unsubscribe(listener) {
+        const index = this.listeners.indexOf(listener);
         if (index >= 0) {
             this.listeners.splice(index, 1);
         }
-    };
-    SocketChannel.prototype.notify = function (message) {
-        this.listeners.forEach(function (dispatch) { return dispatch(message); });
-    };
-    SocketChannel.prototype.connect = function () {
-        var _this = this;
+    }
+    notify(message) {
+        this.listeners.forEach(dispatch => dispatch(message));
+    }
+    connect() {
         if (this.closed) {
             return Promise.reject(new Error('Channel has been closed.'));
         }
         if (this.connection !== undefined) {
-            return this.connection.then(function (connection) {
-                var state = connection.readyState;
+            return this.connection
+                .then(connection => {
+                const state = connection.readyState;
                 if (state === WebSocket.OPEN) {
                     return connection;
                 }
                 throw new Error('Connection lost.');
-            }).catch(function () {
+            })
+                .catch(() => {
                 // Reconnect
-                delete _this.connection;
-                return _this.connect();
+                delete this.connection;
+                return this.connect();
             });
         }
-        this.connection = new Promise(function (resolve, reject) {
-            _this.logger.debug('Connecting...');
-            var connection = new window.WebSocket(_this.url, _this.options.protocols);
-            if (_this.options.binaryType) {
-                connection.binaryType = _this.options.binaryType;
+        this.connection = new Promise((resolve, reject) => {
+            this.logger.debug('Connecting...');
+            const connection = new window.WebSocket(this.url, this.options.protocols);
+            if (this.options.binaryType !== undefined) {
+                connection.binaryType = this.options.binaryType;
             }
-            var abortListener = function () {
-                var reason = 'Maximum connection timeout reached.';
-                _this.logger.error(reason);
+            const abortListener = () => {
+                const reason = 'Maximum connection timeout reached.';
+                this.logger.error(reason);
                 reject(new Error(reason));
                 connection.close(1000, reason);
             };
-            var abortTimer = window.setTimeout(abortListener, _this.options.connectionTimeout);
-            var openListener = function () {
+            const abortTimer = window.setTimeout(abortListener, this.options.connectionTimeout);
+            const openListener = () => {
                 window.clearTimeout(abortTimer);
-                _this.logger.info('Connection established.');
+                this.logger.info('Connection established.');
                 connection.removeEventListener('open', openListener);
                 resolve(connection);
             };
-            var errorListener = function () {
-                if (!_this.closed) {
-                    _this.logger.error('Connection error.');
+            const errorListener = () => {
+                if (!this.closed) {
+                    this.logger.error('Connection error.');
                 }
             };
-            var messageListener = function (event) {
-                _this.logger.debug('Message received.');
-                _this.notify(event.data);
+            const messageListener = (event) => {
+                this.logger.debug('Message received.');
+                this.notify(event.data);
             };
-            var closeListener = function (event) {
+            const closeListener = (event) => {
+                var _a;
                 window.clearTimeout(abortTimer);
-                var reason = "".concat((0, error_1.formatCause)(event.reason || 'unknown'), " (code ").concat(event.code, ")");
-                var message = "Connection has been closed, reason: ".concat(reason);
-                if (!_this.closed) {
-                    _this.logger.info(message);
+                const reason = `${(0, error_1.formatCause)((_a = event.reason) !== null && _a !== void 0 ? _a : 'unknown')} (code ${event.code})`;
+                const message = `Connection has been closed, reason: ${reason}`;
+                if (!this.closed) {
+                    this.logger.info(message);
                 }
                 connection.removeEventListener('open', openListener);
                 connection.removeEventListener('error', errorListener);
@@ -110,37 +110,35 @@ var SocketChannel = /** @class */ (function () {
             connection.addEventListener('message', messageListener);
         });
         return this.connection;
-    };
-    SocketChannel.prototype.close = function () {
-        var _this = this;
+    }
+    close() {
         this.logger.debug('Closing connection...');
-        return new Promise(function (resolve, reject) {
-            _this.closed = true;
-            if (_this.connection === undefined) {
-                _this.logger.debug('Connection is not open.');
+        return new Promise((resolve, reject) => {
+            this.closed = true;
+            if (this.connection === undefined) {
+                this.logger.debug('Connection is not open.');
                 resolve();
                 return;
             }
-            _this.connection.then(function (connection) {
-                var abortTimer;
-                var abort = function () {
-                    _this.logger.warn('Connection could not be closed within the timeout period.');
+            this.connection.then((connection) => {
+                let abortTimer;
+                const abort = () => {
+                    this.logger.warn('Connection could not be closed within the timeout period.');
                     reject(new Error('Maximum close timeout reached.'));
                 };
-                var close = function () {
+                const close = () => {
                     window.clearTimeout(abortTimer);
-                    _this.logger.info('Connection gracefully closed.');
+                    this.logger.info('Connection gracefully closed.');
                     resolve();
                 };
                 connection.addEventListener('close', close, { once: true });
                 connection.close(1000, 'Deliberate disconnection.');
-                abortTimer = window.setTimeout(abort, _this.options.closeTimeout);
-            }, function () {
-                _this.logger.info('Connection closed.');
+                abortTimer = window.setTimeout(abort, this.options.closeTimeout);
+            }, () => {
+                this.logger.info('Connection closed.');
                 resolve();
             });
         });
-    };
-    return SocketChannel;
-}());
+    }
+}
 exports.SocketChannel = SocketChannel;

package/cid/cachedAssigner.js

@@ -1,35 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CachedAssigner = void 0;
-var tslib_1 = require("tslib");
-var logging_1 = require("../logging");
-var CachedAssigner = /** @class */ (function () {
-    function CachedAssigner(assigner, cache, logger) {
+const logging_1 = require("../logging");
+class CachedAssigner {
+    constructor(assigner, cache, logger) {
         this.assigner = assigner;
         this.cache = cache;
         this.logger = logger !== null && logger !== void 0 ? logger : new logging_1.NullLogger();
     }
-    CachedAssigner.prototype.assignCid = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var cid, newCid;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        cid = this.cache.get();
-                        if (cid !== null) {
-                            this.logger.debug('Previous CID loaded from cache');
-                            return [2 /*return*/, cid];
-                        }
-                        return [4 /*yield*/, this.assigner.assignCid()];
-                    case 1:
-                        newCid = _a.sent();
-                        this.cache.put(newCid);
-                        this.logger.debug('New CID stored into cache');
-                        return [2 /*return*/, newCid];
-                }
-            });
-        });
-    };
-    return CachedAssigner;
-}());
+    async assignCid() {
+        const cid = this.cache.get();
+        if (cid !== null) {
+            this.logger.debug('Previous CID loaded from cache');
+            return cid;
+        }
+        const newCid = await this.assigner.assignCid();
+        this.cache.put(newCid);
+        this.logger.debug('New CID stored into cache');
+        return newCid;
+    }
+}
 exports.CachedAssigner = CachedAssigner;

package/cid/fixedAssigner.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FixedAssigner = void 0;
-var FixedAssigner = /** @class */ (function () {
-    function FixedAssigner(cid) {
+class FixedAssigner {
+    constructor(cid) {
         this.cid = cid;
     }
-    FixedAssigner.prototype.assignCid = function () {
+    assignCid() {
         return Promise.resolve(this.cid);
-    };
-    return FixedAssigner;
-}());
+    }
+}
 exports.FixedAssigner = FixedAssigner;

package/cid/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoteAssigner = exports.FixedAssigner = exports.CachedAssigner = void 0;
-var tslib_1 = require("tslib");
+const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./assigner"), exports);
 var cachedAssigner_1 = require("./cachedAssigner");
 Object.defineProperty(exports, "CachedAssigner", { enumerable: true, get: function () { return cachedAssigner_1.CachedAssigner; } });

package/cid/remoteAssigner.js

@@ -1,47 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoteAssigner = void 0;
-var tslib_1 = require("tslib");
-var logging_1 = require("../logging");
-var error_1 = require("../error");
-var RemoteAssigner = /** @class */ (function () {
-    function RemoteAssigner(endpoint, logger) {
+const logging_1 = require("../logging");
+const error_1 = require("../error");
+class RemoteAssigner {
+    constructor(endpoint, logger) {
         this.endpoint = endpoint;
         this.logger = logger !== null && logger !== void 0 ? logger : new logging_1.NullLogger();
     }
-    RemoteAssigner.prototype.assignCid = function () {
-        var _this = this;
+    assignCid() {
         if (this.pending === undefined) {
-            this.pending = this.fetchCid().finally(function () {
-                _this.pending = undefined;
+            this.pending = this.fetchCid().finally(() => {
+                this.pending = undefined;
             });
         }
         return this.pending;
-    };
-    RemoteAssigner.prototype.fetchCid = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var options, response, error;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        options = {
-                            method: 'GET',
-                            credentials: 'include',
-                        };
-                        return [4 /*yield*/, window.fetch(this.endpoint, options)];
-                    case 1:
-                        response = _a.sent();
-                        if (!response.ok) {
-                            error = new Error("Failed to assign CID: ".concat((0, error_1.formatCause)(response.statusText)));
-                            this.logger.error(error.message);
-                            throw error;
-                        }
-                        this.logger.debug('New CID successfully assigned');
-                        return [2 /*return*/, response.text()];
-                }
-            });
-        });
-    };
-    return RemoteAssigner;
-}());
+    }
+    async fetchCid() {
+        const options = {
+            method: 'GET',
+            credentials: 'include',
+        };
+        const response = await window.fetch(this.endpoint, options);
+        if (!response.ok) {
+            const error = new Error(`Failed to assign CID: ${(0, error_1.formatCause)(response.statusText)}`);
+            this.logger.error(error.message);
+            throw error;
+        }
+        this.logger.debug('New CID successfully assigned');
+        return response.text();
+    }
+}
 exports.RemoteAssigner = RemoteAssigner;

package/constants.d.ts

@@ -1,5 +1,6 @@
+export declare const CID_ASSIGNER_ENDPOINT_URL = "<@cidAssignerEndpointUrl@>";
 export declare const TRACKER_ENDPOINT_URL = "<@trackerEndpointUrl@>";
 export declare const EVALUATION_ENDPOINT_URL = "<@evaluationEndpointUrl@>";
-export declare const BOOTSTRAP_ENDPOINT_URL = "<@bootstrapEndpointUrl@>";
-export declare const MAX_EXPRESSION_LENGTH: number;
+export declare const CONTENT_ENDPOINT_URL = "<@contentEndpointUrl@>";
+export declare const MAX_QUERY_LENGTH: number;
 export declare const VERSION = "<@version@>";

package/constants.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = exports.MAX_EXPRESSION_LENGTH = exports.BOOTSTRAP_ENDPOINT_URL = exports.EVALUATION_ENDPOINT_URL = exports.TRACKER_ENDPOINT_URL = void 0;
+exports.VERSION = exports.MAX_QUERY_LENGTH = exports.CONTENT_ENDPOINT_URL = exports.EVALUATION_ENDPOINT_URL = exports.TRACKER_ENDPOINT_URL = exports.CID_ASSIGNER_ENDPOINT_URL = void 0;
+exports.CID_ASSIGNER_ENDPOINT_URL = 'https://api.croct.io/client/web/bootstrap';
 exports.TRACKER_ENDPOINT_URL = 'wss://api.croct.io/client/web/connect';
-exports.EVALUATION_ENDPOINT_URL = 'https://api.croct.io/client/web/evaluate';
-exports.BOOTSTRAP_ENDPOINT_URL = 'https://api.croct.io/client/web/bootstrap';
-exports.MAX_EXPRESSION_LENGTH = 300;
-exports.VERSION = '0.9.1';
+exports.EVALUATION_ENDPOINT_URL = 'https://api.croct.io';
+exports.CONTENT_ENDPOINT_URL = 'https://api.croct.io';
+exports.MAX_QUERY_LENGTH = 500;
+exports.VERSION = '0.11.0-alpha';

package/container.d.ts

@@ -1,22 +1,24 @@
 import { Logger } from './logging';
 import { Context, TokenScope } from './context';
 import { MonitoredQueue } from './queue';
-import { TokenProvider } from './token';
+import { TokenStore } from './token';
 import { Tracker } from './tracker';
 import { Evaluator } from './evaluator';
 import { CidAssigner } from './cid';
 import { EventManager } from './eventManager';
 import { SdkEventMap } from './sdkEvents';
 import { UrlSanitizer } from './tab';
-export declare type Configuration = {
+import { ContentFetcher } from './contentFetcher';
+export type Configuration = {
     appId: string;
     tokenScope: TokenScope;
-    cid?: string;
+    clientId?: string;
     debug: boolean;
     test: boolean;
     trackerEndpointUrl: string;
     evaluationEndpointUrl: string;
-    bootstrapEndpointUrl: string;
+    contentEndpointUrl: string;
+    cidAssignerEndpointUrl: string;
     beaconQueueSize: number;
     logger?: Logger;
     urlSanitizer?: UrlSanitizer;
@@ -27,9 +29,11 @@ export declare type Configuration = {
 export declare class Container {
     private readonly configuration;
     private context?;
-    private tokenProvider?;
+    private userTokenProvider?;
+    private previewTokenStore?;
     private tracker?;
     private evaluator?;
+    private contentFetcher?;
     private cidAssigner?;
     private beaconChannel?;
     private beaconQueue?;
@@ -39,9 +43,12 @@ export declare class Container {
     getConfiguration(): Configuration;
     getEvaluator(): Evaluator;
     private createEvaluator;
+    getContentFetcher(): ContentFetcher;
+    private createContentFetcher;
+    getPreviewTokenStore(): TokenStore;
     getTracker(): Tracker;
     private createTracker;
-    getTokenProvider(): TokenProvider;
+    getUserTokenStore(): TokenStore;
     getContext(): Context;
     private createContext;
     private getBeaconChannel;