easy-analytics 1.0.0

package/README.md

@@ -0,0 +1,113 @@
+# Easy Analytics
+
+A super minimalist, lite & easy, independent analytics tracker & visualizer for your custom web applications.
+
+Easy Analytics consists of three parts that work seamlessly together:
+1. **Client**: A lightweight browser script (~6 KB uncompressed, ~1.7 KB gzipped) tracking basic metrics (screens, duration, referrers, devices) without relying exclusively on tracking cookies.
+2. **Server**: Server-side integration storing the incoming logs effortlessly using `easy-db-node`.
+3. **React**: Helpful hooks and a minimalist unstyled UI component (`GroupTable`) for you to build your own dashboard quickly.
+
+## Philosophy
+
+- **Self-hosted**: Say goodbye to ad-blockers preventing analytics. The requests go straight to your backend.
+- **Privacy-first**: It groups users into temporary `sessionId` and permanent `localId` via `localStorage`/`sessionStorage` without obnoxious 3rd party tracker tracking.
+- **Minimalist setup**: No bloated dashboard or configuration pages unless you create them.
+
+---
+
+## 1. Client Integration
+
+Call `init` as early as possible in your application lifecycle (for example in your main React `index.tsx`, or inside `<script>` tag).
+
+```ts
+import { init, sendError } from "easy-analytics/client";
+
+// Initializes the tracker. 
+// 1st arg: path to the tracking endpoint
+// 2nd arg: token (optional)
+init("/api/easy-analytics", "token");
+
+// Example of manual error tracking
+try {
+    throw new Error("Something broke!");
+} catch (e) {
+    sendError(e);
+}
+```
+
+## 2. Server Integration
+
+You need a runtime (like `express.js`) to capture incoming events. Easy Analytics uses `easy-db-node` under the hood.
+
+```ts
+import express from "express";
+import { postEasyAnalytics, getEasyAnalytics, getEasyAnalyticsError } from "easy-analytics/server";
+
+const app = express();
+app.use(express.json()); // Need to parse JSON body
+
+app.post("/api/easy-analytics", async (req, res) => {
+    try {
+        const ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
+        const userAgent = req.headers['user-agent'] || "";
+        
+        // Pass body, userAgent, and IP. Optionally pass ipCountry if you resolve it
+        const responseData = await postEasyAnalytics(req.body, userAgent, ip, "US");
+        res.status(200).send(responseData);
+    } catch (e) {
+        res.status(400).send({ error: e.message });
+    }
+});
+
+// Endpoint to retrieve data for your React dashboard
+app.get("/api/easy-analytics-data", async (req, res) => {
+    // get records by passing month in YYYY-MM format
+    const records = await getEasyAnalytics("2026-04");
+    res.status(200).send(records);
+});
+```
+
+This will automatically track page visits, `visibilitychange` for session lengths, and handle basic errors automatically attaching to `window.onerror`.
+
+## 3. Visualization & React Hooks
+
+When it's time to analyze your data in an admin dashboard, `easy-analytics/react` provides utility hooks to process and group rows easily.
+
+The `<GroupTable />` component is 100% dependency-free and uses standard HTML tables.
+
+```tsx
+import React, { useEffect, useState } from "react";
+import { useGroup, GroupTable, getGroupedCount } from "easy-analytics/react";
+
+export function Dashboard() {
+    const [records, setRecords] = useState([]);
+
+    useEffect(() => {
+        fetch("/api/easy-analytics-data")
+            .then(res => res.json())
+            .then(data => setRecords(data));
+    }, []);
+
+    // Grouping examples
+    // 1. Group by pathname
+    const byURL = useGroup(records, r => new URL(r.url).pathname);
+    
+    // 2. Group by Referrer but count unique users (localId) instead of pure views
+    const byReferrer = useGroup(
+        records, 
+        r => r.referrer || "Direct", 
+        rs => getGroupedCount(rs, row => row.localId)
+    );
+
+    return (
+        <div>
+            <h1>Analytics Dashboard</h1>
+            
+            <div style={{ display: "flex", gap: "20px" }}>
+                <GroupTable title="Most Visited Pages" data={byURL} mainColor="#4287f5" />
+                <GroupTable title="Traffic Sources (Unique)" data={byReferrer} mainColor="#7dd421" />
+            </div>
+        </div>
+    );
+}
+```

