@capture.dev/event-logger 0.0.1

package/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (c) 2026 Capture.dev
+
+All rights reserved.
+
+This software is made available for use by Capture.dev customers.
+Unauthorized copying, modification, distribution, or use of this software
+is strictly prohibited.

package/dist/event-logger.d.ts

@@ -0,0 +1,25 @@
+import type { EventSink } from "./event-sink.js";
+import type { SerializedValue } from "./to-json/serialized-types.js";
+export type BaseEvent = {
+    time: number;
+    [key: string]: SerializedValue | undefined;
+};
+export type EventLoggerType = "state" | "events";
+export type EventLoggerMeta = {
+    identifier: string;
+    name?: string;
+    version?: number;
+};
+export declare class EventLogger<EventType extends BaseEvent = BaseEvent> {
+    type: EventLoggerType;
+    private sinks;
+    private queue;
+    private errorQueue;
+    meta: EventLoggerMeta;
+    initialize(meta: EventLoggerMeta): void;
+    registerSink(sink: EventSink): void;
+    logEvent: (event: EventType) => void;
+    logInternalError: (error: unknown) => void;
+    start(): void;
+}
+//# sourceMappingURL=event-logger.d.ts.map

package/dist/event-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-logger.d.ts","sourceRoot":"","sources":["../src/event-logger.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEjD,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,qBAAa,WAAW,CAAC,SAAS,SAAS,SAAS,GAAG,SAAS;IAC9D,IAAI,EAAE,eAAe,CAAY;IAEjC,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,UAAU,CAAiB;IAE5B,IAAI,EAAE,eAAe,CAE1B;IAEF,UAAU,CAAC,IAAI,EAAE,eAAe;IAOhC,YAAY,CAAC,IAAI,EAAE,SAAS;IAU5B,QAAQ,GAAI,OAAO,SAAS,UAM1B;IAEF,gBAAgB,GAAI,OAAO,OAAO,UAMhC;IAEF,KAAK;CAGN"}

package/dist/event-logger.js

@@ -0,0 +1,42 @@
+import { getGlobalSinks } from "./global-state.js";
+export class EventLogger {
+    type = "events";
+    sinks = [];
+    queue = [];
+    errorQueue = [];
+    meta = {
+        identifier: "events",
+    };
+    initialize(meta) {
+        this.meta = meta;
+        getGlobalSinks().forEach((sink) => {
+            this.registerSink(sink);
+        });
+    }
+    registerSink(sink) {
+        this.sinks.push(sink);
+        this.queue.forEach((item) => {
+            sink.log(this.type, this.meta, item);
+        });
+        this.errorQueue.forEach((error) => {
+            sink.logInternalError(this.type, this.meta, error);
+        });
+    }
+    logEvent = (event) => {
+        this.sinks.forEach((sink) => {
+            sink.log(this.type, this.meta, event);
+        });
+        this.queue.push(event);
+        this.queue = this.queue.slice(-250);
+    };
+    logInternalError = (error) => {
+        this.sinks.forEach((sink) => {
+            sink.logInternalError(this.type, this.meta, error);
+        });
+        this.errorQueue.push(error);
+        this.errorQueue = this.errorQueue.slice(-50);
+    };
+    start() {
+        // Override in subclasses
+    }
+}

package/dist/event-sink.d.ts

@@ -0,0 +1,11 @@
+import type { BaseEvent, EventLoggerMeta, EventLoggerType } from "./event-logger.js";
+/**
+ * Base EventSink class used to register loggers and forward events to storage.
+ * The base sink does not implement any storage itself.
+ */
+export declare class EventSink {
+    constructor();
+    log(_loggerType: EventLoggerType, _loggerMeta: EventLoggerMeta, _event: BaseEvent): void;
+    logInternalError: (loggerType: EventLoggerType, loggerMeta: EventLoggerMeta, error: unknown) => void;
+}
+//# sourceMappingURL=event-sink.d.ts.map

