@capture.dev/event-logger 0.0.1

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

@@ -0,0 +1,39 @@
+const isSerializedWithType = (type, value) => {
+    return (typeof value === "object" &&
+        value !== null &&
+        "__CAPTURE_TYPE__" in value &&
+        value.__CAPTURE_TYPE__ === type);
+};
+export const isSerializedPlainObject = (value) => {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !("__CAPTURE_TYPE__" in value));
+};
+export const isSerializedArray = (value) => {
+    return Array.isArray(value);
+};
+export const isSerializedError = (value) => {
+    return isSerializedWithType("error", value);
+};
+export const isSerializedMap = (value) => {
+    return isSerializedWithType("map", value);
+};
+export const isSerializedSet = (value) => {
+    return isSerializedWithType("set", value);
+};
+export const isSerializedRegex = (value) => {
+    return isSerializedWithType("regex", value);
+};
+export const isSerializedFunction = (value) => {
+    return isSerializedWithType("function", value);
+};
+export const isSerializedClassConstructor = (value) => {
+    return isSerializedWithType("classConstructor", value);
+};
+export const isSerializedObject = (value) => {
+    return isSerializedWithType("object", value);
+};
+export const isSerializedDate = (value) => {
+    return isSerializedWithType("date", value);
+};

package/dist/to-json/to-json.constants.d.ts

@@ -0,0 +1,11 @@
+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$";
+//# sourceMappingURL=to-json.constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-json.constants.d.ts","sourceRoot":"","sources":["../../src/to-json/to-json.constants.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"}

package/dist/to-json/to-json.constants.js

@@ -0,0 +1,10 @@
+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$";

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

@@ -0,0 +1,14 @@
+import type { SerializedValue } from "./serialized-types.js";
+export type VisitorFn = (value: unknown) => SerializedValue;
+interface ToJSONOpts {
+    maxDepth?: number;
+    maxStringLength?: number;
+    maxSize?: number;
+    onError?: (error: unknown) => void;
+}
+/**
+ * Serializes a JS value to a JSON-compatible structure.
+ */
+export declare function toJSON<T>(obj: T, opts?: ToJSONOpts): SerializedValue;
+export {};
+//# sourceMappingURL=to-json.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-json.d.ts","sourceRoot":"","sources":["../../src/to-json/to-json.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,MAAM,SAAS,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,eAAe,CAAC;AAoB5D,UAAU,UAAU;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,GAAE,UAAe,GAAG,eAAe,CAwIxE"}

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

