@croct/sdk 0.17.12 → 0.18.0

package/cid/index.cjs

@@ -23,14 +23,14 @@ __export(cid_exports, {
   RemoteAssigner: () => import_remoteAssigner.RemoteAssigner
 });
 module.exports = __toCommonJS(cid_exports);
-__reExport(cid_exports, require("./assigner"), module.exports);
-var import_cachedAssigner = require("./cachedAssigner");
-var import_fixedAssigner = require("./fixedAssigner");
-var import_remoteAssigner = require("./remoteAssigner");
+__reExport(cid_exports, require('./assigner.cjs'), module.exports);
+var import_cachedAssigner = require('./cachedAssigner.cjs');
+var import_fixedAssigner = require('./fixedAssigner.cjs');
+var import_remoteAssigner = require('./remoteAssigner.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CachedAssigner,
   FixedAssigner,
   RemoteAssigner,
-  ...require("./assigner")
+  ...require('./assigner.cjs')
 });

package/cid/index.d.cts

@@ -0,0 +1,6 @@
+export { CidAssigner } from './assigner.cjs';
+export { CachedAssigner } from './cachedAssigner.cjs';
+export { FixedAssigner } from './fixedAssigner.cjs';
+export { RemoteAssigner } from './remoteAssigner.cjs';
+import '../logging/logger.cjs';
+import '../cache/cache.cjs';

package/cid/index.js