package/dist/event-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-sink.d.ts","sourceRoot":"","sources":["../src/event-sink.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,SAAS,EACT,eAAe,EACf,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B;;;GAGG;AACH,qBAAa,SAAS;;IAYpB,GAAG,CACD,WAAW,EAAE,eAAe,EAC5B,WAAW,EAAE,eAAe,EAC5B,MAAM,EAAE,SAAS;IAKnB,gBAAgB,GACd,YAAY,eAAe,EAC3B,YAAY,eAAe,EAC3B,OAAO,OAAO,UAed;CACH"}

package/dist/event-sink.js

@@ -0,0 +1,32 @@
+import { getGlobalLoggers, getGlobalSinks } from "./global-state.js";
+import { toJSON } from "./to-json/to-json.js";
+/**
+ * Base EventSink class used to register loggers and forward events to storage.
+ * The base sink does not implement any storage itself.
+ */
+export class EventSink {
+    constructor() {
+        // Registering a sink will cause the logger to call methods on this sink.  Timeout is
+        // necessary to allow the constructor to complete so those methods are available.
+        setTimeout(() => {
+            getGlobalSinks().add(this);
+            getGlobalLoggers().forEach((logger) => {
+                logger.registerSink(this);
+            });
+        }, 0);
+    }
+    log(_loggerType, _loggerMeta, _event) {
+        throw new Error("Method not implemented.");
+    }
+    logInternalError = (loggerType, loggerMeta, error) => {
+        if (error instanceof Error) {
+            this.log("events", { identifier: "__internal__" }, {
+                time: Date.now(),
+                type: "internal-error",
+                loggerType,
+                loggerMeta,
+                error: toJSON(error),
+            });
+        }
+    };
+}

package/dist/global-state.d.ts

@@ -0,0 +1,14 @@
+import type { EventLogger } from "./event-logger.js";
+import type { EventSink } from "./event-sink.js";
+type LoggerMap = Map<string, EventLogger>;
+type SinkSet = Set<EventSink>;
+export interface CaptureGlobalState {
+    browserClientInitialized?: boolean;
+    loggers?: LoggerMap;
+    sinks?: SinkSet;
+}
+export declare const getGlobalState: () => CaptureGlobalState;
+export declare const getGlobalLoggers: () => LoggerMap;
+export declare const getGlobalSinks: () => SinkSet;
+export {};
+//# sourceMappingURL=global-state.d.ts.map

package/dist/global-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-state.d.ts","sourceRoot":"","sources":["../src/global-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,KAAK,SAAS,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;AAC1C,KAAK,OAAO,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC;AAE9B,MAAM,WAAW,kBAAkB;IACjC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,eAAO,MAAM,cAAc,QAAO,kBASjC,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAO,SAQnC,CAAC;AAEF,eAAO,MAAM,cAAc,QAAO,OAQjC,CAAC"}

package/dist/global-state.js

@@ -0,0 +1,28 @@
+export const getGlobalState = () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let state = window.__capture;
+    if (!state) {
+        state = {};
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        window.__capture = state;
+    }
+    return state;
+};
+export const getGlobalLoggers = () => {
+    const state = getGlobalState();
+    let loggers = state.loggers;
+    if (!loggers) {
+        loggers = new Map();
+        state.loggers = loggers;
+    }
+    return loggers;
+};
+export const getGlobalSinks = () => {
+    const state = getGlobalState();
+    let sinks = state.sinks;
+    if (!sinks) {
+        sinks = new Set();
+        state.sinks = sinks;
+    }
+    return sinks;
+};

package/dist/index-internal.d.ts