@@ -0,0 +1,141 @@
+import { isClass, serializeClass } from "./serialize-class.js";
+import { serializeDate } from "./serialize-date.js";
+import { serializeError } from "./serialize-error.js";
+import { serializeFunction } from "./serialize-function.js";
+import { serializeMap } from "./serialize-map.js";
+import { serializeObject } from "./serialize-object.js";
+import { serializeRegex } from "./serialize-regex.js";
+import { serializeSet } from "./serialize-set.js";
+import { BIG_INT, CIRCULAR_REFERENCE, MAX_DEPTH_REACHED, PROMISE, TOO_LARGE, UNDEFINED, UNKNOWN, } from "./to-json.constants.js";
+import { SERIALIZATION_ERROR } from "./to-json.constants.js";
+const hasProp = Object.prototype.hasOwnProperty;
+function throwsMessage(error) {
+    return "[Throws: " + (error instanceof Error ? error.message : "?") + "]";
+}
+function safeGetValue(obj, property) {
+    if (hasProp.call(obj, property)) {
+        try {
+            return obj[property];
+        }
+        catch (err) {
+            return throwsMessage(err);
+        }
+    }
+    return obj[property];
+}
+/**
+ * Serializes a JS value to a JSON-compatible structure.
+ */
+export function toJSON(obj, opts = {}) {
+    const seen = [];
+    const maxStringLength = opts.maxStringLength ?? 100000;
+    const maxSize = opts.maxSize ?? 500000;
+    const maxDepth = opts.maxDepth ?? 20;
+    let currentSize = 0;
+    function visit(obj, depth) {
+        try {
+            if (depth > maxDepth) {
+                return MAX_DEPTH_REACHED;
+            }
+            if (currentSize > maxSize) {
+                return TOO_LARGE;
+            }
+            if (obj === null ||
+                typeof obj === "boolean" ||
+                typeof obj === "number" ||
+                typeof obj === "string") {
+                const size = JSON.stringify(obj).length;
+                currentSize += size;
+                if (currentSize > maxSize) {
+                    return TOO_LARGE;
+                }
+                if (typeof obj === "string" && size > maxStringLength) {
+                    return (obj.substring(0, maxStringLength) +
+                        " [Output truncated due to length]");
+                }
+                return obj;
+            }
+            else if (typeof obj === "undefined") {
+                return UNDEFINED;
+            }
+            else if (typeof obj === "bigint") {
+                if (obj <= Number.MAX_SAFE_INTEGER && obj >= Number.MIN_SAFE_INTEGER) {
+                    return Number(obj);
+                }
+                return BIG_INT;
+            }
+            if (typeof obj === "symbol") {
+                return obj.toString();
+            }
+            if (typeof obj === "function") {
+                return isClass(obj) ? serializeClass(obj) : serializeFunction(obj);
+            }
+            if (obj instanceof Date) {
+                return serializeDate(obj);
+            }
+            if (obj instanceof Error) {
+                return serializeError(obj);
+            }
+            if (obj instanceof RegExp) {
+                return serializeRegex(obj);
+            }
+            if (obj instanceof Promise) {
+                return PROMISE;
+            }
+            if (seen.indexOf(obj) !== -1) {
+                return CIRCULAR_REFERENCE;
+            }
+            seen.push(obj);
+            if (obj instanceof Map) {
+                const result = serializeMap(obj, (value) => visit(value, depth + 1));
+                seen.pop();
+                return result;
+            }
+            if (obj instanceof Set) {
+                const result = serializeSet(obj, (value) => visit(value, depth + 1));
+                seen.pop();
+                return result;
+            }
+            if (Array.isArray(obj)) {
+                const aResult = obj.map((item) => visit(item, depth + 1));
+                seen.pop();
+                return aResult;
+            }
+            if (typeof obj === "object") {
+                if ("toJSON" in obj && typeof obj.toJSON === "function") {
+                    try {
+                        const fResult = visit(obj.toJSON(), depth + 1);
+                        seen.pop();
+                        return fResult;
+                    }
+                    catch (err) {
+                        return throwsMessage(err);
+                    }
+                }
+                const isPlainObject = Object.getPrototypeOf(obj) === Object.prototype;
+                if (!isPlainObject) {
+                    const result = serializeObject(obj, (value) => visit(value, depth + 1));
+                    seen.pop();
+                    return result;
+                }
+                const result = {};
+                for (const prop of Object.keys(obj)) {
+                    result[prop] = visit(safeGetValue(obj, prop), depth + 1);
+                }
+                seen.pop();
+                return result;
+            }
+            return UNKNOWN;
+        }
+        catch (error) {
+            try {
+                opts.onError?.(error);
+            }
+            catch {
+                // ignore
+            }
+            return SERIALIZATION_ERROR;
+        }
+    }
+    return visit(obj, 0);
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@capture.dev/event-logger",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "sideEffects": false,
+  "license": "MIT",
+  "homepage": "https://capture.dev",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./internal": {
+      "import": "./dist/index-internal.js",
+      "require": "./dist/index-internal.cjs"
+    }
+  },
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "lint": "eslint src/",
+    "lint:fix": "npm run lint -- --fix",
+    "build": "tsc",
+    "test": "vitest",
+    "clean": "rimraf dist"
+  },
+  "devDependencies": {
+    "@capture/vitest-config": "*",
+    "clean-publish": "^6.0.1",
+    "eslint": "^9.29.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.9"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "lint-staged": {
+    "**/*.{ts,tsx,js}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "**/*.{json,md,css,html}": "prettier --write"
+  },
+  "tscLib": "true",
+  "dependencies": {
+    "@capture.dev/fast-json-patch": "^3.2.1"
+  }
+}