@capture.dev/event-logger 0.0.1

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

@@ -0,0 +1,356 @@
+import { describe, it, expect } from "vitest";
+import { BIG_INT, CIRCULAR_REFERENCE, MAX_DEPTH_REACHED, PROMISE, TOO_LARGE, UNDEFINED, } from "../to-json.constants.js";
+import { toJSON } from "../to-json.js";
+describe("toJSON", () => {
+    describe("primitives", () => {
+        it("serializes null", () => {
+            expect(toJSON(null)).toBe(null);
+        });
+        it("serializes booleans", () => {
+            expect(toJSON(true)).toBe(true);
+            expect(toJSON(false)).toBe(false);
+        });
+        it("serializes numbers", () => {
+            expect(toJSON(42)).toBe(42);
+            expect(toJSON(3.14)).toBe(3.14);
+            expect(toJSON(-100)).toBe(-100);
+        });
+        it("serializes strings", () => {
+            expect(toJSON("hello")).toBe("hello");
+            expect(toJSON("")).toBe("");
+        });
+        it("serializes undefined as marker", () => {
+            expect(toJSON(undefined)).toBe(UNDEFINED);
+        });
+        it("serializes safe bigint as number", () => {
+            expect(toJSON(BigInt(42))).toBe(42);
+        });
+        it("serializes unsafe bigint as marker", () => {
+            expect(toJSON(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1))).toBe(BIG_INT);
+        });
+        it("serializes symbol as string", () => {
+            expect(toJSON(Symbol("test"))).toBe("Symbol(test)");
+            expect(toJSON(Symbol.for("global"))).toBe("Symbol(global)");
+        });
+    });
+    describe("functions", () => {
+        it("serializes named function", () => {
+            function myFunc() { }
+            const result = toJSON(myFunc);
+            expect(result).toEqual({
+                __CAPTURE_TYPE__: "function",
+                name: "myFunc",
+            });
+        });
+        it("serializes arrow function", () => {
+            const arrow = () => { };
+            const result = toJSON(arrow);
+            expect(result).toEqual({
+                __CAPTURE_TYPE__: "function",
+                name: "arrow",
+            });
+        });
+    });
+    describe("classes", () => {
+        it("serializes a class", () => {
+            class MyClass {
+            }
+            const result = toJSON(MyClass);
+            expect(result).toEqual({
+                __CAPTURE_TYPE__: "classConstructor",
+                name: "MyClass",
+            });
+        });
+        it("serializes an extended class", () => {
+            class Parent {
+            }
+            class Child extends Parent {
+            }
+            const result = toJSON(Child);
+            expect(result).toEqual({
+                __CAPTURE_TYPE__: "classConstructor",
+                name: "Child",
+            });
+        });
+    });
+    describe("dates", () => {
+        it("serializes date as timestamp", () => {
+            const date = new Date("2024-01-15T12:00:00.000Z");
+            expect(toJSON(date)).toMatchObject({
+                __CAPTURE_TYPE__: "date",
+                value: 1705320000000,
+            });
+        });
+    });
+    describe("errors", () => {
+        it("serializes error with name and message", () => {
+            const error = new Error("Test error");
+            const result = toJSON(error);
+            expect(result).toMatchObject({
+                __CAPTURE_TYPE__: "error",
+                error: {
+                    name: "Error",
+                    message: "Test error",
+                },
+            });
+        });
+        it("serializes TypeError", () => {
+            const error = new TypeError("Type mismatch");
+            const result = toJSON(error);
+            expect(result).toMatchObject({
+                __CAPTURE_TYPE__: "error",
+                error: {
+                    name: "TypeError",
+                    message: "Type mismatch",
+                },
+            });
+        });
+    });
+    describe("regex", () => {
+        it("serializes regex with pattern", () => {
+            const regex = /test/gi;
+            const result = toJSON(regex);
+            expect(result).toEqual({
+                __CAPTURE_TYPE__: "regex",
+                pattern: "/test/gi",
+            });
+        });
+    });
+    describe("promises", () => {
+        it("serializes promise as marker", () => {
+            const promise = Promise.resolve(42);
+            expect(toJSON(promise)).toBe(PROMISE);
+        });
+        it("serializes pending promise as marker", () => {
+            const promise = new Promise(() => { });
+            expect(toJSON(promise)).toBe(PROMISE);
+        });
+    });
+    describe("arrays", () => {
+        it("serializes empty array", () => {
+            expect(toJSON([])).toEqual([]);
+        });
+        it("serializes array of primitives", () => {
+            expect(toJSON([1, "two", true, null])).toEqual([1, "two", true, null]);
+        });
+        it("serializes nested arrays", () => {
+            expect(toJSON([
+                [1, 2],
+                [3, 4],
+            ])).toEqual([
+                [1, 2],
+                [3, 4],
+            ]);
+        });
+        it("serializes array with mixed types", () => {
+            const result = toJSON([1, undefined, () => { }, new Map([["a", 1]])]);
+            expect(result).toEqual([
+                1,
+                UNDEFINED,
+                { __CAPTURE_TYPE__: "function", name: "(anonymous)" },
+                {
+                    __CAPTURE_TYPE__: "map",
+                    entries: [["a", 1]],
+                },
+            ]);
+        });
+    });
+    describe("maps", () => {
+        it("serializes empty map", () => {
+            const result = toJSON(new Map());
+            expect(result).toEqual({
+                __CAPTURE_TYPE__: "map",
+                entries: [],
+            });
+        });
+        it("serializes map with entries", () => {
+            const map = new Map([
+                ["a", 1],
+                ["b", 2],
+            ]);
+            const result = toJSON(map);
+            expect(result).toEqual({
+                __CAPTURE_TYPE__: "map",
+                entries: [
+                    ["a", 1],
+                    ["b", 2],
+                ],
+            });
+        });
+    });
+    describe("sets", () => {
+        it("serializes empty set", () => {
+            const result = toJSON(new Set());
+            expect(result).toEqual({
+                __CAPTURE_TYPE__: "set",
+                values: [],
+            });
+        });
+        it("serializes set with values", () => {
+            const set = new Set([1, 2, 3]);
+            const result = toJSON(set);
+            expect(result).toEqual({
+                __CAPTURE_TYPE__: "set",
+                values: [1, 2, 3],
+            });
+        });
+    });
+    describe("plain objects", () => {
+        it("serializes empty object", () => {
+            expect(toJSON({})).toEqual({});
+        });
+        it("serializes object with properties", () => {
+            expect(toJSON({ a: 1, b: "two" })).toEqual({ a: 1, b: "two" });
+        });
+        it("serializes nested objects", () => {
+            expect(toJSON({ outer: { inner: "value" } })).toEqual({
+                outer: { inner: "value" },
+            });
+        });
+        it("respects toJSON method", () => {
+            const obj = {
+                secret: "hidden",
+                toJSON() {
+                    return { public: "visible" };
+                },
+            };
+            expect(toJSON(obj)).toEqual({ public: "visible" });
+        });
+    });
+    describe("class instances", () => {
+        it("serializes class instance with name", () => {
+            class User {
+                name = "Alice";
+            }
+            const result = toJSON(new User());
+            expect(result).toEqual({
+                __CAPTURE_TYPE__: "object",
+                name: "User",
+                properties: { name: "Alice" },
+            });
+        });
+        it("serializes inherited class", () => {
+            class Animal {
+                type = "animal";
+            }
+            class Dog extends Animal {
+                breed = "labrador";
+            }
+            const result = toJSON(new Dog());
+            expect(result).toMatchObject({
+                __CAPTURE_TYPE__: "object",
+                name: "Dog",
+            });
+        });
+    });
+    describe("circular references", () => {
+        it("handles circular object reference", () => {
+            const obj = { a: 1 };
+            obj.self = obj;
+            const result = toJSON(obj);
+            expect(result).toEqual({
+                a: 1,
+                self: CIRCULAR_REFERENCE,
+            });
+        });
+        it("handles circular array reference", () => {
+            const arr = [1, 2];
+            arr.push(arr);
+            const result = toJSON(arr);
+            expect(result).toEqual([1, 2, CIRCULAR_REFERENCE]);
+        });
+        it("handles deeply nested circular reference", () => {
+            const obj = {
+                level1: {
+                    level2: {
+                        level3: {},
+                    },
+                },
+            };
+            obj.level1.level2.level3 = obj;
+            const result = toJSON(obj);
+            expect(result.level1.level2).toMatchObject({
+                level3: CIRCULAR_REFERENCE,
+            });
+        });
+    });
+    describe("depth limiting", () => {
+        it("returns marker when max depth exceeded", () => {
+            const deep = { l1: { l2: { l3: { l4: "value" } } } };
+            const result = toJSON(deep, { maxDepth: 2 });
+            expect(result).toEqual({
+                l1: {
+                    l2: {
+                        l3: MAX_DEPTH_REACHED,
+                    },
+                },
+            });
+        });
+    });
+    describe("size limiting (partial truncation)", () => {
+        it("returns partial object with TOO_LARGE marker when size exceeded", () => {
+            const large = {
+                first: "a".repeat(100),
+                second: "b".repeat(100),
+                third: "c".repeat(100),
+            };
+            const result = toJSON(large, { maxSize: 250 });
+            expect(result).toMatchObject({
+                first: expect.any(String),
+            });
+            expect(Object.values(result)).toContain(TOO_LARGE);
+        });
+        it("preserves data before truncation point", () => {
+            const obj = {
+                small: "hello",
+                large: "x".repeat(1000000),
+            };
+            const result = toJSON(obj, { maxSize: 100 });
+            expect(result.small).toBe("hello");
+            expect(result.large).toBe(TOO_LARGE);
+        });
+    });
+    describe("string truncation", () => {
+        it("truncates long strings", () => {
+            const longString = "a".repeat(200);
+            const result = toJSON(longString, { maxStringLength: 50 });
+            expect(result).toBe("a".repeat(50) + " [Output truncated due to length]");
+        });
+        it("does not truncate strings under limit", () => {
+            const shortString = "hello";
+            const result = toJSON(shortString, { maxStringLength: 50 });
+            expect(result).toBe("hello");
+        });
+    });
+    describe("edge cases", () => {
+        it("handles unknown value type", () => {
+            // Proxy that masquerades as non-object
+            const weird = Object.create(null);
+            Object.setPrototypeOf(weird, null);
+            const result = toJSON(weird);
+            expect(result).toMatchObject({
+                __CAPTURE_TYPE__: "object",
+            });
+        });
+        it("handles getter that throws", () => {
+            const obj = {
+                get throwing() {
+                    throw new Error("Oops");
+                },
+                normal: "value",
+            };
+            const result = toJSON(obj);
+            expect(result.normal).toBe("value");
+            expect(result.throwing).toContain("[Throws:");
+        });
+        it("handles toJSON that throws", () => {
+            const obj = {
+                toJSON() {
+                    throw new Error("toJSON failed");
+                },
+            };
+            const result = toJSON(obj);
+            expect(result).toContain("[Throws:");
+        });
+    });
+});

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