@@ -0,0 +1,20 @@
+export { internalRegisterEventLogger } from "./register-logger.js";
+export { ACTIVITY_LOGGER_IDENTIFIER } from "./register-logger.js";
+export { STATE_LOGGER_SNAPSHOT_INTERVAL, type StatePatchEvent, type StateSnapshotEvent, type StateEvent, } from "./state-logger.js";
+export type { EventLoggerType } from "./event-logger.js";
+export * from "./event-sink.js";
+export * from "./global-state.js";
+export * from "./to-json/to-json.constants.js";
+export * from "./to-json/serialized-types.js";
+export * from "./to-json/serialize-error.js";
+export * from "./to-json/to-json.js";
+export * from "./snapshot-event-to-operation.js";
+export { serializeClass } from "./to-json/serialize-class.js";
+export { serializeDate } from "./to-json/serialize-date.js";
+export { serializeError } from "./to-json/serialize-error.js";
+export { serializeFunction } from "./to-json/serialize-function.js";
+export { serializeMap } from "./to-json/serialize-map.js";
+export { serializeObject } from "./to-json/serialize-object.js";
+export { serializeRegex } from "./to-json/serialize-regex.js";
+export { serializeSet } from "./to-json/serialize-set.js";
+//# sourceMappingURL=index-internal.d.ts.map

package/dist/index-internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-internal.d.ts","sourceRoot":"","sources":["../src/index-internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EACL,8BAA8B,EAC9B,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,UAAU,GAChB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC;AAEjD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/index-internal.js

@@ -0,0 +1,18 @@
+export { internalRegisterEventLogger } from "./register-logger.js";
+export { ACTIVITY_LOGGER_IDENTIFIER } from "./register-logger.js";
+export { STATE_LOGGER_SNAPSHOT_INTERVAL, } from "./state-logger.js";
+export * from "./event-sink.js";
+export * from "./global-state.js";
+export * from "./to-json/to-json.constants.js";
+export * from "./to-json/serialized-types.js";
+export * from "./to-json/serialize-error.js";
+export * from "./to-json/to-json.js";
+export * from "./snapshot-event-to-operation.js";
+export { serializeClass } from "./to-json/serialize-class.js";
+export { serializeDate } from "./to-json/serialize-date.js";
+export { serializeError } from "./to-json/serialize-error.js";
+export { serializeFunction } from "./to-json/serialize-function.js";
+export { serializeMap } from "./to-json/serialize-map.js";
+export { serializeObject } from "./to-json/serialize-object.js";
+export { serializeRegex } from "./to-json/serialize-regex.js";
+export { serializeSet } from "./to-json/serialize-set.js";

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { EventLogger, type EventLoggerMeta, type BaseEvent, } from "./event-logger.js";
+export { StateLogger } from "./state-logger.js";
+export { registerEventLogger } from "./register-logger.js";
+export * from "./register-state-logger.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,KAAK,eAAe,EACpB,KAAK,SAAS,GACf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,cAAc,4BAA4B,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { EventLogger, } from "./event-logger.js";
+export { StateLogger } from "./state-logger.js";
+export { registerEventLogger } from "./register-logger.js";
+export * from "./register-state-logger.js";

package/dist/register-logger.d.ts

@@ -0,0 +1,8 @@
+import { EventLogger } from "./event-logger.js";
+import type { BaseEvent, EventLoggerMeta } from "./event-logger.js";
+export declare function internalRegisterEventLogger<TEvent extends BaseEvent>(meta: EventLoggerMeta): EventLogger<TEvent>;
+export declare function internalRegisterEventLogger<TLogger extends EventLogger<any>>(meta: EventLoggerMeta, create: () => TLogger): TLogger;
+export declare const ACTIVITY_LOGGER_IDENTIFIER = "activity";
+export declare function registerEventLogger<TEvent extends BaseEvent>(meta: EventLoggerMeta): EventLogger<TEvent>;
+export declare function registerEventLogger<TLogger extends EventLogger<any>>(meta: EventLoggerMeta, create: () => TLogger): TLogger;
+//# sourceMappingURL=register-logger.d.ts.map