package/dist/client.d.ts

@@ -0,0 +1,6 @@
+import { UUID } from "./common";
+export * from "./common";
+export declare function init(url?: string, token?: string): void;
+export declare function getLocalId(): UUID;
+export declare function getSessionId(): UUID;
+export declare function sendError(error: any, sendUrl?: string, token?: string): void;

package/dist/client.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+exports.getLocalId = getLocalId;
+exports.getSessionId = getSessionId;
+exports.sendError = sendError;
+const common_1 = require("./common");
+__exportStar(require("./common"), exports);
+const STORAGE_ID = "easyAnalyticsId";
+let easyAnalyticsUrl = "/api/easy-analytics";
+let easyAnalyticsToken = "";
+function init(url = easyAnalyticsUrl, token = easyAnalyticsToken) {
+    // not run on server site
+    if (typeof window === "undefined" || typeof document === "undefined")
+        return;
+    easyAnalyticsUrl = url;
+    easyAnalyticsToken = token;
+    let interval = setInterval(() => handleChangeUrl(url, token), 500);
+    document.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "visible") {
+            if (interval === null)
+                interval = setInterval(() => handleChangeUrl(url, token), 500);
+        }
+        else {
+            // leaving page or tab - can return
+            if (interval) {
+                handleLeave(url, token);
+                clearInterval(interval);
+                interval = null;
+            }
+        }
+    });
+    window.addEventListener("beforeunload", () => {
+        if (interval)
+            handleLeave(url, token);
+    });
+    // error handle
+    // window.onerror = (message, source, lineno, colno, error) => {
+    //     handleError(url, token, error || message);
+    // };
+    window.addEventListener("error", (event) => sendError(event.error, url, token));
+    window.addEventListener("unhandledrejection", (event) => sendError(event.reason, url, token));
+}
+let localId = null;
+function getLocalId() {
+    // not run on server site
+    if (typeof localStorage === "undefined")
+        return "server";
+    if (localId)
+        return localId;
+    localId = localStorage.getItem(STORAGE_ID);
+    if ((0, common_1.isUuidV4)(localId))
+        return localId;
+    localId = (0, common_1.generateUuidV4)();
+    localStorage.setItem(STORAGE_ID, localId);
+    return localId;
+}
+let sessionId = null;
+function getSessionId() {
+    // not run on server site
+    if (typeof sessionStorage === "undefined")
+        return "server";
+    if (sessionId)
+        return sessionId;
+    sessionId = sessionStorage.getItem(STORAGE_ID);
+    if ((0, common_1.isUuidV4)(sessionId))
+        return sessionId;
+    sessionId = (0, common_1.generateUuidV4)();
+    sessionStorage.setItem(STORAGE_ID, sessionId);
+    return sessionId;
+}
+let recordIdBefore = "";
+let urlBefore = "";
+function handleChangeUrl(sendUrl, token) {
+    const url = window.location.href;
+    if (url === urlBefore)
+        return;
+    const record = {
+        recordIdBefore,
+        localId: getLocalId(),
+        sessionId: getSessionId(),
+        localDate: (0, common_1.getDate)(),
+        url,
+        urlBefore,
+        referrer: document.referrer,
+        window: {
+            innerWidth: window.innerWidth,
+            innerHeight: window.innerHeight,
+            devicePixelRatio: window.devicePixelRatio,
+            screenWidth: window.screen.width,
+            screenHeight: window.screen.height,
+        },
+    };
+    urlBefore = url;
+    fetch(sendUrl + (token ? `?token=${encodeURIComponent(token)}` : ""), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(record),
+    })
+        .then(res => res.json())
+        .then(data => {
+        if (data && typeof data === "object" && typeof data.id === "string" && data.id) {
+            recordIdBefore = data.id;
+        }
+        else {
+            console.warn("Easy Analytics problem with receiving data to server");
+        }
+    })
+        .catch(() => {
+        console.warn("Easy Analytics problem with receiving data to server");
+    });
+}
+function handleLeave(sendUrl, token) {
+    const record = {
+        recordIdBefore,
+        localId: getLocalId(),
+        sessionId: getSessionId(),
+        localDate: (0, common_1.getDate)(),
+    };
+    const send = navigator.sendBeacon(sendUrl + (token ? `?token=${encodeURIComponent(token)}` : ""), new Blob([JSON.stringify(record)], { type: "application/json" }));
+    if (!send) {
+        console.warn("Easy Analytics problem with sending data to server");
+    }
+}
+function sendError(error, sendUrl = easyAnalyticsUrl, token = easyAnalyticsToken) {
+    let name;
+    let message = "";
+    let stack;
+    if (error instanceof Error) {
+        name = error.name;
+        message = error.message;
+        stack = error.stack;
+    }
+    else if (typeof error === "string") {
+        message = error;
+    }
+    else {
+        message = JSON.stringify(error);
+    }
+    const record = {
+        localId: getLocalId(),
+        sessionId: getSessionId(),
+        url: window.location.href,
+        localDate: (0, common_1.getDate)(),
+        error: { name, message, stack },
+    };
+    fetch(sendUrl + (token ? `?token=${encodeURIComponent(token)}` : ""), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(record),
+    })
+        .then(res => res.json())
+        .then(data => {
+        if (!data || typeof data !== "object" || typeof data.id !== "string" && !data.id)
+            console.warn("Easy Analytics problem with receiving data to server");
+    })
+        .catch(() => {
+        console.warn("Easy Analytics problem with receiving data to server");
+    });
+}

