@croct/sdk 0.10.0 → 0.11.0-alpha

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; } });

package/token/replicatedTokenStore.js

@@ -1,18 +1,17 @@
 "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;

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,85 @@ 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;

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>;