package/dist/register-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-logger.d.ts","sourceRoot":"","sources":["../src/register-logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpE,wBAAgB,2BAA2B,CAAC,MAAM,SAAS,SAAS,EAClE,IAAI,EAAE,eAAe,GACpB,WAAW,CAAC,MAAM,CAAC,CAAC;AAEvB,wBAAgB,2BAA2B,CAAC,OAAO,SAAS,WAAW,CAAC,GAAG,CAAC,EAC1E,IAAI,EAAE,eAAe,EACrB,MAAM,EAAE,MAAM,OAAO,GACpB,OAAO,CAAC;AAqBX,eAAO,MAAM,0BAA0B,aAAa,CAAC;AAErD,wBAAgB,mBAAmB,CAAC,MAAM,SAAS,SAAS,EAC1D,IAAI,EAAE,eAAe,GACpB,WAAW,CAAC,MAAM,CAAC,CAAC;AAEvB,wBAAgB,mBAAmB,CAAC,OAAO,SAAS,WAAW,CAAC,GAAG,CAAC,EAClE,IAAI,EAAE,eAAe,EACrB,MAAM,EAAE,MAAM,OAAO,GACpB,OAAO,CAAC"}

package/dist/register-logger.js

@@ -0,0 +1,24 @@
+import { EventLogger } from "./event-logger.js";
+import { getGlobalLoggers } from "./global-state.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function internalRegisterEventLogger(meta, create) {
+    const loggers = getGlobalLoggers();
+    let logger = loggers.get(meta.identifier);
+    if (!logger) {
+        logger = create ? create() : new EventLogger();
+        logger.initialize(meta);
+        logger.start();
+        loggers.set(meta.identifier, logger);
+        return logger;
+    }
+    return logger;
+}
+export const ACTIVITY_LOGGER_IDENTIFIER = "activity";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerEventLogger(meta, create) {
+    if (meta.identifier === ACTIVITY_LOGGER_IDENTIFIER) {
+        throw new Error(`${meta.identifier} is a reserved identifier. Please use an alternative for this logger.`);
+    }
+    //@ts-expect-error -- overloads ensure correct types
+    return internalRegisterEventLogger(meta, create);
+}

package/dist/register-state-logger.d.ts

@@ -0,0 +1,5 @@
+import { StateLogger } from "./state-logger.js";
+import type { StateLoggerMeta } from "./state-logger.js";
+export declare function registerStateLogger(meta: StateLoggerMeta): StateLogger;
+export declare function registerStateLogger<TLogger extends StateLogger>(meta: StateLoggerMeta, create: () => TLogger): TLogger;
+//# sourceMappingURL=register-state-logger.d.ts.map

package/dist/register-state-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-state-logger.d.ts","sourceRoot":"","sources":["../src/register-state-logger.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,WAAW,CAAC;AACxE,wBAAgB,mBAAmB,CAAC,OAAO,SAAS,WAAW,EAC7D,IAAI,EAAE,eAAe,EACrB,MAAM,EAAE,MAAM,OAAO,GACpB,OAAO,CAAC"}

package/dist/register-state-logger.js

@@ -0,0 +1,5 @@
+import { internalRegisterEventLogger } from "./register-logger.js";
+import { StateLogger } from "./state-logger.js";
+export function registerStateLogger(meta, create) {
+    return internalRegisterEventLogger(meta, create || (() => new StateLogger()));
+}

package/dist/snapshot-event-to-operation.d.ts

@@ -0,0 +1,5 @@
+import type { StateSnapshotEvent } from "./state-logger.js";
+import type { SerializedValue } from "./to-json/serialized-types.js";
+import type { Operation } from "@capture.dev/fast-json-patch";
+export declare function snapshotEventToOperation(snapshotEvent: StateSnapshotEvent): Operation<SerializedValue>;
+//# sourceMappingURL=snapshot-event-to-operation.d.ts.map

package/dist/snapshot-event-to-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-event-to-operation.d.ts","sourceRoot":"","sources":["../src/snapshot-event-to-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAE9D,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,kBAAkB,GAChC,SAAS,CAAC,eAAe,CAAC,CAM5B"}

package/dist/snapshot-event-to-operation.js

@@ -0,0 +1,7 @@
+export function snapshotEventToOperation(snapshotEvent) {
+    return {
+        op: "replace",
+        path: "",
+        value: snapshotEvent.value,
+    };
+}

