heimdall-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+import { type HeimdallConfig } from './interceptor.js';
+interface HeimdallProviderProps extends HeimdallConfig {
+    children: ReactNode;
+    enabled?: boolean;
+}
+export declare function HeimdallProvider({ children, collectorUrl, project, ignore, enabled, }: HeimdallProviderProps): import("react/jsx-runtime").JSX.Element;
+export type { HeimdallConfig };

package/dist/index.js

@@ -0,0 +1,12 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect } from 'react';
+import { patchFetch, unpatchFetch } from './interceptor.js';
+export function HeimdallProvider({ children, collectorUrl, project = 'default', ignore = [], enabled = true, }) {
+    useEffect(() => {
+        if (!enabled)
+            return;
+        patchFetch({ collectorUrl, project, ignore });
+        return () => unpatchFetch();
+    }, [collectorUrl, project, enabled]); // eslint-disable-line react-hooks/exhaustive-deps
+    return _jsx(_Fragment, { children: children });
+}

package/dist/interceptor.d.ts

@@ -0,0 +1,7 @@
+export interface HeimdallConfig {
+    collectorUrl: string;
+    project?: string;
+    ignore?: (string | RegExp)[];
+}
+export declare function patchFetch(config: HeimdallConfig): void;
+export declare function unpatchFetch(): void;

package/dist/interceptor.js

@@ -0,0 +1,92 @@
+function shouldIgnore(url, patterns) {
+    return patterns.some(p => typeof p === 'string' ? url.includes(p) : p.test(url));
+}
+function sendLog(collectorUrl, payload) {
+    // Use the original fetch before we patch it
+    const f = window.__heimdall_fetch;
+    f(`${collectorUrl}/collect`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+    }).catch(() => {
+        // Silently fail — never break the app
+    });
+}
+export function patchFetch(config) {
+    const original = window.fetch.bind(window);
+    window.__heimdall_fetch = original;
+    window.fetch = async (input, init) => {
+        const url = typeof input === 'string'
+            ? input
+            : input instanceof URL
+                ? input.href
+                : input.url;
+        // Never intercept our own collector calls
+        if (url.startsWith(config.collectorUrl))
+            return original(input, init);
+        if (config.ignore && shouldIgnore(url, config.ignore))
+            return original(input, init);
+        const method = init?.method?.toUpperCase() ?? (input instanceof Request ? input.method : 'GET');
+        const requestBody = init?.body;
+        let requestBodyParsed = null;
+        if (requestBody) {
+            try {
+                requestBodyParsed = JSON.parse(requestBody);
+            }
+            catch {
+                requestBodyParsed = String(requestBody);
+            }
+        }
+        const requestHeaders = Object.fromEntries(new Headers(init?.headers ?? (input instanceof Request ? input.headers : {})).entries());
+        const start = performance.now();
+        let response;
+        try {
+            response = await original(input, init);
+        }
+        catch (err) {
+            sendLog(config.collectorUrl, {
+                method,
+                url,
+                error: String(err),
+                duration_ms: Math.round(performance.now() - start),
+                request_headers: requestHeaders,
+                request_body: requestBodyParsed,
+                project: config.project ?? 'default',
+                timestamp: new Date().toISOString(),
+            });
+            throw err;
+        }
+        const duration = Math.round(performance.now() - start);
+        const cloned = response.clone();
+        let responseBody = null;
+        try {
+            const text = await cloned.text();
+            try {
+                responseBody = JSON.parse(text);
+            }
+            catch {
+                responseBody = text;
+            }
+        }
+        catch { /* ignore */ }
+        const responseHeaders = Object.fromEntries(response.headers.entries());
+        sendLog(config.collectorUrl, {
+            method,
+            url,
+            status_code: response.status,
+            duration_ms: duration,
+            request_headers: requestHeaders,
+            request_body: requestBodyParsed,
+            response_headers: responseHeaders,
+            response_body: responseBody,
+            project: config.project ?? 'default',
+            timestamp: new Date().toISOString(),
+        });
+        return response;
+    };
+}
+export function unpatchFetch() {
+    const original = window.__heimdall_fetch;
+    if (original)
+        window.fetch = original;
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "heimdall-sdk",
+  "version": "0.1.0",
+  "description": "Heimdall SDK — zero-config API logger for React",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "peerDependencies": {
+    "react": ">=17"
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.2",
+    "typescript": "^5.8.3"
+  }
+}