package/dist/common.d.ts

@@ -0,0 +1,46 @@
+export type UUID = string;
+export type AnalysisRecord = {
+    recordIdBefore: string;
+    localId: UUID;
+    sessionId: UUID;
+    serverDate: string;
+    localDate: string;
+    localDateLeft?: string;
+    ip: string;
+    ipCountry?: string;
+    userAgent: string;
+    url: string;
+    urlBefore: string;
+    referrer: string;
+    window: {
+        innerWidth: number;
+        innerHeight: number;
+        devicePixelRatio: number;
+        screenWidth: number;
+        screenHeight: number;
+    };
+};
+export type AnalysisRecordBrowser = Omit<AnalysisRecord, "ip" | "userAgent" | "serverDate" | "localDateLeft">;
+export type AnalysisLeaveRecordBrowser = {
+    recordIdBefore: string;
+    localId: UUID;
+    sessionId: UUID;
+    localDate: string;
+};
+export type AnalysisErrorRecord = AnalysisErrorRecordBrowser & {
+    serverDate: string;
+};
+export type AnalysisErrorRecordBrowser = {
+    localId: UUID;
+    sessionId: UUID;
+    url: string;
+    localDate: string;
+    error: {
+        name?: string;
+        message: string;
+        stack?: string;
+    };
+};
+export declare function getDate(date?: Date): string;
+export declare function isUuidV4(id: unknown): id is UUID;
+export declare function generateUuidV4(): UUID;

package/dist/common.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDate = getDate;
+exports.isUuidV4 = isUuidV4;
+exports.generateUuidV4 = generateUuidV4;
+function getDate(date = new Date()) {
+    const offset = date.getTimezoneOffset();
+    const offsetHours = Math.abs(Math.floor(offset / 60));
+    const offsetMinutes = Math.abs(offset % 60);
+    const offsetString = (offset > 0 ? '-' : '+') + offsetHours.toFixed(0).padStart(2, '0') + ':' + offsetMinutes.toFixed(0).padStart(2, '0');
+    return date.toISOString().replace('Z', offsetString);
+}
+function isUuidV4(id) {
+    if (id
+        && typeof id === "string"
+        && id.length === 36
+        && id.charAt(8) === "-"
+        && id.charAt(13) === "-"
+        && id.charAt(18) === "-"
+        && id.charAt(23) === "-"
+        && id.charAt(14) === "4")
+        return true;
+    return false;
+}
+function generateUuidV4() {
+    if (window.crypto && window.crypto.randomUUID) {
+        return window.crypto.randomUUID();
+    }
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0;
+        const v = c == 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+}