package/dist/state-logger.d.ts

@@ -0,0 +1,37 @@
+import { type Operation } from "@capture.dev/fast-json-patch";
+import { EventLogger } from "./event-logger.js";
+import type { BaseEvent, EventLoggerMeta, EventLoggerType } from "./event-logger.js";
+import type { SerializedValue } from "./to-json/serialized-types.js";
+export declare const STATE_LOGGER_SNAPSHOT_INTERVAL: number;
+export interface StateLoggerMeta extends EventLoggerMeta {
+    contextLabel?: string;
+}
+export interface StatePatchEvent extends BaseEvent {
+    id: string;
+    type: "patch";
+    label?: string;
+    ops: Operation<SerializedValue>[];
+    context?: SerializedValue;
+}
+export interface StateSnapshotEvent extends BaseEvent {
+    type: "snapshot";
+    value: SerializedValue;
+}
+export type StateEvent = StatePatchEvent | StateSnapshotEvent;
+interface StateLoggerOpts<State = unknown> {
+    initialState?: State;
+}
+export declare class StateLogger extends EventLogger<StateEvent> {
+    type: EventLoggerType;
+    private previousState;
+    private idCounter;
+    private snapshotInterval;
+    meta: StateLoggerMeta;
+    constructor({ initialState }?: StateLoggerOpts);
+    start(): void;
+    stop(): void;
+    logState(state: unknown, label?: string, context?: unknown): void;
+    private logSnapshot;
+}
+export {};
+//# sourceMappingURL=state-logger.d.ts.map

package/dist/state-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-logger.d.ts","sourceRoot":"","sources":["../src/state-logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEvE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,OAAO,KAAK,EACV,SAAS,EACT,eAAe,EACf,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE,eAAO,MAAM,8BAA8B,QAAY,CAAC;AAExD,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAgB,SAAQ,SAAS;IAChD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,SAAS,CAAC,eAAe,CAAC,EAAE,CAAC;IAClC,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAmB,SAAQ,SAAS;IACnD,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,eAAe,CAAC;CACxB;AAED,MAAM,MAAM,UAAU,GAAG,eAAe,GAAG,kBAAkB,CAAC;AAE9D,UAAU,eAAe,CAAC,KAAK,GAAG,OAAO;IACvC,YAAY,CAAC,EAAE,KAAK,CAAC;CACtB;AAED,qBAAa,WAAY,SAAQ,WAAW,CAAC,UAAU,CAAC;IACtD,IAAI,EAAE,eAAe,CAAW;IAEhC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,gBAAgB,CAAuB;IAExC,IAAI,EAAE,eAAe,CAG1B;gBAEU,EAAE,YAAY,EAAE,GAAE,eAAoB;IAelD,KAAK;IAQL,IAAI;IAOJ,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO;IAqC1D,OAAO,CAAC,WAAW;CAgBpB"}

package/dist/state-logger.js

