@croct/sdk 0.17.11 → 0.18.0

package/tab.d.cts

@@ -0,0 +1,40 @@
+import { EventListener } from './eventManager.cjs';
+
+type TabEvent<T = Record<string, unknown>> = CustomEvent<{
+    tab: Tab;
+} & T>;
+type TabVisibilityChangeEvent = TabEvent<{
+    visible: boolean;
+}>;
+type TabUrlChangeEvent = TabEvent<{
+    url: string;
+}>;
+type UrlSanitizer = (url: string) => URL;
+type TabEventMap = {
+    focus: TabEvent;
+    blur: TabEvent;
+    load: TabEvent;
+    unload: TabEvent;
+    visibilityChange: TabVisibilityChangeEvent;
+    urlChange: TabUrlChangeEvent;
+};
+declare class Tab {
+    readonly id: string;
+    readonly isNew: boolean;
+    readonly urlSanitizer?: UrlSanitizer;
+    private readonly eventManager;
+    constructor(id: string, isNew: boolean, urlSanitizer?: UrlSanitizer);
+    private initialize;
+    get url(): string;
+    get title(): string;
+    get referrer(): string;
+    get isVisible(): boolean;
+    get document(): Document;
+    addListener<T extends keyof TabEventMap>(type: T, listener: EventListener<TabEventMap[T]>): void;
+    removeListener<T extends keyof TabEventMap>(type: T, listener: EventListener<TabEventMap[T]>): void;
+    private sanitizeUrl;
+    private emit;
+    private static addUrlChangeListener;
+}
+
+export { Tab, type TabEvent, type TabUrlChangeEvent, type TabVisibilityChangeEvent, type UrlSanitizer };

package/tab.js