@@ -0,0 +1,4 @@
+import type { SerializedClassConstructor } from "./serialized-types.js";
+export declare function isClass(fn: Function): boolean;
+export declare function serializeClass(fn: Function): SerializedClassConstructor;
+//# sourceMappingURL=serialize-class.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-class.d.ts","sourceRoot":"","sources":["../../src/to-json/serialize-class.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAExE,wBAAgB,OAAO,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAM7C;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,QAAQ,GAAG,0BAA0B,CAKvE"}

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

@@ -0,0 +1,14 @@
+export function isClass(fn) {
+    try {
+        return /^class\s/.test(fn.toString());
+    }
+    catch {
+        return false;
+    }
+}
+export function serializeClass(fn) {
+    return {
+        __CAPTURE_TYPE__: "classConstructor",
+        name: fn.name || "(anonymous)",
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { SerializedDate } from "./serialized-types.js";
+export declare function serializeDate(date: Date): SerializedDate;
+//# sourceMappingURL=serialize-date.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-date.d.ts","sourceRoot":"","sources":["../../src/to-json/serialize-date.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,cAAc,CAOxD"}

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

@@ -0,0 +1,8 @@
+export function serializeDate(date) {
+    const time = date.getTime();
+    const isInvalid = Number.isNaN(time);
+    return {
+        __CAPTURE_TYPE__: "date",
+        value: isInvalid ? null : time,
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { SerializedError } from "./serialized-types.js";
+export declare function serializeError(error: Error): SerializedError;
+//# sourceMappingURL=serialize-error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-error.d.ts","sourceRoot":"","sources":["../../src/to-json/serialize-error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EAEhB,MAAM,uBAAuB,CAAC;AAqB/B,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,eAAe,CAK5D"}

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

@@ -0,0 +1,22 @@
+function serializeErrorObject(error) {
+    const result = {
+        name: error.name,
+        message: error.message,
+    };
+    if (error.stack) {
+        result.stack = error.stack;
+    }
+    if (error.cause instanceof Error) {
+        result.cause = serializeErrorObject(error.cause);
+    }
+    else if (error.cause !== undefined) {
+        result.cause = null;
+    }
+    return result;
+}
+export function serializeError(error) {
+    return {
+        __CAPTURE_TYPE__: "error",
+        error: serializeErrorObject(error),
+    };
+}

package/dist/to-json/serialize-function.d.ts

@@ -0,0 +1,3 @@
+import type { SerializedFunction } from "./serialized-types.js";
+export declare function serializeFunction(fn: Function): SerializedFunction;
+//# sourceMappingURL=serialize-function.d.ts.map

package/dist/to-json/serialize-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-function.d.ts","sourceRoot":"","sources":["../../src/to-json/serialize-function.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAGhE,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,QAAQ,GAAG,kBAAkB,CAKlE"}

package/dist/to-json/serialize-function.js

@@ -0,0 +1,7 @@
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+export function serializeFunction(fn) {
+    return {
+        __CAPTURE_TYPE__: "function",
+        name: fn.name || "(anonymous)",
+    };
+}

package/dist/to-json/serialize-map.d.ts

@@ -0,0 +1,4 @@
+import type { SerializedMap } from "./serialized-types.js";
+import type { VisitorFn } from "./to-json.js";
+export declare function serializeMap(map: Map<unknown, unknown>, visit: VisitorFn): SerializedMap;
+//# sourceMappingURL=serialize-map.d.ts.map

package/dist/to-json/serialize-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-map.d.ts","sourceRoot":"","sources":["../../src/to-json/serialize-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAmB,MAAM,uBAAuB,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,wBAAgB,YAAY,CAC1B,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,EAC1B,KAAK,EAAE,SAAS,GACf,aAAa,CAWf"}

package/dist/to-json/serialize-map.js

@@ -0,0 +1,10 @@
+export function serializeMap(map, visit) {
+    const entries = [];
+    for (const [key, value] of map) {
+        entries.push([visit(key), visit(value)]);
+    }
+    return {
+        __CAPTURE_TYPE__: "map",
+        entries,
+    };
+}

package/dist/to-json/serialize-object.d.ts

@@ -0,0 +1,4 @@
+import type { SerializedObject } from "./serialized-types.js";
+import type { VisitorFn } from "./to-json.js";
+export declare function serializeObject(obj: object, visit: VisitorFn): SerializedObject;
+//# sourceMappingURL=serialize-object.d.ts.map

package/dist/to-json/serialize-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-object.d.ts","sourceRoot":"","sources":["../../src/to-json/serialize-object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,uBAAuB,CAAC;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,SAAS,GACf,gBAAgB,CAiBlB"}

package/dist/to-json/serialize-object.js

@@ -0,0 +1,17 @@
+export function serializeObject(obj, visit) {
+    const name = obj.constructor?.name || "Object";
+    const properties = {};
+    for (const key of Object.keys(obj)) {
+        try {
+            properties[key] = visit(obj[key]);
+        }
+        catch {
+            properties[key] = "[Throws]";
+        }
+    }
+    return {
+        __CAPTURE_TYPE__: "object",
+        name,
+        properties,
+    };
+}

package/dist/to-json/serialize-regex.d.ts

@@ -0,0 +1,3 @@
+import type { SerializedRegex } from "./serialized-types.js";
+export declare function serializeRegex(regex: RegExp): SerializedRegex;
+//# sourceMappingURL=serialize-regex.d.ts.map

package/dist/to-json/serialize-regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-regex.d.ts","sourceRoot":"","sources":["../../src/to-json/serialize-regex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAK7D"}

package/dist/to-json/serialize-regex.js

@@ -0,0 +1,6 @@
+export function serializeRegex(regex) {
+    return {
+        __CAPTURE_TYPE__: "regex",
+        pattern: regex.toString(),
+    };
+}

package/dist/to-json/serialize-set.d.ts

@@ -0,0 +1,4 @@
+import type { SerializedSet } from "./serialized-types.js";
+import type { VisitorFn } from "./to-json.js";
+export declare function serializeSet(set: Set<unknown>, visit: VisitorFn): SerializedSet;
+//# sourceMappingURL=serialize-set.d.ts.map

package/dist/to-json/serialize-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-set.d.ts","sourceRoot":"","sources":["../../src/to-json/serialize-set.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAmB,MAAM,uBAAuB,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,wBAAgB,YAAY,CAC1B,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC,EACjB,KAAK,EAAE,SAAS,GACf,aAAa,CAWf"}

package/dist/to-json/serialize-set.js

@@ -0,0 +1,10 @@
+export function serializeSet(set, visit) {
+    const values = [];
+    for (const value of set) {
+        values.push(visit(value));
+    }
+    return {
+        __CAPTURE_TYPE__: "set",
+        values,
+    };
+}

package/dist/to-json/serialized-markers.d.ts

@@ -0,0 +1,23 @@
+export declare const REDACTED = "$REDACTED$";
+export declare const UNDEFINED = "$UNDEFINED$";
+export declare const BIG_INT = "$BIGINT$";
+export declare const FUNCTION = "$FUNCTION$";
+export declare const PROMISE = "$PROMISE$";
+export declare const CIRCULAR_REFERENCE = "$CIRCULAR_REFERENCE$";
+export declare const UNKNOWN = "$UNKNOWN$";
+export declare const TOO_LARGE = "$TOO_LARGE$";
+export declare const MAX_DEPTH_REACHED = "$MAX_DEPTH_REACHED$";
+export declare const SERIALIZATION_ERROR = "$SERIALIZATION_ERROR$";
+export declare const SerializedMarker: {
+    readonly REDACTED: "$REDACTED$";
+    readonly UNDEFINED: "$UNDEFINED$";
+    readonly BIG_INT: "$BIGINT$";
+    readonly FUNCTION: "$FUNCTION$";
+    readonly PROMISE: "$PROMISE$";
+    readonly CIRCULAR_REFERENCE: "$CIRCULAR_REFERENCE$";
+    readonly UNKNOWN: "$UNKNOWN$";
+    readonly TOO_LARGE: "$TOO_LARGE$";
+    readonly MAX_DEPTH_REACHED: "$MAX_DEPTH_REACHED$";
+    readonly SERIALIZATION_ERROR: "$SERIALIZATION_ERROR$";
+};
+//# sourceMappingURL=serialized-markers.d.ts.map

package/dist/to-json/serialized-markers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialized-markers.d.ts","sourceRoot":"","sources":["../../src/to-json/serialized-markers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,eAAe,CAAC;AACrC,eAAO,MAAM,SAAS,gBAAgB,CAAC;AACvC,eAAO,MAAM,OAAO,aAAa,CAAC;AAClC,eAAO,MAAM,QAAQ,eAAe,CAAC;AACrC,eAAO,MAAM,OAAO,cAAc,CAAC;AACnC,eAAO,MAAM,kBAAkB,yBAAyB,CAAC;AACzD,eAAO,MAAM,OAAO,cAAc,CAAC;AACnC,eAAO,MAAM,SAAS,gBAAgB,CAAC;AACvC,eAAO,MAAM,iBAAiB,wBAAwB,CAAC;AACvD,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAE3D,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAWnB,CAAC"}

package/dist/to-json/serialized-markers.js

@@ -0,0 +1,22 @@
+export const REDACTED = "$REDACTED$";
+export const UNDEFINED = "$UNDEFINED$";
+export const BIG_INT = "$BIGINT$";
+export const FUNCTION = "$FUNCTION$";
+export const PROMISE = "$PROMISE$";
+export const CIRCULAR_REFERENCE = "$CIRCULAR_REFERENCE$";
+export const UNKNOWN = "$UNKNOWN$";
+export const TOO_LARGE = "$TOO_LARGE$";
+export const MAX_DEPTH_REACHED = "$MAX_DEPTH_REACHED$";
+export const SERIALIZATION_ERROR = "$SERIALIZATION_ERROR$";
+export const SerializedMarker = {
+    REDACTED,
+    UNDEFINED,
+    BIG_INT,
+    FUNCTION,
+    PROMISE,
+    CIRCULAR_REFERENCE,
+    UNKNOWN,
+    TOO_LARGE,
+    MAX_DEPTH_REACHED,
+    SERIALIZATION_ERROR,
+};

package/dist/to-json/serialized-types.d.ts

@@ -0,0 +1,55 @@
+export type SerializedValue = string | number | boolean | null | SerializedValue[] | {
+    [key: string]: SerializedValue;
+} | SerializedError | SerializedMap | SerializedSet | SerializedRegex | SerializedFunction | SerializedClassConstructor | SerializedObject;
+export type SerializedPlainObject = Record<string, SerializedValue>;
+export type SerializedArray = SerializedValue[];
+export declare const isSerializedPlainObject: (value: SerializedValue) => value is SerializedPlainObject;
+export declare const isSerializedArray: (value: SerializedValue) => value is SerializedArray;
+export type SerializedErrorObject = {
+    name: string;
+    message: string;
+    stack?: string;
+    cause?: SerializedErrorObject | null;
+};
+export type SerializedError = {
+    __CAPTURE_TYPE__: "error";
+    error: SerializedErrorObject;
+};
+export declare const isSerializedError: (value: SerializedValue) => value is SerializedError;
+export type SerializedMap = {
+    __CAPTURE_TYPE__: "map";
+    entries: [SerializedValue, SerializedValue][];
+};
+export declare const isSerializedMap: (value: SerializedValue) => value is SerializedMap;
+export type SerializedSet = {
+    __CAPTURE_TYPE__: "set";
+    values: SerializedValue[];
+};
+export declare const isSerializedSet: (value: SerializedValue) => value is SerializedSet;
+export type SerializedRegex = {
+    __CAPTURE_TYPE__: "regex";
+    pattern: string;
+};
+export declare const isSerializedRegex: (value: SerializedValue) => value is SerializedRegex;
+export type SerializedFunction = {
+    __CAPTURE_TYPE__: "function";
+    name: string;
+};
+export declare const isSerializedFunction: (value: SerializedValue) => value is SerializedFunction;
+export type SerializedClassConstructor = {
+    __CAPTURE_TYPE__: "classConstructor";
+    name: string;
+};
+export declare const isSerializedClassConstructor: (value: SerializedValue) => value is SerializedClassConstructor;
+export type SerializedObject = {
+    __CAPTURE_TYPE__: "object";
+    name: string;
+    properties: Record<string, SerializedValue>;
+};
+export declare const isSerializedObject: (value: SerializedValue) => value is SerializedObject;
+export type SerializedDate = {
+    __CAPTURE_TYPE__: "date";
+    value: number | null;
+};
+export declare const isSerializedDate: (value: SerializedValue) => value is SerializedDate;
+//# sourceMappingURL=serialized-types.d.ts.map

package/dist/to-json/serialized-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialized-types.d.ts","sourceRoot":"","sources":["../../src/to-json/serialized-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,eAAe,EAAE,GACjB;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAAA;CAAE,GAClC,eAAe,GACf,aAAa,GACb,aAAa,GACb,eAAe,GACf,kBAAkB,GAClB,0BAA0B,GAC1B,gBAAgB,CAAC;AAErB,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;AACpE,MAAM,MAAM,eAAe,GAAG,eAAe,EAAE,CAAC;AAchD,eAAO,MAAM,uBAAuB,GAClC,OAAO,eAAe,KACrB,KAAK,IAAI,qBAOX,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,OAAO,eAAe,KACrB,KAAK,IAAI,eAEX,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,qBAAqB,GAAG,IAAI,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,KAAK,EAAE,qBAAqB,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,OAAO,eAAe,KACrB,KAAK,IAAI,eAEX,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,gBAAgB,EAAE,KAAK,CAAC;IACxB,OAAO,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,EAAE,CAAC;CAC/C,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,OAAO,eAAe,KACrB,KAAK,IAAI,aAEX,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,gBAAgB,EAAE,KAAK,CAAC;IACxB,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,OAAO,eAAe,KACrB,KAAK,IAAI,aAEX,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,OAAO,eAAe,KACrB,KAAK,IAAI,eAEX,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gBAAgB,EAAE,UAAU,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,eAAe,KACrB,KAAK,IAAI,kBAEX,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,gBAAgB,EAAE,kBAAkB,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,4BAA4B,GACvC,OAAO,eAAe,KACrB,KAAK,IAAI,0BAEX,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,gBAAgB,EAAE,QAAQ,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC7C,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,OAAO,eAAe,KACrB,KAAK,IAAI,gBAEX,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,OAAO,eAAe,KACrB,KAAK,IAAI,cAEX,CAAC"}