@@ -0,0 +1,90 @@
+import { compare } from "@capture.dev/fast-json-patch";
+import { EventLogger } from "./event-logger.js";
+import { toJSON } from "./to-json/to-json.js";
+export const STATE_LOGGER_SNAPSHOT_INTERVAL = 1000 * 60; // 1 minute
+export class StateLogger extends EventLogger {
+    type = "state";
+    previousState;
+    idCounter = 0;
+    snapshotInterval = null;
+    meta = {
+        identifier: "state",
+        name: "State",
+    };
+    constructor({ initialState } = {}) {
+        super();
+        if (initialState === undefined || initialState === null) {
+            this.previousState = null;
+        }
+        else if (typeof initialState !== "object") {
+            console.warn(`StateLogger can only log state of type "object", received  "${initialState === null ? "null" : typeof initialState}"`);
+            this.previousState = null;
+        }
+        else {
+            this.previousState = initialState;
+            this.logSnapshot(initialState);
+        }
+    }
+    start() {
+        this.snapshotInterval = window.setInterval(() => {
+            if (this.previousState !== null) {
+                this.logSnapshot(this.previousState);
+            }
+        }, STATE_LOGGER_SNAPSHOT_INTERVAL);
+    }
+    stop() {
+        if (this.snapshotInterval) {
+            clearInterval(this.snapshotInterval);
+            this.snapshotInterval = null;
+        }
+    }
+    logState(state, label, context) {
+        if (typeof state !== "object" || state === null) {
+            console.warn(`StateLogger can only log state of type "object", received "${state === null ? "null" : typeof state}"`);
+            return;
+        }
+        try {
+            let ops = [];
+            if (this.previousState === null) {
+                this.logSnapshot(state);
+            }
+            else {
+                ops = toJSON(compare(this.previousState, state), {
+                    onError: this.logInternalError,
+                });
+            }
+            const serializedContext = context !== undefined
+                ? toJSON(context, {
+                    onError: this.logInternalError,
+                    maxDepth: 10,
+                })
+                : undefined;
+            this.logEvent({
+                id: `${this.idCounter++}`,
+                time: Date.now(),
+                type: "patch",
+                ops,
+                label,
+                context: serializedContext,
+            });
+            this.previousState = state;
+        }
+        catch (error) {
+            this.logInternalError(error);
+        }
+    }
+    logSnapshot(state) {
+        if (typeof state !== "object" || state === null) {
+            console.warn(`StateLogger can only log state of type "object", received "${state === null ? "null" : typeof state}"`);
+            return;
+        }
+        this.logEvent({
+            time: Date.now(),
+            type: "snapshot",
+            value: toJSON(state, {
+                onError: this.logInternalError,
+            }),
+        });
+        this.previousState = state;
+    }
+}

package/dist/to-json/__tests__/serialize-class.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=serialize-class.test.d.ts.map

package/dist/to-json/__tests__/serialize-class.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-class.test.d.ts","sourceRoot":"","sources":["../../../src/to-json/__tests__/serialize-class.test.ts"],"names":[],"mappings":""}

package/dist/to-json/__tests__/serialize-class.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect } from "vitest";
+import { isClass, serializeClass } from "../serialize-class.js";
+describe("isClass", () => {
+    it("returns true for a class", () => {
+        class MyClass {
+        }
+        expect(isClass(MyClass)).toBe(true);
+    });
+    it("returns false for a regular function", () => {
+        function myFunc() { }
+        expect(isClass(myFunc)).toBe(false);
+    });
+    it("returns false for an arrow function", () => {
+        const arrow = () => { };
+        expect(isClass(arrow)).toBe(false);
+    });
+    it("returns false for a method", () => {
+        const obj = { method() { } };
+        expect(isClass(obj.method)).toBe(false);
+    });
+    it("returns true for an anonymous class", () => {
+        const AnonymousClass = class {
+        };
+        expect(isClass(AnonymousClass)).toBe(true);
+    });
+    it("returns true for a class with extends", () => {
+        class Parent {
+        }
+        class Child extends Parent {
+        }
+        expect(isClass(Child)).toBe(true);
+    });
+    it("returns false for native functions", () => {
+        expect(isClass(Array.isArray)).toBe(false);
+    });
+});
+describe("serializeClass", () => {
+    it("serializes a named class", () => {
+        class MyClass {
+        }
+        const result = serializeClass(MyClass);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "classConstructor",
+            name: "MyClass",
+        });
+    });
+    it("serializes an anonymous class as (anonymous)", () => {
+        const AnonymousClass = class {
+        };
+        Object.defineProperty(AnonymousClass, "name", { value: "" });
+        const result = serializeClass(AnonymousClass);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "classConstructor",
+            name: "(anonymous)",
+        });
+    });
+    it("serializes a class with inheritance", () => {
+        class Animal {
+        }
+        class Dog extends Animal {
+        }
+        const result = serializeClass(Dog);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "classConstructor",
+            name: "Dog",
+        });
+    });
+    it("serializes a class with properties", () => {
+        class User {
+            name = "test";
+            age = 25;
+        }
+        const result = serializeClass(User);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "classConstructor",
+            name: "User",
+        });
+    });
+});