@@ -1,4 +1,4 @@
-import { SynchronousEventManager } from "./eventManager";
+import { SynchronousEventManager } from "./eventManager.js";
 const EventMap = {
   focus: "focus",
   blur: "blur",
@@ -96,4 +96,3 @@ class Tab {
 export {
   Tab
 };
-//# sourceMappingURL=tab.js.map

package/token/cachedTokenStore.cjs

@@ -20,7 +20,7 @@ __export(cachedTokenStore_exports, {
   CachedTokenStore: () => CachedTokenStore
 });
 module.exports = __toCommonJS(cachedTokenStore_exports);
-var import_token = require("./token");
+var import_token = require('./token.cjs');
 class CachedTokenStore {
   constructor(cache) {
     this.cache = cache;
@@ -48,4 +48,3 @@ class CachedTokenStore {
 0 && (module.exports = {
   CachedTokenStore
 });
-//# sourceMappingURL=cachedTokenStore.cjs.map

package/token/cachedTokenStore.d.cts

@@ -0,0 +1,13 @@
+import { TokenStore, Token } from './token.cjs';
+import { Cache } from '../cache/cache.cjs';
+import '@croct/json';
+import '../apiKey.cjs';
+
+declare class CachedTokenStore implements TokenStore {
+    private readonly cache;
+    constructor(cache: Cache);
+    getToken(): Token | null;
+    setToken(token: Token | null): void;
+}
+
+export { CachedTokenStore };

package/token/cachedTokenStore.js

@@ -1,4 +1,4 @@
-import { Token } from "./token";
+import { Token } from "./token.js";
 class CachedTokenStore {
   constructor(cache) {
     this.cache = cache;
@@ -25,4 +25,3 @@ class CachedTokenStore {
 export {
   CachedTokenStore
 };
-//# sourceMappingURL=cachedTokenStore.js.map

package/token/inMemoryTokenStore.cjs

@@ -35,4 +35,3 @@ class InMemoryTokenStore {
 0 && (module.exports = {
   InMemoryTokenStore
 });
-//# sourceMappingURL=inMemoryTokenStore.cjs.map

package/token/inMemoryTokenStore.d.cts

@@ -0,0 +1,11 @@
+import { TokenStore, Token } from './token.cjs';
+import '@croct/json';
+import '../apiKey.cjs';
+
+declare class InMemoryTokenStore implements TokenStore {
+    private token;
+    getToken(): Token | null;
+    setToken(token: Token | null): void;
+}
+
+export { InMemoryTokenStore };

package/token/inMemoryTokenStore.js

@@ -12,4 +12,3 @@ class InMemoryTokenStore {
 export {
   InMemoryTokenStore
 };
-//# sourceMappingURL=inMemoryTokenStore.js.map

package/token/index.cjs

@@ -23,15 +23,14 @@ __export(token_exports, {
   ReplicatedTokenStore: () => import_replicatedTokenStore.ReplicatedTokenStore
 });
 module.exports = __toCommonJS(token_exports);
-__reExport(token_exports, require("./token"), module.exports);
-var import_cachedTokenStore = require("./cachedTokenStore");
-var import_inMemoryTokenStore = require("./inMemoryTokenStore");
-var import_replicatedTokenStore = require("./replicatedTokenStore");
+__reExport(token_exports, require('./token.cjs'), module.exports);
+var import_cachedTokenStore = require('./cachedTokenStore.cjs');
+var import_inMemoryTokenStore = require('./inMemoryTokenStore.cjs');
+var import_replicatedTokenStore = require('./replicatedTokenStore.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CachedTokenStore,
   InMemoryTokenStore,
   ReplicatedTokenStore,
-  ...require("./token")
+  ...require('./token.cjs')
 });
-//# sourceMappingURL=index.cjs.map

package/token/index.d.cts

@@ -0,0 +1,7 @@
+export { FixedTokenProvider, Token, TokenClaims, TokenHeaders, TokenPayload, TokenProvider, TokenStore } from './token.cjs';
+export { CachedTokenStore } from './cachedTokenStore.cjs';
+export { InMemoryTokenStore } from './inMemoryTokenStore.cjs';
+export { ReplicatedTokenStore } from './replicatedTokenStore.cjs';
+import '@croct/json';
+import '../apiKey.cjs';
+import '../cache/cache.cjs';

package/token/index.js

@@ -1,10 +1,9 @@
-export * from "./token";
-import { CachedTokenStore } from "./cachedTokenStore";
-import { InMemoryTokenStore } from "./inMemoryTokenStore";
-import { ReplicatedTokenStore } from "./replicatedTokenStore";
+export * from "./token.js";
+import { CachedTokenStore } from "./cachedTokenStore.js";
+import { InMemoryTokenStore } from "./inMemoryTokenStore.js";
+import { ReplicatedTokenStore } from "./replicatedTokenStore.js";
 export {
   CachedTokenStore,
   InMemoryTokenStore,
   ReplicatedTokenStore
 };
-//# sourceMappingURL=index.js.map

package/token/replicatedTokenStore.cjs

@@ -37,4 +37,3 @@ class ReplicatedTokenStore {
 0 && (module.exports = {
   ReplicatedTokenStore
 });
-//# sourceMappingURL=replicatedTokenStore.cjs.map

package/token/replicatedTokenStore.d.cts

@@ -0,0 +1,13 @@
+import { TokenStore, Token } from './token.cjs';
+import '@croct/json';
+import '../apiKey.cjs';
+
+declare class ReplicatedTokenStore implements TokenStore {
+    private primary;
+    private secondary;
+    constructor(primary: TokenStore, secondary: TokenStore);
+    getToken(): Token | null;
+    setToken(token: Token | null): void;
+}
+
+export { ReplicatedTokenStore };

package/token/replicatedTokenStore.js

@@ -14,4 +14,3 @@ class ReplicatedTokenStore {
 export {
   ReplicatedTokenStore
 };
-//# sourceMappingURL=replicatedTokenStore.js.map

package/token/token.cjs

@@ -21,9 +21,9 @@ __export(token_exports, {
   Token: () => Token
 });
 module.exports = __toCommonJS(token_exports);
-var import_schema = require("../schema");
-var import_error = require("../error");
-var import_base64Url = require("../base64Url");
+var import_schema = require('../schema/index.cjs');
+var import_error = require('../error.cjs');
+var import_base64Url = require('../base64Url.cjs');
 const _Token = class _Token {
   constructor(headers, payload, signature = "") {
     this.headers = headers;
@@ -236,4 +236,3 @@ class FixedTokenProvider {
   FixedTokenProvider,
   Token
 });
-//# sourceMappingURL=token.cjs.map

package/token/token.d.cts

@@ -0,0 +1,70 @@
+import { JsonObject } from '@croct/json';
+import { ApiKey } from '../apiKey.cjs';
+
+type TokenHeaders = {
+    typ: string;
+    alg: string;
+    kid?: string;
+    appId?: string;
+};
+type TokenClaims = {
+    iss: string;
+    aud: string | string[];
+    iat: number;
+    exp?: number;
+    sub?: string;
+    jti?: string;
+};
+type TokenPayload = JsonObject & TokenClaims;
+declare class Token {
+    private static readonly UUID_PATTERN;
+    private readonly headers;
+    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: TokenHeaders, payload: TokenPayload, signature?: string): Token;
+    signedWith(apiKey: ApiKey): Promise<Token>;
+    isSigned(): boolean;
+    isSubject(subject: string): boolean;
+    isAnonymous(): boolean;
+    isValidNow(now?: number): boolean;
+    isNewerThan(token: Token): boolean;
+    matchesKeyId(apiKey: ApiKey): Promise<boolean>;
+    getHeaders(): TokenHeaders;
+    getPayload(): TokenPayload;
+    getSignature(): string;
+    getApplicationId(): string | null;
+    getAlgorithm(): string;
+    getType(): string;
+    getKeyId(): string | null;
+    getSubject(): string | null;
+    getIssueTime(): number;
+    getExpirationTime(): number | null;
+    getTokenId(): string | null;
+    getAudience(): string | string[];
+    getIssuer(): string;
+    withTokenId(tokenId: string): Token;
+    withDuration(duration: number, now?: number): Token;
+    withAddedHeaders(headers: Partial<TokenHeaders>): Token;
+    withAddedClaims(claims: Partial<TokenClaims>): Token;
+    withHeaders(headers: TokenHeaders): Token;
+    withPayload(payload: TokenPayload): Token;
+    withSignature(signature: string): Token;
+    toJSON(): string;
+    toString(): string;
+}
+interface TokenProvider {
+    getToken(): Token | null;
+}
+interface TokenStore extends TokenProvider {
+    setToken(token: Token | null): void;
+}
+declare class FixedTokenProvider implements TokenProvider {
+    private readonly token;
+    constructor(token: Token | null);
+    getToken(): Token | null;
+}
+
+export { FixedTokenProvider, Token, type TokenClaims, type TokenHeaders, type TokenPayload, type TokenProvider, type TokenStore };

package/token/token.js

@@ -1,6 +1,6 @@
-import { tokenSchema } from "../schema";
-import { formatCause } from "../error";
-import { base64UrlDecode, base64UrlEncode } from "../base64Url";
+import { tokenSchema } from "../schema/index.js";
+import { formatCause } from "../error.js";
+import { base64UrlDecode, base64UrlEncode } from "../base64Url.js";
 const _Token = class _Token {
   constructor(headers, payload, signature = "") {
     this.headers = headers;
@@ -212,4 +212,3 @@ export {
   FixedTokenProvider,
   Token
 };
-//# sourceMappingURL=token.js.map

package/tracker.cjs

@@ -20,9 +20,9 @@ __export(tracker_exports, {
   Tracker: () => Tracker
 });
 module.exports = __toCommonJS(tracker_exports);
-var import_logging = require("./logging");
-var import_error = require("./error");
-var import_trackingEvents = require("./trackingEvents");
+var import_logging = require('./logging/index.cjs');
+var import_error = require('./error.cjs');
+var import_trackingEvents = require('./trackingEvents.cjs');
 const trackedEvents = {};
 class Tracker {
   constructor(config) {
@@ -355,4 +355,3 @@ class Tracker {
 0 && (module.exports = {
   Tracker
 });
-//# sourceMappingURL=tracker.cjs.map

package/tracker.d.cts

@@ -0,0 +1,82 @@
+import { Logger } from './logging/logger.cjs';
+import { Tab } from './tab.cjs';
+import { OutputChannel } from './channel/channel.cjs';
+import { RetryPolicy } from './retry/policy.cjs';
+import { Token, TokenProvider } from './token/token.cjs';
+import { TrackingEvent, TrackingEventContext, Beacon, PartialTrackingEvent } from './trackingEvents.cjs';
+import './eventManager.cjs';
+import '@croct/json';
+import './apiKey.cjs';
+import './patch.cjs';
+import './utilityTypes.cjs';
+
+type Options = {
+    eventMetadata?: {
+        [key: string]: string;
+    };
+};
+type Configuration = Options & {
+    channel: OutputChannel<Beacon>;
+    logger?: Logger;
+    tab: Tab;
+    tokenProvider: TokenProvider;
+    processor?: TrackingEventProcessor;
+    inactivityRetryPolicy: RetryPolicy<number>;
+};
+interface TrackingEventProcessor {
+    process(event: QueuedEventInfo): QueuedEventInfo[];
+}
+type QueuedEventInfo<T extends TrackingEvent = TrackingEvent> = Omit<EventInfo<T>, 'status'>;
+type EventInfo<T extends TrackingEvent = TrackingEvent> = {
+    context: TrackingEventContext;
+    userToken?: Token;
+    event: T;
+    timestamp: number;
+    status: 'pending' | 'confirmed' | 'failed' | 'ignored';
+};
+interface EventListener {
+    (event: EventInfo): void;
+}
+declare class Tracker {
+    private readonly options;
+    private tab;
+    private tokenProvider;
+    private inactivityRetryPolicy;
+    private readonly channel;
+    private readonly logger;
+    private readonly processor?;
+    private readonly listeners;
+    private readonly pending;
+    private readonly state;
+    private readonly inactivityTimer;
+    constructor(config: Configuration);
+    addListener(listener: EventListener): void;
+    removeListener(listener: EventListener): void;
+    get flushed(): Promise<void>;
+    isEnabled(): boolean;
+    isSuspended(): boolean;
+    enable(): void;
+    disable(): void;
+    suspend(): void;
+    unsuspend(): void;
+    private initialize;
+    private stopInactivityTimer;
+    private startInactivityTimer;
+    track<T extends PartialTrackingEvent>(event: T, timestamp?: number): Promise<T>;
+    private trackPageOpen;
+    private trackPageLoad;
+    private trackTabOpen;
+    private trackTabUrlChange;
+    private trackTabVisibilityChange;
+    private trackInactivity;
+    private enqueue;
+    private notifyEvent;
+    private dispatch;
+    private publish;
+    private enrichEvent;
+    private createBeacon;
+    private createBeaconPayload;
+    private enrichBeaconPayload;
+}
+
+export { type Configuration, type EventInfo, type EventListener, type QueuedEventInfo, Tracker, type TrackingEventProcessor };

package/tracker.js

@@ -1,9 +1,9 @@
-import { NullLogger } from "./logging";
-import { formatCause } from "./error";
+import { NullLogger } from "./logging/index.js";
+import { formatCause } from "./error.js";
 import {
   isCartPartialEvent,
   isIdentifiedUserEvent
-} from "./trackingEvents";
+} from "./trackingEvents.js";
 const trackedEvents = {};
 class Tracker {
   constructor(config) {
@@ -335,4 +335,3 @@ class Tracker {
 export {
   Tracker
 };
-//# sourceMappingURL=tracker.js.map

package/trackingEvents.cjs

@@ -91,4 +91,3 @@ function isCartPartialEvent(event) {
   tabEventTypes,
   userEventTypes
 });
-//# sourceMappingURL=trackingEvents.cjs.map