@capture.dev/event-logger 0.0.1

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

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

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

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

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

@@ -0,0 +1,84 @@
+import { describe, it, expect } from "vitest";
+import { serializeFunction } from "../serialize-function.js";
+describe("serializeFunction", () => {
+    it("serializes a named function", () => {
+        function myFunction() {
+            return 42;
+        }
+        const result = serializeFunction(myFunction);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "function",
+            name: "myFunction",
+        });
+    });
+    it("serializes an anonymous function as (anonymous)", () => {
+        const fn = function () {
+            return 42;
+        };
+        // Override the name to simulate truly anonymous
+        Object.defineProperty(fn, "name", { value: "" });
+        const result = serializeFunction(fn);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "function",
+            name: "(anonymous)",
+        });
+    });
+    it("serializes an arrow function with inferred name", () => {
+        const arrowFn = () => 42;
+        const result = serializeFunction(arrowFn);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "function",
+            name: "arrowFn",
+        });
+    });
+    it("serializes a method reference", () => {
+        const obj = {
+            myMethod() {
+                return 42;
+            },
+        };
+        const result = serializeFunction(obj.myMethod);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "function",
+            name: "myMethod",
+        });
+    });
+    it("serializes native functions", () => {
+        const result = serializeFunction(Array.isArray);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "function",
+            name: "isArray",
+        });
+    });
+    it("serializes bound functions", () => {
+        function original() {
+            return 42;
+        }
+        const bound = original.bind(null);
+        const result = serializeFunction(bound);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "function",
+            name: "bound original",
+        });
+    });
+    it("serializes async functions", () => {
+        async function asyncFn() {
+            return 42;
+        }
+        const result = serializeFunction(asyncFn);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "function",
+            name: "asyncFn",
+        });
+    });
+    it("serializes generator functions", () => {
+        function* generatorFn() {
+            yield 42;
+        }
+        const result = serializeFunction(generatorFn);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "function",
+            name: "generatorFn",
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,90 @@
+import { describe, it, expect } from "vitest";
+import { serializeMap } from "../serialize-map.js";
+const identity = (value) => value;
+describe("serializeMap", () => {
+    it("serializes an empty map", () => {
+        const map = new Map();
+        const result = serializeMap(map, identity);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "map",
+            entries: [],
+        });
+    });
+    it("serializes a map with string keys and values", () => {
+        const map = new Map([
+            ["key1", "value1"],
+            ["key2", "value2"],
+        ]);
+        const result = serializeMap(map, identity);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "map",
+            entries: [
+                ["key1", "value1"],
+                ["key2", "value2"],
+            ],
+        });
+    });
+    it("serializes a map with number keys", () => {
+        const map = new Map([
+            [1, "one"],
+            [2, "two"],
+        ]);
+        const result = serializeMap(map, identity);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "map",
+            entries: [
+                [1, "one"],
+                [2, "two"],
+            ],
+        });
+    });
+    it("serializes a map with object values", () => {
+        const map = new Map([["user", { name: "Alice", age: 30 }]]);
+        const result = serializeMap(map, identity);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "map",
+            entries: [["user", { name: "Alice", age: 30 }]],
+        });
+    });
+    it("calls visitor function for each key and value", () => {
+        const map = new Map([
+            ["a", 1],
+            ["b", 2],
+        ]);
+        const visited = [];
+        const visitor = (value) => {
+            visited.push(value);
+            return value;
+        };
+        serializeMap(map, visitor);
+        expect(visited).toEqual(["a", 1, "b", 2]);
+    });
+    it("applies visitor transformation to values", () => {
+        const map = new Map([
+            ["count", 5],
+            ["total", 10],
+        ]);
+        const doubler = (value) => {
+            if (typeof value === "number")
+                return value * 2;
+            return value;
+        };
+        const result = serializeMap(map, doubler);
+        expect(result.entries).toEqual([
+            ["count", 10],
+            ["total", 20],
+        ]);
+    });
+    it("preserves insertion order", () => {
+        const map = new Map();
+        map.set("third", 3);
+        map.set("first", 1);
+        map.set("second", 2);
+        const result = serializeMap(map, identity);
+        expect(result.entries.map(([k]) => k)).toEqual([
+            "third",
+            "first",
+            "second",
+        ]);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,138 @@
+import { describe, it, expect } from "vitest";
+import { serializeObject } from "../serialize-object.js";
+const identity = (value) => value;
+describe("serializeObject", () => {
+    it("serializes a class instance with its name", () => {
+        class User {
+            name = "Alice";
+            age = 30;
+        }
+        const user = new User();
+        const result = serializeObject(user, identity);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "object",
+            name: "User",
+            properties: {
+                name: "Alice",
+                age: 30,
+            },
+        });
+    });
+    it("serializes an object created with Object.create(null)", () => {
+        const obj = Object.create(null);
+        obj.foo = "bar";
+        const result = serializeObject(obj, identity);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "object",
+            name: "Object",
+            properties: {
+                foo: "bar",
+            },
+        });
+    });
+    it("captures class name from inheritance chain", () => {
+        class Animal {
+            species = "unknown";
+        }
+        class Dog extends Animal {
+            breed = "labrador";
+        }
+        const dog = new Dog();
+        const result = serializeObject(dog, identity);
+        expect(result.name).toBe("Dog");
+        expect(result.properties).toEqual({
+            species: "unknown",
+            breed: "labrador",
+        });
+    });
+    it("only serializes own enumerable properties", () => {
+        class Example {
+            visible = "yes";
+            constructor() {
+                Object.defineProperty(this, "hidden", {
+                    value: "no",
+                    enumerable: false,
+                });
+            }
+        }
+        const obj = new Example();
+        const result = serializeObject(obj, identity);
+        expect(result.properties).toEqual({
+            visible: "yes",
+        });
+        expect(result.properties).not.toHaveProperty("hidden");
+    });
+    it("calls visitor function for each property value", () => {
+        class Data {
+            a = 1;
+            b = 2;
+        }
+        const visited = [];
+        const visitor = (value) => {
+            visited.push(value);
+            return value;
+        };
+        serializeObject(new Data(), visitor);
+        expect(visited).toEqual([1, 2]);
+    });
+    it("applies visitor transformation to property values", () => {
+        class Numbers {
+            x = 5;
+            y = 10;
+        }
+        const doubler = (value) => {
+            if (typeof value === "number")
+                return value * 2;
+            return value;
+        };
+        const result = serializeObject(new Numbers(), doubler);
+        expect(result.properties).toEqual({
+            x: 10,
+            y: 20,
+        });
+    });
+    it("handles empty class instance", () => {
+        class Empty {
+        }
+        const obj = new Empty();
+        const result = serializeObject(obj, identity);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "object",
+            name: "Empty",
+            properties: {},
+        });
+    });
+    it("handles property access errors gracefully", () => {
+        class Problematic {
+            safe = "value";
+            get throwing() {
+                throw new Error("Cannot access");
+            }
+        }
+        const obj = new Problematic();
+        Object.defineProperty(obj, "throwing", {
+            enumerable: true,
+            get() {
+                throw new Error("Cannot access");
+            },
+        });
+        const result = serializeObject(obj, identity);
+        expect(result.properties.safe).toBe("value");
+        expect(result.properties.throwing).toBe("[Throws]");
+    });
+    it("serializes built-in object types", () => {
+        const url = new URL("https://example.com");
+        const result = serializeObject(url, identity);
+        expect(result.name).toBe("URL");
+        expect(result.__CAPTURE_TYPE__).toBe("object");
+    });
+    it("serializes anonymous class instances", () => {
+        const AnonymousClass = class {
+            value = 42;
+        };
+        const obj = new AnonymousClass();
+        const result = serializeObject(obj, identity);
+        expect(result.name).toBe("AnonymousClass");
+        expect(result.properties).toEqual({ value: 42 });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,64 @@
+import { describe, it, expect } from "vitest";
+import { serializeRegex } from "../serialize-regex.js";
+describe("serializeRegex", () => {
+    it("serializes a simple regex", () => {
+        const regex = /hello/;
+        const result = serializeRegex(regex);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "regex",
+            pattern: "/hello/",
+        });
+    });
+    it("serializes a regex with global flag", () => {
+        const regex = /test/g;
+        const result = serializeRegex(regex);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "regex",
+            pattern: "/test/g",
+        });
+    });
+    it("serializes a regex with multiple flags", () => {
+        const regex = /pattern/gim;
+        const result = serializeRegex(regex);
+        expect(result.__CAPTURE_TYPE__).toBe("regex");
+        expect(result.pattern).toContain("/pattern/");
+        expect(result.pattern).toContain("g");
+        expect(result.pattern).toContain("i");
+        expect(result.pattern).toContain("m");
+    });
+    it("serializes a regex with special characters", () => {
+        const regex = /\d+\.\d{2}/;
+        const result = serializeRegex(regex);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "regex",
+            pattern: "/\\d+\\.\\d{2}/",
+        });
+    });
+    it("serializes a regex created with RegExp constructor", () => {
+        const regex = new RegExp("foo|bar", "i");
+        const result = serializeRegex(regex);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "regex",
+            pattern: "/foo|bar/i",
+        });
+    });
+    it("serializes a complex email regex", () => {
+        const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        const result = serializeRegex(regex);
+        expect(result.__CAPTURE_TYPE__).toBe("regex");
+        expect(result.pattern).toBe("/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/");
+    });
+    it("serializes a regex with unicode flag", () => {
+        const regex = /\p{L}+/u;
+        const result = serializeRegex(regex);
+        expect(result.pattern).toContain("u");
+    });
+    it("serializes an empty regex", () => {
+        const regex = new RegExp("");
+        const result = serializeRegex(regex);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "regex",
+            pattern: "/(?:)/",
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,74 @@
+import { describe, it, expect } from "vitest";
+import { serializeSet } from "../serialize-set.js";
+const identity = (value) => value;
+describe("serializeSet", () => {
+    it("serializes an empty set", () => {
+        const set = new Set();
+        const result = serializeSet(set, identity);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "set",
+            values: [],
+        });
+    });
+    it("serializes a set of strings", () => {
+        const set = new Set(["apple", "banana", "cherry"]);
+        const result = serializeSet(set, identity);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "set",
+            values: ["apple", "banana", "cherry"],
+        });
+    });
+    it("serializes a set of numbers", () => {
+        const set = new Set([1, 2, 3]);
+        const result = serializeSet(set, identity);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "set",
+            values: [1, 2, 3],
+        });
+    });
+    it("serializes a set of mixed types", () => {
+        const set = new Set([1, "two", true, null]);
+        const result = serializeSet(set, identity);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "set",
+            values: [1, "two", true, null],
+        });
+    });
+    it("serializes a set with object values", () => {
+        const obj = { id: 1 };
+        const set = new Set([obj]);
+        const result = serializeSet(set, identity);
+        expect(result).toEqual({
+            __CAPTURE_TYPE__: "set",
+            values: [{ id: 1 }],
+        });
+    });
+    it("calls visitor function for each value", () => {
+        const set = new Set(["a", "b", "c"]);
+        const visited = [];
+        const visitor = (value) => {
+            visited.push(value);
+            return value;
+        };
+        serializeSet(set, visitor);
+        expect(visited).toEqual(["a", "b", "c"]);
+    });
+    it("applies visitor transformation to values", () => {
+        const set = new Set([1, 2, 3]);
+        const doubler = (value) => {
+            if (typeof value === "number")
+                return value * 2;
+            return value;
+        };
+        const result = serializeSet(set, doubler);
+        expect(result.values).toEqual([2, 4, 6]);
+    });
+    it("preserves insertion order", () => {
+        const set = new Set();
+        set.add("third");
+        set.add("first");
+        set.add("second");
+        const result = serializeSet(set, identity);
+        expect(result.values).toEqual(["third", "first", "second"]);
+    });
+});

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

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

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

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