package/dist/react.d.ts

@@ -0,0 +1,12 @@
+export type GroupLog<T> = {
+    key: string;
+    records: T[];
+    count: number;
+};
+export declare function useGroup<T>(log: T[], cb: (l: T) => string, cbCount?: (l: T[]) => number): GroupLog<T>[];
+export declare function getGroupedCount<T>(records: T[], cb: (r: T) => string): number;
+export declare function GroupTable<T>({ title, data, mainColor }: {
+    title: string;
+    data: GroupLog<T>[];
+    mainColor?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/react.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGroup = useGroup;
+exports.getGroupedCount = getGroupedCount;
+exports.GroupTable = GroupTable;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+function useGroup(log, cb, cbCount = (l) => l.length) {
+    return (0, react_1.useMemo)(() => {
+        // Fallback for environments where Object.groupBy might not be available yet
+        const group = Object.groupBy ? Object.groupBy(log, cb) : fallbackGroupBy(log, cb);
+        return Object.entries(group)
+            .map(([key, records]) => ({ key, records: records || [], count: cbCount(records || []) }))
+            .sort((a, b) => b.count - a.count);
+    }, [log]);
+}
+function fallbackGroupBy(log, cb) {
+    const group = {};
+    for (const item of log) {
+        const key = cb(item);
+        if (!group[key])
+            group[key] = [];
+        group[key].push(item);
+    }
+    return group;
+}
+function getGroupedCount(records, cb) {
+    const group = Object.groupBy ? Object.groupBy(records, cb) : fallbackGroupBy(records, cb);
+    return Object.keys(group).length;
+}
+function GroupTable({ title, data, mainColor = "#7dd421" }) {
+    const max = Math.max(0, ...data.map(d => d.count));
+    const sum = data.reduce((a, b) => a + b.count, 0);
+    return (0, jsx_runtime_1.jsxs)("div", { style: { width: "100%", maxWidth: "600px", marginBottom: "32px", fontFamily: "sans-serif" }, children: [(0, jsx_runtime_1.jsx)("h2", { style: { paddingTop: "20px", marginBottom: "8px" }, children: title }), (0, jsx_runtime_1.jsxs)("p", { style: { margin: "0 0 16px 0", fontSize: "14px", color: "#666" }, children: ["Z\u00E1znamy: ", Object.keys(data).length] }), (0, jsx_runtime_1.jsxs)("table", { style: { width: "100%", borderCollapse: "collapse" }, children: [(0, jsx_runtime_1.jsx)("thead", { children: (0, jsx_runtime_1.jsxs)("tr", { children: [(0, jsx_runtime_1.jsx)("th", { style: { textAlign: "left", paddingBottom: "8px", width: "150px" }, children: "Po\u010Det" }), (0, jsx_runtime_1.jsx)("th", { style: { textAlign: "left", paddingBottom: "8px" }, children: "Polo\u017Eka" })] }) }), (0, jsx_runtime_1.jsx)("tbody", { children: data.map(r => (0, jsx_runtime_1.jsxs)("tr", { children: [(0, jsx_runtime_1.jsxs)("td", { style: { position: "relative", padding: "4px 0", minWidth: "150px" }, children: [(0, jsx_runtime_1.jsx)("div", { style: { position: "absolute", zIndex: 1, width: `${max > 0 ? (r.count / max * 100) : 0}%`, left: "0px", top: "4px", bottom: "4px", backgroundColor: mainColor, borderRadius: "4px", opacity: 0.8 } }), (0, jsx_runtime_1.jsxs)("div", { style: { position: "relative", zIndex: 2, paddingLeft: "8px", fontWeight: "bold" }, children: [r.count, " ", (0, jsx_runtime_1.jsxs)("span", { style: { fontWeight: "normal", fontSize: "0.85em", opacity: 0.8 }, children: ["(", sum > 0 ? Math.round(r.count / sum * 100) : 0, "%)"] })] })] }), (0, jsx_runtime_1.jsx)("td", { style: { padding: "4px 8px" }, children: (0, jsx_runtime_1.jsx)("div", { style: { whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis", maxWidth: "400px" }, title: r.key, children: r.key }) })] }, r.key)) })] })] });
+}

package/dist/server.d.ts

@@ -0,0 +1,15 @@
+import { AnalysisErrorRecordBrowser, AnalysisRecord } from "./common";
+type Month = string;
+export * from "./common";
+export declare function postEasyAnalytics(body: unknown, userAgent: string, ip: string, ipCountry?: string): Promise<{
+    id: string;
+}>;
+export declare function getEasyAnalytics(month: Month): Promise<(AnalysisRecord & {
+    _id: import("easy-db-core").Id;
+})[]>;
+export declare function getEasyAnalyticsError(month: Month): Promise<(AnalysisErrorRecordBrowser & {
+    serverDate: string;
+} & {
+    _id: import("easy-db-core").Id;
+})[]>;
+export declare function updateEasyAnalyticsRecord(month: Month, recordId: string, record: AnalysisRecord): Promise<void>;

package/dist/server.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postEasyAnalytics = postEasyAnalytics;
+exports.getEasyAnalytics = getEasyAnalytics;
+exports.getEasyAnalyticsError = getEasyAnalyticsError;
+exports.updateEasyAnalyticsRecord = updateEasyAnalyticsRecord;
+const easy_db_node_1 = __importDefault(require("easy-db-node"));
+const common_1 = require("./common");
+const { insert, select, selectArray, update, remove } = (0, easy_db_node_1.default)({});
+__exportStar(require("./common"), exports);
+async function postEasyAnalytics(body, userAgent, ip, ipCountry) {
+    const recordBrowser = getAnalysisRecordBrowser(body);
+    if (recordBrowser) {
+        const serverDate = (0, common_1.getDate)();
+        if (recordBrowser.recordIdBefore) {
+            await updateLeaveRecord(recordBrowser.recordIdBefore, recordBrowser.localDate);
+        }
+        const id = await insert(getCollection(serverDate), {
+            ...recordBrowser,
+            ip,
+            ipCountry,
+            userAgent,
+            serverDate,
+        });
+        return { id };
+    }
+    const leaveRecordBrowser = getAnalysisLeaveRecordBrowser(body);
+    if (leaveRecordBrowser)
+        return await updateLeaveRecord(leaveRecordBrowser.recordIdBefore, leaveRecordBrowser.localDate);
+    const errorRecordBrowser = getAnalysisErrorRecordBrowser(body);
+    if (errorRecordBrowser)
+        return {
+            id: await insert(getErrorCollection(errorRecordBrowser.localDate), {
+                ...errorRecordBrowser,
+                serverDate: (0, common_1.getDate)(),
+            })
+        };
+    throw new Error("Easy Analytics data are not valid");
+}
+async function getEasyAnalytics(month) {
+    return selectArray(getCollection(month));
+}
+async function getEasyAnalyticsError(month) {
+    return selectArray(getErrorCollection(month));
+}
+async function updateEasyAnalyticsRecord(month, recordId, record) {
+    await update(getCollection(month), recordId, record);
+}
+async function updateLeaveRecord(recordIdBefore, date) {
+    const collection = getCollection(date);
+    const record = await select(collection, recordIdBefore);
+    // TODO: check month back
+    if (!record) {
+        console.error(new Error("Easy Analytic leave record not found"));
+        return { id: recordIdBefore };
+    }
+    // TODO: check localId and more
+    await update(collection, record._id, {
+        ...record,
+        localDateLeft: date,
+    });
+    return { id: record._id };
+}
+function getCollection(date) {
+    return `easyAnalytics-${getMonth(date)}`;
+}
+function getErrorCollection(date) {
+    return `easyAnalyticsError-${getMonth(date)}`;
+}
+function getMonth(date = (0, common_1.getDate)()) {
+    return date.slice(0, 7);
+}
+function getAnalysisLeaveRecordBrowser(d) {
+    if (d !== null
+        && typeof d === "object"
+        && typeof d.recordIdBefore === "string"
+        && typeof d.localId === "string" && d.localId
+        && typeof d.sessionId === "string" && d.sessionId
+        && typeof d.localDate === "string" && d.localDate
+        && typeof d.url === "undefined")
+        return {
+            recordIdBefore: d.recordIdBefore,
+            localId: d.localId,
+            sessionId: d.sessionId,
+            localDate: d.localDate,
+        };
+    return null;
+}
+function getAnalysisRecordBrowser(d) {
+    if (d !== null
+        && typeof d === "object"
+        && typeof d.recordIdBefore === "string"
+        && typeof d.localId === "string" && d.localId
+        && typeof d.sessionId === "string" && d.sessionId
+        && typeof d.localDate === "string" && d.localDate
+        && typeof d.url === "string" && d.url
+        && typeof d.urlBefore === "string"
+        && typeof d.referrer === "string"
+        && typeof d.window === "object" && d.window
+        && typeof d.window.innerWidth === "number"
+        && typeof d.window.innerHeight === "number"
+        && typeof d.window.devicePixelRatio === "number"
+        && typeof d.window.screenWidth === "number"
+        && typeof d.window.screenHeight === "number")
+        return {
+            recordIdBefore: d.recordIdBefore,
+            localId: d.localId,
+            sessionId: d.sessionId,
+            localDate: d.localDate,
+            url: d.url,
+            urlBefore: d.urlBefore,
+            referrer: d.referrer,
+            window: {
+                innerWidth: d.window.innerWidth,
+                innerHeight: d.window.innerHeight,
+                devicePixelRatio: d.window.devicePixelRatio,
+                screenWidth: d.window.screenWidth,
+                screenHeight: d.window.screenHeight,
+            },
+        };
+    return null;
+}
+function getAnalysisErrorRecordBrowser(d) {
+    if (d !== null
+        && typeof d === "object"
+        && typeof d.localId === "string" && d.localId
+        && typeof d.sessionId === "string" && d.sessionId
+        && typeof d.localDate === "string" && d.localDate
+        && typeof d.url === "string"
+        && d.error
+        && typeof d.error === "object"
+        && typeof d.error.message === "string"
+        && (typeof d.error.name === "string" || typeof d.error.name === "undefined")
+        && (typeof d.error.stack === "string" || typeof d.error.stack === "undefined"))
+        return {
+            localId: d.localId,
+            sessionId: d.sessionId,
+            url: d.url,
+            localDate: d.localDate,
+            error: {
+                name: d.error.name,
+                message: d.error.message,
+                stack: d.error.stack,
+            },
+        };
+    return null;
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "easy-analytics",
+  "version": "1.0.0",
+  "description": "Minimalist analytics tracker and visualizer with client and server integration.",
+  "main": "dist/server.js",
+  "types": "dist/common.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/common.d.ts",
+      "import": "./dist/client.js",
+      "require": "./dist/server.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "default": "./dist/client.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "default": "./dist/react.js"
+    }
+  },
+  "scripts": {
+    "build": "npx tsc"
+  },
+  "dependencies": {
+    "easy-db-node": "^3.0.0"
+  },
+  "peerDependencies": {
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+    "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "typescript": "^5.x.x"
+  },
+  "author": "Filip Paulů <ing.fenix@seznam.cz>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ingSlonik/easy-analytics.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ingSlonik/easy-analytics/issues"
+  },
+  "license": "MIT"
+}