@croct/sdk 0.10.0 → 0.11.0-alpha.1

package/tab.js

@@ -1,125 +1,96 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tab = void 0;
-var eventManager_1 = require("./eventManager");
-var EventMap = {
+const eventManager_1 = require("./eventManager");
+const EventMap = {
     focus: 'focus',
     blur: 'blur',
     beforeunload: 'unload',
     DOMContentLoaded: 'load',
     visibilitychange: 'visibilityChange',
 };
-var Tab = /** @class */ (function () {
-    function Tab(id, isNew, urlSanitizer) {
+class Tab {
+    constructor(id, isNew, urlSanitizer) {
         this.eventManager = new eventManager_1.SynchronousEventManager();
         this.id = id;
         this.isNew = isNew;
         this.urlSanitizer = urlSanitizer;
         this.initialize();
     }
-    Tab.prototype.initialize = function () {
-        var _this = this;
-        var listener = function (event) {
-            _this.emit(EventMap[event.type], new CustomEvent(EventMap[event.type], { detail: { tab: _this } }));
+    initialize() {
+        const listener = (event) => {
+            this.emit(EventMap[event.type], new CustomEvent(EventMap[event.type], { detail: { tab: this } }));
         };
         window.addEventListener('focus', listener, true);
         window.addEventListener('blur', listener, true);
         window.addEventListener('beforeunload', listener, true);
         window.addEventListener('DOMContentLoaded', listener, true);
-        document.addEventListener('visibilitychange', function () {
-            _this.emit('visibilityChange', new CustomEvent('visibilityChange', {
+        document.addEventListener('visibilitychange', () => {
+            this.emit('visibilityChange', new CustomEvent('visibilityChange', {
                 detail: {
-                    tab: _this,
-                    visible: _this.isVisible,
+                    tab: this,
+                    visible: this.isVisible,
                 },
             }));
         }, true);
-        Tab.addUrlChangeListener(function (url) {
-            _this.emit('urlChange', new CustomEvent('urlChange', { detail: { tab: _this, url: _this.sanitizeUrl(url) } }));
+        Tab.addUrlChangeListener(url => {
+            this.emit('urlChange', new CustomEvent('urlChange', { detail: { tab: this, url: this.sanitizeUrl(url) } }));
         });
-    };
-    Object.defineProperty(Tab.prototype, "url", {
-        get: function () {
-            return this.sanitizeUrl(window.location.href);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Tab.prototype, "title", {
-        get: function () {
-            return document.title;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Tab.prototype, "referrer", {
-        get: function () {
-            return document.referrer === '' ? '' : this.sanitizeUrl(document.referrer);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Tab.prototype, "isVisible", {
-        get: function () {
-            return document.visibilityState === 'visible';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Tab.prototype, "document", {
-        get: function () {
-            return document;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Tab.prototype.addListener = function (type, listener) {
+    }
+    get url() {
+        return this.sanitizeUrl(window.location.href);
+    }
+    get title() {
+        return document.title;
+    }
+    get referrer() {
+        return document.referrer === '' ? '' : this.sanitizeUrl(document.referrer);
+    }
+    get isVisible() {
+        return document.visibilityState === 'visible';
+    }
+    get document() {
+        return document;
+    }
+    addListener(type, listener) {
         this.eventManager.addListener(type, listener);
-    };
-    Tab.prototype.removeListener = function (type, listener) {
+    }
+    removeListener(type, listener) {
         this.eventManager.removeListener(type, listener);
-    };
-    Tab.prototype.sanitizeUrl = function (url) {
-        var normalized = window.encodeURI(window.decodeURI(url));
+    }
+    sanitizeUrl(url) {
+        const normalized = window.encodeURI(window.decodeURI(url));
         if (this.urlSanitizer !== undefined) {
             return this.urlSanitizer(normalized).toString();
         }
         return normalized;
-    };
-    Tab.prototype.emit = function (type, event) {
+    }
+    emit(type, event) {
         this.eventManager.dispatch(type, event);
-    };
-    Tab.addUrlChangeListener = function (listener) {
-        var url = window.location.href;
-        var updateUrl = function () {
-            var currentUrl = window.location.href;
+    }
+    static addUrlChangeListener(listener) {
+        let url = window.location.href;
+        const updateUrl = () => {
+            const currentUrl = window.location.href;
             if (url !== currentUrl) {
                 listener(currentUrl);
                 url = currentUrl;
             }
         };
-        var pushState = window.history.pushState;
-        window.history.pushState = function interceptPushState() {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var result = pushState.apply(window.history, args);
+        const { pushState } = window.history;
+        window.history.pushState = function interceptPushState(...args) {
+            const result = pushState.apply(window.history, args);
             updateUrl();
             return result;
         };
-        var replaceState = window.history.replaceState;
-        window.history.replaceState = function interceptReplaceState() {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var result = replaceState.apply(window.history, args);
+        const { replaceState } = window.history;
+        window.history.replaceState = function interceptReplaceState(...args) {
+            const result = replaceState.apply(window.history, args);
             updateUrl();
             return result;
         };
         window.addEventListener('popstate', updateUrl, true);
-    };
-    return Tab;
-}());
+    }
+}
 exports.Tab = Tab;
+//# sourceMappingURL=tab.js.map

package/token/cachedTokenStore.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CachedTokenStore = void 0;
-var token_1 = require("./token");
-var CachedTokenStore = /** @class */ (function () {
-    function CachedTokenStore(cache) {
+const token_1 = require("./token");
+class CachedTokenStore {
+    constructor(cache) {
         this.cache = cache;
     }
-    CachedTokenStore.prototype.getToken = function () {
-        var data = this.cache.get();
+    getToken() {
+        const data = this.cache.get();
         if (data === null) {
             return null;
         }
@@ -17,14 +17,14 @@ var CachedTokenStore = /** @class */ (function () {
         catch (error) {
             return null;
         }
-    };
-    CachedTokenStore.prototype.setToken = function (token) {
+    }
+    setToken(token) {
         if (token === null) {
             this.cache.clear();
             return;
         }
         this.cache.put(token.toString());
-    };
-    return CachedTokenStore;
-}());
+    }
+}
 exports.CachedTokenStore = CachedTokenStore;
+//# sourceMappingURL=cachedTokenStore.js.map

package/token/inMemoryTokenStore.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryTokenStore = void 0;
-var InMemoryTokenStore = /** @class */ (function () {
-    function InMemoryTokenStore() {
+class InMemoryTokenStore {
+    constructor() {
         this.token = null;
     }
-    InMemoryTokenStore.prototype.getToken = function () {
+    getToken() {
         return this.token;
-    };
-    InMemoryTokenStore.prototype.setToken = function (token) {
+    }
+    setToken(token) {
         this.token = token;
-    };
-    return InMemoryTokenStore;
-}());
+    }
+}
 exports.InMemoryTokenStore = InMemoryTokenStore;
+//# sourceMappingURL=inMemoryTokenStore.js.map

package/token/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReplicatedTokenStore = exports.InMemoryTokenStore = exports.CachedTokenStore = void 0;
-var tslib_1 = require("tslib");
+const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./token"), exports);
 var cachedTokenStore_1 = require("./cachedTokenStore");
 Object.defineProperty(exports, "CachedTokenStore", { enumerable: true, get: function () { return cachedTokenStore_1.CachedTokenStore; } });
@@ -9,3 +9,4 @@ var inMemoryTokenStore_1 = require("./inMemoryTokenStore");
 Object.defineProperty(exports, "InMemoryTokenStore", { enumerable: true, get: function () { return inMemoryTokenStore_1.InMemoryTokenStore; } });
 var replicatedTokenStore_1 = require("./replicatedTokenStore");
 Object.defineProperty(exports, "ReplicatedTokenStore", { enumerable: true, get: function () { return replicatedTokenStore_1.ReplicatedTokenStore; } });
+//# sourceMappingURL=index.js.map

package/token/replicatedTokenStore.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReplicatedTokenStore = void 0;
-var ReplicatedTokenStore = /** @class */ (function () {
-    function ReplicatedTokenStore(primary, secondary) {
+class ReplicatedTokenStore {
+    constructor(primary, secondary) {
         this.primary = primary;
         this.secondary = secondary;
     }
-    ReplicatedTokenStore.prototype.getToken = function () {
+    getToken() {
         return this.primary.getToken();
-    };
-    ReplicatedTokenStore.prototype.setToken = function (token) {
+    }
+    setToken(token) {
         this.primary.setToken(token);
         this.secondary.setToken(token);
-    };
-    return ReplicatedTokenStore;
-}());
+    }
+}
 exports.ReplicatedTokenStore = ReplicatedTokenStore;
+//# sourceMappingURL=replicatedTokenStore.js.map

package/token/token.d.ts

@@ -1,10 +1,11 @@
-export declare type Headers = {
+import { JsonObject } from '@croct/json';
+export type Headers = {
     typ: string;
     alg: string;
     kid?: string;
-    appId: string;
+    appId?: string;
 };
-export declare type Claims = {
+type Claims = {
     iss: string;
     aud: string | string[];
     iat: number;
@@ -12,15 +13,17 @@ export declare type Claims = {
     sub?: string;
     jid?: string;
 };
+export type TokenPayload = JsonObject & Claims;
 export declare class Token {
     private readonly headers;
-    private readonly claims;
+    private readonly payload;
     private readonly signature;
     private constructor();
     static issue(appId: string, subject?: string | null, timestamp?: number): Token;
     static parse(token: string): Token;
+    static of(headers: Headers, payload: TokenPayload, signature?: string): Token;
     getHeaders(): Headers;
-    getClaims(): Claims;
+    getPayload(): TokenPayload;
     getSignature(): string;
     isAnonymous(): boolean;
     getSubject(): string | null;
@@ -39,3 +42,4 @@ export declare class FixedTokenProvider implements TokenProvider {
     constructor(token: Token | null);
     getToken(): Token | null;
 }
+export {};

package/token/token.js

@@ -1,20 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FixedTokenProvider = exports.Token = void 0;
-var tslib_1 = require("tslib");
-var base64Url_1 = require("../base64Url");
-var schema_1 = require("../schema");
-var error_1 = require("../error");
-var Token = /** @class */ (function () {
-    function Token(headers, claims, signature) {
-        if (signature === void 0) { signature = ''; }
+const base64Url_1 = require("../base64Url");
+const schema_1 = require("../schema");
+const error_1 = require("../error");
+class Token {
+    constructor(headers, payload, signature = '') {
         this.headers = headers;
-        this.claims = claims;
+        this.payload = payload;
         this.signature = signature;
     }
-    Token.issue = function (appId, subject, timestamp) {
-        if (subject === void 0) { subject = null; }
-        if (timestamp === void 0) { timestamp = Math.floor(Date.now() / 1000); }
+    static issue(appId, subject = null, timestamp = Math.floor(Date.now() / 1000)) {
         if (timestamp < 0) {
             throw new Error('The timestamp must be non-negative.');
         }
@@ -25,75 +21,86 @@ var Token = /** @class */ (function () {
             typ: 'JWT',
             alg: 'none',
             appId: appId,
-        }, tslib_1.__assign({ iss: 'croct.io', aud: 'croct.io', iat: timestamp }, (subject !== null ? { sub: subject } : null)));
-    };
-    Token.parse = function (token) {
+        }, {
+            iss: 'croct.io',
+            aud: 'croct.io',
+            iat: timestamp,
+            ...(subject !== null ? { sub: subject } : null),
+        });
+    }
+    static parse(token) {
         if (token === '') {
             throw new Error('The token cannot be empty.');
         }
-        var parts = token.split('.', 3);
+        const parts = token.split('.', 3);
         // This token is invalid
         if (parts.length < 2) {
             throw new Error('The token is malformed.');
         }
-        var headers;
-        var claims;
-        var signature;
+        let headers;
+        let payload;
+        let signature;
         try {
             headers = JSON.parse((0, base64Url_1.base64UrlDecode)(parts[0]));
-            claims = JSON.parse((0, base64Url_1.base64UrlDecode)(parts[1]));
+            payload = JSON.parse((0, base64Url_1.base64UrlDecode)(parts[1]));
             if (parts.length === 3) {
                 signature = (0, base64Url_1.base64UrlDecode)(parts[2]);
             }
         }
-        catch (_a) {
+        catch {
             throw new Error('The token is corrupted.');
         }
+        return Token.of(headers, payload, signature);
+    }
+    static of(headers, payload, signature = '') {
         try {
-            schema_1.tokenSchema.validate({ headers: headers, claims: claims, signature: signature });
+            schema_1.tokenSchema.validate({
+                headers: headers,
+                payload: payload,
+                signature: signature,
+            });
         }
         catch (violation) {
-            throw new Error("The token is invalid: ".concat((0, error_1.formatCause)(violation)));
+            throw new Error(`The token is invalid: ${(0, error_1.formatCause)(violation)}`);
         }
-        return new Token(headers, claims, signature);
-    };
-    Token.prototype.getHeaders = function () {
-        return tslib_1.__assign({}, this.headers);
-    };
-    Token.prototype.getClaims = function () {
-        return tslib_1.__assign({}, this.claims);
-    };
-    Token.prototype.getSignature = function () {
+        return new Token(headers, payload, signature);
+    }
+    getHeaders() {
+        return { ...this.headers };
+    }
+    getPayload() {
+        return { ...this.payload };
+    }
+    getSignature() {
         return this.signature;
-    };
-    Token.prototype.isAnonymous = function () {
-        return this.claims.sub === undefined;
-    };
-    Token.prototype.getSubject = function () {
-        return this.claims.sub !== undefined ? this.claims.sub : null;
-    };
-    Token.prototype.getIssueTime = function () {
-        return this.claims.iat;
-    };
-    Token.prototype.toJSON = function () {
+    }
+    isAnonymous() {
+        return this.payload.sub === undefined;
+    }
+    getSubject() {
+        return this.payload.sub !== undefined ? this.payload.sub : null;
+    }
+    getIssueTime() {
+        return this.payload.iat;
+    }
+    toJSON() {
         return this.toString();
-    };
-    Token.prototype.toString = function () {
-        var headers = (0, base64Url_1.base64UrlEncode)(JSON.stringify(this.headers));
-        var claims = (0, base64Url_1.base64UrlEncode)(JSON.stringify(this.claims));
-        var signature = (0, base64Url_1.base64UrlEncode)(this.signature);
-        return "".concat(headers, ".").concat(claims, ".").concat(signature);
-    };
-    return Token;
-}());
+    }
+    toString() {
+        const headers = (0, base64Url_1.base64UrlEncode)(JSON.stringify(this.headers));
+        const payload = (0, base64Url_1.base64UrlEncode)(JSON.stringify(this.payload));
+        const signature = (0, base64Url_1.base64UrlEncode)(this.signature);
+        return `${headers}.${payload}.${signature}`;
+    }
+}
 exports.Token = Token;
-var FixedTokenProvider = /** @class */ (function () {
-    function FixedTokenProvider(token) {
+class FixedTokenProvider {
+    constructor(token) {
         this.token = token;
     }
-    FixedTokenProvider.prototype.getToken = function () {
+    getToken() {
         return this.token;
-    };
-    return FixedTokenProvider;
-}());
+    }
+}
 exports.FixedTokenProvider = FixedTokenProvider;
+//# sourceMappingURL=token.js.map

package/tracker.d.ts

@@ -4,19 +4,19 @@ import { OutputChannel } from './channel';
 import { TokenProvider } from './token';
 import { RetryPolicy } from './retry';
 import { Beacon, TrackingEvent, TrackingEventContext, PartialTrackingEvent } from './trackingEvents';
-declare type Options = {
+type Options = {
     eventMetadata?: {
         [key: string]: string;
     };
 };
-export declare type Configuration = Options & {
+export type Configuration = Options & {
     channel: OutputChannel<Beacon>;
     logger?: Logger;
     tab: Tab;
     tokenProvider: TokenProvider;
     inactivityRetryPolicy: RetryPolicy<number>;
 };
-export declare type EventInfo<T extends TrackingEvent = TrackingEvent> = {
+export type EventInfo<T extends TrackingEvent = TrackingEvent> = {
     context: TrackingEventContext;
     event: T;
     timestamp: number;
@@ -36,7 +36,7 @@ export declare class Tracker {
     private readonly pending;
     private readonly state;
     private readonly inactivityTimer;
-    constructor({ tab, tokenProvider, channel, logger, inactivityRetryPolicy, ...options }: Configuration);
+    constructor(config: Configuration);
     addListener(listener: EventListener): void;
     removeListener(listener: EventListener): void;
     get flushed(): Promise<void>;