package/dist/to-json/__tests__/serialize-date.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=serialize-date.test.d.ts.map

package/dist/to-json/__tests__/serialize-date.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-date.test.d.ts","sourceRoot":"","sources":["../../../src/to-json/__tests__/serialize-date.test.ts"],"names":[],"mappings":""}

package/dist/to-json/__tests__/serialize-date.test.js

@@ -0,0 +1,20 @@
+import { describe, it, expect } from "vitest";
+import { serializeDate } from "../serialize-date.js";
+describe("serializeDate", () => {
+    it("serializes a valid date to a timestamp", () => {
+        const date = new Date("2024-01-15T12:00:00.000Z");
+        const result = serializeDate(date);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "date",
+            value: 1705320000000,
+        });
+    });
+    it("serializes an invalid date to null", () => {
+        const date = new Date("invalid-date-string");
+        const result = serializeDate(date);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "date",
+            value: null,
+        });
+    });
+});

package/dist/to-json/__tests__/serialize-error.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=serialize-error.test.d.ts.map

package/dist/to-json/__tests__/serialize-error.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-error.test.d.ts","sourceRoot":"","sources":["../../../src/to-json/__tests__/serialize-error.test.ts"],"names":[],"mappings":""}

package/dist/to-json/__tests__/serialize-error.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect } from "vitest";
+import { serializeError } from "../serialize-error.js";
+describe("serializeError", () => {
+    it("serializes a basic error with name and message", () => {
+        const error = new Error("Something went wrong");
+        const result = serializeError(error);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "error",
+            error: {
+                name: "Error",
+                message: "Something went wrong",
+                stack: expect.any(String),
+            },
+        });
+    });
+    it("serializes a TypeError", () => {
+        const error = new TypeError("Cannot read property 'foo' of undefined");
+        const result = serializeError(error);
+        expect(result.__CAPTURE_TYPE__).toBe("error");
+        expect(result.error.name).toBe("TypeError");
+        expect(result.error.message).toBe("Cannot read property 'foo' of undefined");
+    });
+    it("serializes a custom error class", () => {
+        class CustomError extends Error {
+            constructor(message) {
+                super(message);
+                this.name = "CustomError";
+            }
+        }
+        const error = new CustomError("Custom error message");
+        const result = serializeError(error);
+        expect(result.error.name).toBe("CustomError");
+        expect(result.error.message).toBe("Custom error message");
+    });
+    it("includes stack trace when present", () => {
+        const error = new Error("With stack");
+        const result = serializeError(error);
+        expect(result.error.stack).toBeDefined();
+        expect(result.error.stack).toContain("Error: With stack");
+    });
+    it("handles error without stack trace", () => {
+        const error = new Error("No stack");
+        error.stack = undefined;
+        const result = serializeError(error);
+        expect(result.error.stack).toBeUndefined();
+    });
+    it("serializes error with Error cause", () => {
+        const cause = new Error("Root cause");
+        const error = new Error("Wrapper error", { cause });
+        const result = serializeError(error);
+        expect(result.error.cause).toEqual({
+            name: "Error",
+            message: "Root cause",
+            stack: expect.any(String),
+        });
+    });
+    it("serializes nested error causes", () => {
+        const rootCause = new Error("Root");
+        const middleCause = new Error("Middle", { cause: rootCause });
+        const error = new Error("Top", { cause: middleCause });
+        const result = serializeError(error);
+        expect(result.error.message).toBe("Top");
+        expect(result.error.cause?.message).toBe("Middle");
+        expect(result.error.cause?.cause?.message).toBe("Root");
+    });
+    it("handles non-Error cause by setting null", () => {
+        const error = new Error("With string cause", { cause: "string cause" });
+        const result = serializeError(error);
+        expect(result.error.cause).toBeNull();
+    });
+});