@@ -1,7 +1,7 @@
-export * from "./assigner";
-import { CachedAssigner } from "./cachedAssigner";
-import { FixedAssigner } from "./fixedAssigner";
-import { RemoteAssigner } from "./remoteAssigner";
+export * from "./assigner.js";
+import { CachedAssigner } from "./cachedAssigner.js";
+import { FixedAssigner } from "./fixedAssigner.js";
+import { RemoteAssigner } from "./remoteAssigner.js";
 export {
   CachedAssigner,
   FixedAssigner,

package/cid/remoteAssigner.cjs

@@ -20,9 +20,9 @@ __export(remoteAssigner_exports, {
   RemoteAssigner: () => RemoteAssigner
 });
 module.exports = __toCommonJS(remoteAssigner_exports);
-var import_logging = require("../logging");
-var import_error = require("../error");
-var import_constants = require("../constants");
+var import_logging = require('../logging/index.cjs');
+var import_error = require('../error.cjs');
+var import_constants = require('../constants.cjs');
 class RemoteAssigner {
   constructor(endpoint, logger) {
     this.endpoint = endpoint;

package/cid/remoteAssigner.d.cts

@@ -0,0 +1,13 @@
+import { Logger } from '../logging/logger.cjs';
+import { CidAssigner } from './assigner.cjs';
+
+declare class RemoteAssigner implements CidAssigner {
+    private readonly logger;
+    private readonly endpoint;
+    private pending?;
+    constructor(endpoint: string, logger?: Logger);
+    assignCid(currentCid?: string): Promise<string>;
+    private fetchCid;
+}
+
+export { RemoteAssigner };

package/cid/remoteAssigner.js

@@ -1,6 +1,6 @@
-import { NullLogger } from "../logging";
-import { formatCause } from "../error";
-import { CLIENT_LIBRARY } from "../constants";
+import { NullLogger } from "../logging/index.js";
+import { formatCause } from "../error.js";
+import { CLIENT_LIBRARY } from "../constants.js";
 class RemoteAssigner {
   constructor(endpoint, logger) {
     this.endpoint = endpoint;

package/constants.cjs

@@ -25,7 +25,7 @@ __export(constants_exports, {
 module.exports = __toCommonJS(constants_exports);
 const BASE_ENDPOINT_URL = "https://api.croct.io";
 const MAX_QUERY_LENGTH = parseInt("<@maxQueryLength@>", 10);
-const VERSION = "0.17.12";
+const VERSION = "0.18.0";
 const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/constants.d.cts

@@ -0,0 +1,6 @@
+declare const BASE_ENDPOINT_URL = "https://api.croct.io";
+declare const MAX_QUERY_LENGTH: number;
+declare const VERSION = "0.18.0";
+declare const CLIENT_LIBRARY = "Croct SDK JS v0.18.0";
+
+export { BASE_ENDPOINT_URL, CLIENT_LIBRARY, MAX_QUERY_LENGTH, VERSION };

package/constants.d.ts

@@ -1,6 +1,6 @@
 declare const BASE_ENDPOINT_URL = "https://api.croct.io";
 declare const MAX_QUERY_LENGTH: number;
-declare const VERSION = "0.17.12";
-declare const CLIENT_LIBRARY = "Croct SDK JS v0.17.12";
+declare const VERSION = "0.18.0";
+declare const CLIENT_LIBRARY = "Croct SDK JS v0.18.0";
 
 export { BASE_ENDPOINT_URL, CLIENT_LIBRARY, MAX_QUERY_LENGTH, VERSION };

package/constants.js

@@ -1,6 +1,6 @@
 const BASE_ENDPOINT_URL = "https://api.croct.io";
 const MAX_QUERY_LENGTH = parseInt("<@maxQueryLength@>", 10);
-const VERSION = "0.17.12";
+const VERSION = "0.18.0";
 const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;
 export {
   BASE_ENDPOINT_URL,

package/container.cjs

@@ -20,24 +20,24 @@ __export(container_exports, {
   Container: () => Container
 });
 module.exports = __toCommonJS(container_exports);
-var import_logging = require("./logging");
-var import_context = require("./context");
-var import_namespacedStorage = require("./namespacedStorage");
-var import_retry = require("./retry");
-var import_queue = require("./queue");
-var import_token = require("./token");
-var import_tracker = require("./tracker");
-var import_evaluator = require("./evaluator");
-var import_transformer = require("./transformer");
-var import_cid = require("./cid");
-var import_eventManager = require("./eventManager");
-var import_cache = require("./cache");
-var import_guaranteedChannel = require("./channel/guaranteedChannel");
-var import_channel = require("./channel");
-var import_contentFetcher = require("./contentFetcher");
-var import_cookieCache = require("./cache/cookieCache");
-var import_filteredLogger = require("./logging/filteredLogger");
-var import_httpBeaconChannel = require("./channel/httpBeaconChannel");
+var import_logging = require('./logging/index.cjs');
+var import_context = require('./context.cjs');
+var import_namespacedStorage = require('./namespacedStorage.cjs');
+var import_retry = require('./retry/index.cjs');
+var import_queue = require('./queue/index.cjs');
+var import_token = require('./token/index.cjs');
+var import_tracker = require('./tracker.cjs');
+var import_evaluator = require('./evaluator.cjs');
+var import_transformer = require('./transformer.cjs');
+var import_cid = require('./cid/index.cjs');
+var import_eventManager = require('./eventManager.cjs');
+var import_cache = require('./cache/index.cjs');
+var import_guaranteedChannel = require('./channel/guaranteedChannel.cjs');
+var import_channel = require('./channel/index.cjs');
+var import_contentFetcher = require('./contentFetcher.cjs');
+var import_cookieCache = require('./cache/cookieCache.cjs');
+var import_filteredLogger = require('./logging/filteredLogger.cjs');
+var import_httpBeaconChannel = require('./channel/httpBeaconChannel.cjs');
 const _Container = class _Container {
   constructor(configuration) {
     this.eventManager = new import_eventManager.SynchronousEventManager();

package/container.d.cts

@@ -0,0 +1,95 @@
+import { Logger } from './logging/logger.cjs';
+import { TokenScope, Context } from './context.cjs';
+import { MonitoredQueue } from './queue/monitoredQueue.cjs';
+import { TokenStore } from './token/token.cjs';
+import { TrackingEventProcessor, Tracker } from './tracker.cjs';
+import { Evaluator } from './evaluator.cjs';
+import { CidAssigner } from './cid/assigner.cjs';
+import { EventManager } from './eventManager.cjs';
+import { SdkEventMap } from './sdkEvents.cjs';
+import { UrlSanitizer } from './tab.cjs';
+import { ContentFetcher } from './contentFetcher.cjs';
+import { CookieCacheConfiguration } from './cache/cookieCache.cjs';
+import './cache/cache.cjs';
+import './queue/queue.cjs';
+import '@croct/json';
+import './apiKey.cjs';
+import './channel/channel.cjs';
+import './retry/policy.cjs';
+import './trackingEvents.cjs';
+import './patch.cjs';
+import './utilityTypes.cjs';
+import './sourceLocation.cjs';
+
+type DependencyResolver<T> = (container: Container) => T;
+type Configuration = {
+    appId: string;
+    tokenScope: TokenScope;
+    clientId?: string;
+    debug: boolean;
+    test: boolean;
+    disableCidMirroring: boolean;
+    cidAssignerEndpointUrl: string;
+    trackerEndpointUrl: string;
+    evaluationBaseEndpointUrl: string;
+    contentBaseEndpointUrl: string;
+    beaconQueueSize: number;
+    logger?: Logger;
+    urlSanitizer?: UrlSanitizer;
+    cookie?: {
+        clientId?: CookieCacheConfiguration;
+        userToken?: CookieCacheConfiguration;
+        previewToken?: CookieCacheConfiguration;
+    };
+    eventMetadata?: {
+        [key: string]: string;
+    };
+    eventProcessor?: DependencyResolver<TrackingEventProcessor>;
+    defaultFetchTimeout?: number;
+    defaultPreferredLocale?: string;
+};
+declare class Container {
+    static readonly DEFAULT_FETCH_TIMEOUT = 5000;
+    private readonly configuration;
+    private context?;
+    private userTokenProvider?;
+    private previewTokenStore?;
+    private tracker?;
+    private evaluator?;
+    private contentFetcher?;
+    private cidAssigner?;
+    private beaconChannel?;
+    private beaconQueue?;
+    private removeTokenSyncListener?;
+    private readonly eventManager;
+    constructor(configuration: Configuration);
+    getConfiguration(): Configuration;
+    getEvaluator(): Evaluator;
+    private createEvaluator;
+    getContentFetcher(): ContentFetcher;
+    private createContentFetcher;
+    getPreviewTokenStore(): TokenStore;
+    getTracker(): Tracker;
+    private createTracker;
+    getUserTokenStore(): TokenStore;
+    getContext(): Context;
+    private createContext;
+    private getBeaconChannel;
+    private createBeaconChannel;
+    getCidAssigner(): CidAssigner;
+    private createCidAssigner;
+    getBeaconQueue(): MonitoredQueue<string>;
+    private createBeaconQueue;
+    getLogger(...namespace: string[]): Logger;
+    getTabStorage(namespace: string, ...subnamespace: string[]): Storage;
+    getBrowserStorage(namespace: string, ...subnamespace: string[]): Storage;
+    private getGlobalTabStorage;
+    private getGlobalBrowserStorage;
+    private resolveStorageNamespace;
+    private getLocalStorage;
+    private getSessionStorage;
+    getEventManager(): EventManager<SdkEventMap>;
+    dispose(): Promise<void>;
+}
+
+export { type Configuration, Container, type DependencyResolver };

package/container.js

@@ -1,27 +1,27 @@
-import { ConsoleLogger, NamespacedLogger } from "./logging";
-import { Context } from "./context";
-import { NamespacedStorage } from "./namespacedStorage";
-import { BackoffPolicy, ArbitraryPolicy } from "./retry";
-import { PersistentQueue, MonitoredQueue, CapacityRestrictedQueue } from "./queue";
-import { CachedTokenStore } from "./token";
-import { Tracker } from "./tracker";
-import { Evaluator } from "./evaluator";
-import { encodeJson } from "./transformer";
-import { CachedAssigner, RemoteAssigner, FixedAssigner } from "./cid";
-import { SynchronousEventManager } from "./eventManager";
-import { LocalStorageCache } from "./cache";
-import { TimeStamper } from "./channel/guaranteedChannel";
+import { ConsoleLogger, NamespacedLogger } from "./logging/index.js";
+import { Context } from "./context.js";
+import { NamespacedStorage } from "./namespacedStorage.js";
+import { BackoffPolicy, ArbitraryPolicy } from "./retry/index.js";
+import { PersistentQueue, MonitoredQueue, CapacityRestrictedQueue } from "./queue/index.js";
+import { CachedTokenStore } from "./token/index.js";
+import { Tracker } from "./tracker.js";
+import { Evaluator } from "./evaluator.js";
+import { encodeJson } from "./transformer.js";
+import { CachedAssigner, RemoteAssigner, FixedAssigner } from "./cid/index.js";
+import { SynchronousEventManager } from "./eventManager.js";
+import { LocalStorageCache } from "./cache/index.js";
+import { TimeStamper } from "./channel/guaranteedChannel.js";
 import {
   QueuedChannel,
   RetryChannel,
   GuaranteedChannel,
   EncodedChannel,
   SandboxChannel
-} from "./channel";
-import { ContentFetcher } from "./contentFetcher";
-import { CookieCache } from "./cache/cookieCache";
-import { FilteredLogger } from "./logging/filteredLogger";
-import { HttpBeaconChannel } from "./channel/httpBeaconChannel";
+} from "./channel/index.js";
+import { ContentFetcher } from "./contentFetcher.js";
+import { CookieCache } from "./cache/cookieCache.js";
+import { FilteredLogger } from "./logging/filteredLogger.js";
+import { HttpBeaconChannel } from "./channel/httpBeaconChannel.js";
 const _Container = class _Container {
   constructor(configuration) {
     this.eventManager = new SynchronousEventManager();

package/contentFetcher.cjs

@@ -22,10 +22,10 @@ __export(contentFetcher_exports, {
   ContentFetcher: () => ContentFetcher
 });
 module.exports = __toCommonJS(contentFetcher_exports);
-var import_constants = require("./constants");
-var import_error = require("./error");
-var import_logging = require("./logging");
-var import_help = require("./help");
+var import_constants = require('./constants.cjs');
+var import_error = require('./error.cjs');
+var import_logging = require('./logging/index.cjs');
+var import_help = require('./help.cjs');
 var ContentErrorType = /* @__PURE__ */ ((ContentErrorType2) => {
   ContentErrorType2["TIMEOUT"] = "https://croct.help/api/content#timeout";
   ContentErrorType2["UNEXPECTED_ERROR"] = "https://croct.help/api/content#unexpected-error";

package/contentFetcher.d.cts

@@ -0,0 +1,69 @@
+import { JsonObject } from '@croct/json';
+import { EvaluationContext } from './evaluator.cjs';
+import { Token } from './token/token.cjs';
+import { Logger } from './logging/logger.cjs';
+import { ApiKey } from './apiKey.cjs';
+import './sourceLocation.cjs';
+
+type ErrorResponse = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+};
+declare enum ContentErrorType {
+    TIMEOUT = "https://croct.help/api/content#timeout",
+    UNEXPECTED_ERROR = "https://croct.help/api/content#unexpected-error"
+}
+declare class ContentError<T extends ErrorResponse = ErrorResponse> extends Error {
+    readonly response: T;
+    constructor(response: T);
+}
+type BasicOptions = {
+    version?: `${number}` | number;
+    preferredLocale?: string;
+    timeout?: number;
+    extra?: ExtraFetchOptions;
+};
+type StaticContentOptions = BasicOptions & {
+    static: true;
+};
+type DynamicContentOptions = BasicOptions & {
+    static?: false;
+    clientId?: string;
+    clientIp?: string;
+    clientAgent?: string;
+    userToken?: Token | string;
+    previewToken?: Token | string;
+    context?: EvaluationContext;
+};
+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>;
+type FetchOptions = StaticContentOptions | DynamicContentOptions;
+type FetchResponse<P extends JsonObject = JsonObject> = {
+    content: P;
+};
+type Configuration = {
+    appId?: string;
+    apiKey?: string | ApiKey;
+    baseEndpointUrl?: string;
+    logger?: Logger;
+    defaultTimeout?: number;
+    defaultPreferredLocale?: string;
+};
+declare class ContentFetcher {
+    private readonly configuration;
+    private readonly dynamicEndpoint;
+    private readonly staticEndpoint;
+    private readonly logger;
+    constructor(configuration: Configuration);
+    fetch<P extends JsonObject>(slotId: string, options?: FetchOptions): Promise<FetchResponse<P>>;
+    private load;
+    private logHelp;
+    private static isDynamicContent;
+    toJSON(): never;
+}
+
+export { type Configuration, ContentError, ContentErrorType, ContentFetcher, type DynamicContentOptions, type ErrorResponse, type FetchOptions, type FetchResponse, type StaticContentOptions };

package/contentFetcher.js

@@ -1,7 +1,7 @@
-import { BASE_ENDPOINT_URL, CLIENT_LIBRARY } from "./constants";
-import { formatMessage } from "./error";
-import { NullLogger } from "./logging";
-import { Help } from "./help";
+import { BASE_ENDPOINT_URL, CLIENT_LIBRARY } from "./constants.js";
+import { formatMessage } from "./error.js";
+import { NullLogger } from "./logging/index.js";
+import { Help } from "./help.js";
 var ContentErrorType = /* @__PURE__ */ ((ContentErrorType2) => {
   ContentErrorType2["TIMEOUT"] = "https://croct.help/api/content#timeout";
   ContentErrorType2["UNEXPECTED_ERROR"] = "https://croct.help/api/content#unexpected-error";

package/context.cjs

@@ -20,10 +20,10 @@ __export(context_exports, {
   Context: () => Context
 });
 module.exports = __toCommonJS(context_exports);
-var import_token = require("./token");
-var import_tab = require("./tab");
-var import_uuid = require("./uuid");
-var import_cache = require("./cache");
+var import_token = require('./token/index.cjs');
+var import_tab = require('./tab.cjs');
+var import_uuid = require('./uuid.cjs');
+var import_cache = require('./cache/index.cjs');
 function tokenEquals(left, right) {
   return left === right || left !== null && right !== null && left.toString() === right.toString();
 }

package/context.d.cts

@@ -0,0 +1,36 @@
+import { Token } from './token/token.cjs';
+import { Cache } from './cache/cache.cjs';
+import { UrlSanitizer, Tab } from './tab.cjs';
+import { EventDispatcher } from './eventManager.cjs';
+import { SdkEventMap } from './sdkEvents.cjs';
+import '@croct/json';
+import './apiKey.cjs';
+
+type TokenScope = 'isolated' | 'global' | 'contextual';
+type Configuration = {
+    tokenScope: TokenScope;
+    urlSanitizer?: UrlSanitizer;
+    eventDispatcher: ContextEventDispatcher;
+    cache: {
+        tabId: Cache;
+        tabToken: Cache;
+        browserToken: Cache;
+    };
+};
+type ContextEventDispatcher = EventDispatcher<Pick<SdkEventMap, 'tokenChanged'>>;
+declare class Context {
+    private readonly tab;
+    private readonly tokenStore;
+    private readonly eventDispatcher;
+    private lastToken;
+    private constructor();
+    static load({ cache, tokenScope, eventDispatcher, urlSanitizer }: Configuration): Context;
+    getTab(): Tab;
+    isAnonymous(): boolean;
+    getUser(): string | null;
+    getToken(): Token | null;
+    setToken(token: Token | null): void;
+    private syncToken;
+}
+
+export { type Configuration, Context, type TokenScope };

package/context.js

@@ -1,7 +1,7 @@
-import { CachedTokenStore, ReplicatedTokenStore, InMemoryTokenStore } from "./token";
-import { Tab } from "./tab";
-import { uuid4 } from "./uuid";
-import { ObservableCache } from "./cache";
+import { CachedTokenStore, ReplicatedTokenStore, InMemoryTokenStore } from "./token/index.js";
+import { Tab } from "./tab.js";
+import { uuid4 } from "./uuid.js";
+import { ObservableCache } from "./cache/index.js";
 function tokenEquals(left, right) {
   return left === right || left !== null && right !== null && left.toString() === right.toString();
 }

package/error.d.cts

@@ -0,0 +1,4 @@
+declare function formatMessage(error: unknown): string;
+declare function formatCause(error: unknown): string;
+
+export { formatCause, formatMessage };

package/evaluator.cjs

@@ -23,11 +23,11 @@ __export(evaluator_exports, {
   QueryError: () => QueryError
 });
 module.exports = __toCommonJS(evaluator_exports);
-var import_constants = require("./constants");
-var import_error = require("./error");
-var import_sourceLocation = require("./sourceLocation");
-var import_logging = require("./logging");
-var import_help = require("./help");
+var import_constants = require('./constants.cjs');
+var import_error = require('./error.cjs');
+var import_sourceLocation = require('./sourceLocation.cjs');
+var import_logging = require('./logging/index.cjs');
+var import_help = require('./help.cjs');
 var EvaluationErrorType = /* @__PURE__ */ ((EvaluationErrorType2) => {
   EvaluationErrorType2["TIMEOUT"] = "https://croct.help/api/evaluation#timeout";
   EvaluationErrorType2["UNEXPECTED_ERROR"] = "https://croct.help/api/evaluation#unexpected-error";

package/evaluator.d.cts

@@ -0,0 +1,86 @@
+import { JsonObject, JsonValue } from '@croct/json';
+import { Token } from './token/token.cjs';
+import { Location } from './sourceLocation.cjs';
+import { Logger } from './logging/logger.cjs';
+import { ApiKey } from './apiKey.cjs';
+
+type Campaign = {
+    name?: string;
+    source?: string;
+    medium?: string;
+    term?: string;
+    content?: string;
+};
+type Page = {
+    url: string;
+    title?: string;
+    referrer?: string;
+};
+type EvaluationContext = {
+    timeZone?: string;
+    campaign?: Campaign;
+    page?: Page;
+    attributes?: JsonObject;
+};
+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>;
+type EvaluationOptions = {
+    clientId?: string;
+    clientIp?: string;
+    clientAgent?: string;
+    userToken?: Token | string;
+    timeout?: number;
+    context?: EvaluationContext;
+    extra?: ExtraFetchOptions;
+};
+declare enum EvaluationErrorType {
+    TIMEOUT = "https://croct.help/api/evaluation#timeout",
+    UNEXPECTED_ERROR = "https://croct.help/api/evaluation#unexpected-error",
+    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"
+}
+type ErrorResponse = {
+    type: EvaluationErrorType;
+    title: string;
+    status: number;
+    detail?: string;
+};
+declare class EvaluationError<T extends ErrorResponse = ErrorResponse> extends Error {
+    readonly response: T;
+    constructor(response: T);
+}
+type QueryErrorDetail = {
+    cause: string;
+    location: Location;
+};
+type QueryErrorResponse = ErrorResponse & {
+    errors: QueryErrorDetail[];
+};
+declare class QueryError extends EvaluationError<QueryErrorResponse> {
+    constructor(response: QueryErrorResponse);
+}
+type Configuration = {
+    appId?: string;
+    apiKey?: string | ApiKey;
+    baseEndpointUrl?: string;
+    logger?: Logger;
+    defaultTimeout?: number;
+};
+declare class Evaluator {
+    static readonly MAX_QUERY_LENGTH: number;
+    private readonly configuration;
+    private readonly endpoint;
+    private readonly logger;
+    constructor(configuration: Configuration);
+    evaluate(query: string, options?: EvaluationOptions): Promise<JsonValue>;
+    private fetch;
+    private logHelp;
+    toJSON(): never;
+}
+
+export { type Campaign, type Configuration, type ErrorResponse, type EvaluationContext, EvaluationError, EvaluationErrorType, type EvaluationOptions, Evaluator, type Page, QueryError, type QueryErrorResponse };

package/evaluator.js

@@ -1,8 +1,8 @@
-import { BASE_ENDPOINT_URL, CLIENT_LIBRARY, MAX_QUERY_LENGTH } from "./constants";
-import { formatMessage } from "./error";
-import { getLength, getLocation } from "./sourceLocation";
-import { NullLogger } from "./logging";
-import { Help } from "./help";
+import { BASE_ENDPOINT_URL, CLIENT_LIBRARY, MAX_QUERY_LENGTH } from "./constants.js";
+import { formatMessage } from "./error.js";
+import { getLength, getLocation } from "./sourceLocation.js";
+import { NullLogger } from "./logging/index.js";
+import { Help } from "./help.js";
 var EvaluationErrorType = /* @__PURE__ */ ((EvaluationErrorType2) => {
   EvaluationErrorType2["TIMEOUT"] = "https://croct.help/api/evaluation#timeout";
   EvaluationErrorType2["UNEXPECTED_ERROR"] = "https://croct.help/api/evaluation#unexpected-error";

package/eventManager.d.cts

@@ -0,0 +1,21 @@
+interface EventListener<T> {
+    (event: T): void;
+}
+type EventMap = Record<string, Record<string, any>>;
+interface EventDispatcher<TEvents extends EventMap> {
+    dispatch<T extends keyof TEvents>(eventName: T, event: TEvents[T]): void;
+}
+interface EventSubscriber<TEvents extends EventMap> {
+    addListener<T extends keyof TEvents>(eventName: T, listener: EventListener<TEvents[T]>): void;
+    removeListener<T extends keyof TEvents>(eventName: T, listener: EventListener<TEvents[T]>): void;
+}
+interface EventManager<DEvents extends EventMap, SEvents extends EventMap = DEvents> extends EventDispatcher<DEvents>, EventSubscriber<SEvents> {
+}
+declare class SynchronousEventManager<TEvents extends EventMap> implements EventManager<TEvents> {
+    private readonly listeners;
+    addListener<T extends keyof TEvents>(type: T, listener: EventListener<TEvents[T]>): void;
+    removeListener<T extends keyof TEvents>(eventName: T, listener: EventListener<TEvents[T]>): void;
+    dispatch<T extends keyof TEvents>(eventName: T, event: TEvents[T]): void;
+}
+
+export { type EventDispatcher, type EventListener, type EventManager, type EventMap, type EventSubscriber, SynchronousEventManager };

package/eventSubjectProcessor.d.cts

@@ -0,0 +1,22 @@
+import { TrackingEventProcessor, QueuedEventInfo } from './tracker.cjs';
+import { Logger } from './logging/logger.cjs';
+import './tab.cjs';
+import './eventManager.cjs';
+import './channel/channel.cjs';
+import './retry/policy.cjs';
+import './token/token.cjs';
+import '@croct/json';
+import './apiKey.cjs';
+import './trackingEvents.cjs';
+import './patch.cjs';
+import './utilityTypes.cjs';
+
+declare class EventSubjectProcessor implements TrackingEventProcessor {
+    private currentToken?;
+    private logger;
+    constructor(logger: Logger);
+    process(event: QueuedEventInfo): QueuedEventInfo[];
+    private static isIdentificationEvent;
+}
+
+export { EventSubjectProcessor };