@getvision/core 0.0.0 → 0.0.1

package/dist/__tests__/core.test.d.ts

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

package/dist/__tests__/core.test.d.ts.map

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

package/dist/__tests__/core.test.js

@@ -0,0 +1,88 @@
+import { describe, test, expect } from 'bun:test';
+import { VisionCore } from '../core';
+describe('VisionCore (without server)', () => {
+    test('should create and complete trace', () => {
+        const vision = new VisionCore({
+            port: 0,
+            maxTraces: 100,
+            captureConsole: false
+        });
+        const trace = vision.createTrace('GET', '/test');
+        expect(trace).toBeDefined();
+        expect(trace.id).toBeDefined();
+        // Complete trace
+        vision.completeTrace(trace.id, 200, 50);
+        // Retrieve trace from store
+        const retrieved = vision.getTraceStore().getTrace(trace.id);
+        expect(retrieved).toBeDefined();
+    });
+    test('should use tracer', () => {
+        const vision = new VisionCore({ port: 0, captureConsole: false });
+        const tracer = vision.getTracer();
+        expect(tracer).toBeDefined();
+    });
+    test('should create span helper', () => {
+        const vision = new VisionCore({ port: 0, captureConsole: false });
+        const trace = vision.createTrace('GET', '/test');
+        const withSpan = vision.createSpanHelper(trace.id);
+        const result = withSpan('test.operation', { 'test.attr': 'value' }, () => {
+            return 'test result';
+        });
+        expect(result).toBe('test result');
+        // Check span was added
+        const retrieved = vision.getTraceStore().getTrace(trace.id);
+        expect(retrieved?.spans.length).toBeGreaterThan(0);
+        expect(retrieved?.spans[0].name).toBe('test.operation');
+    });
+    test('should handle errors in span helper', () => {
+        const vision = new VisionCore({ port: 0, captureConsole: false });
+        const trace = vision.createTrace('GET', '/test');
+        const withSpan = vision.createSpanHelper(trace.id);
+        expect(() => {
+            withSpan('test.error', {}, () => {
+                throw new Error('Test error');
+            });
+        }).toThrow('Test error');
+        // Check error was recorded in span
+        const retrieved = vision.getTraceStore().getTrace(trace.id);
+        const errorSpan = retrieved?.spans[0];
+        expect(errorSpan?.attributes?.error).toBe(true);
+        expect(errorSpan?.attributes?.['error.message']).toBe('Test error');
+    });
+    test('should register routes', () => {
+        const vision = new VisionCore({ port: 0, captureConsole: false });
+        const routes = [
+            { method: 'GET', path: '/users', handler: 'getUsers' },
+            { method: 'POST', path: '/users', handler: 'createUser' },
+        ];
+        vision.registerRoutes(routes);
+        // Routes are registered, no easy way to verify without getter
+        expect(true).toBe(true);
+    });
+    test('should set app status', () => {
+        const vision = new VisionCore({ port: 0, captureConsole: false });
+        vision.setAppStatus({
+            name: 'Test App',
+            version: '1.0.0',
+            environment: 'test',
+            running: true,
+        });
+        expect(true).toBe(true);
+    });
+    test('should log messages', () => {
+        const vision = new VisionCore({ port: 0, captureConsole: false });
+        const entry = vision.log('info', 'Test log message', { key: 'value' });
+        expect(entry).toBeDefined();
+        expect(entry.level).toBe('info');
+        expect(entry.message).toBe('Test log message');
+    });
+    test('should broadcast events', () => {
+        const vision = new VisionCore({ port: 0, captureConsole: false });
+        // Just test that broadcast doesn't throw
+        vision.broadcast({
+            type: 'log.entry',
+            data: { id: "id", message: 'hello', level: "info", timestamp: Date.now() }
+        });
+        expect(true).toBe(true);
+    });
+});

package/dist/__tests__/tracing.test.d.ts

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

package/dist/__tests__/tracing.test.d.ts.map

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

package/dist/__tests__/tracing.test.js

@@ -0,0 +1,108 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { TraceStore, Tracer } from '../tracing/index';
+describe('TraceStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new TraceStore(100);
+    });
+    test('should add trace', () => {
+        const trace = {
+            id: '123',
+            timestamp: Date.now(),
+            spans: [],
+            method: 'GET',
+            path: '/test',
+            metadata: {},
+        };
+        store.addTrace(trace);
+        const retrieved = store.getTrace('123');
+        expect(retrieved).toBeDefined();
+        expect(retrieved?.id).toBe('123');
+        expect(retrieved?.path).toBe('/test');
+        expect(retrieved?.method).toBe('GET');
+    });
+    test('should get traces with filters', () => {
+        const trace1 = {
+            id: '1',
+            method: 'GET',
+            path: '/users',
+            statusCode: 200,
+            timestamp: Date.now(),
+            spans: [],
+            metadata: {},
+        };
+        const trace2 = {
+            id: '2',
+            timestamp: Date.now(),
+            spans: [],
+            metadata: {},
+            method: 'POST',
+            path: '/users',
+            statusCode: 201
+        };
+        store.addTrace(trace1);
+        store.addTrace(trace2);
+        const getTraces = store.getTraces({ method: 'GET' });
+        expect(getTraces.length).toBe(1);
+        expect(getTraces[0].id).toBe('1');
+        const postTraces = store.getTraces({ method: 'POST' });
+        expect(postTraces.length).toBe(1);
+        expect(postTraces[0].id).toBe('2');
+    });
+    test('should limit number of traces', () => {
+        const smallStore = new TraceStore(2);
+        for (let i = 0; i < 5; i++) {
+            smallStore.addTrace({
+                id: `trace-${i}`,
+                timestamp: Date.now(),
+                method: "GET",
+                path: '/test',
+                spans: [],
+            });
+        }
+        const traces = smallStore.getAllTraces();
+        expect(traces.length).toBeLessThanOrEqual(2);
+    });
+    test('should clear all traces', () => {
+        store.addTrace({
+            id: '1',
+            timestamp: Date.now(),
+            method: "GET",
+            path: '/test',
+            spans: [],
+        });
+        store.clear();
+        const traces = store.getAllTraces();
+        expect(traces.length).toBe(0);
+    });
+    test('should filter by status code', () => {
+        store.addTrace({
+            id: '1',
+            timestamp: Date.now(),
+            spans: [],
+            method: "GET",
+            path: '/test',
+            statusCode: 200,
+            metadata: {},
+        });
+        store.addTrace({
+            id: '2',
+            timestamp: Date.now(),
+            spans: [],
+            method: "GET",
+            path: '/test2',
+            statusCode: 200,
+            metadata: {},
+        });
+        const successTraces = store.getTraces({ statusCode: 200 });
+        expect(successTraces.length).toBe(2);
+        expect(successTraces[0]?.statusCode).toBe(200);
+        expect(successTraces[1]?.statusCode).toBe(200);
+    });
+});
+describe('Tracer', () => {
+    test('should create tracer instance', () => {
+        const tracer = new Tracer();
+        expect(tracer).toBeDefined();
+    });
+});

package/dist/core.d.ts

@@ -0,0 +1,98 @@
+import { VisionWebSocketServer } from './server';
+import { TraceStore, Tracer } from './tracing';
+import { LogStore } from './logs/store';
+import type { VisionServerOptions, AppStatus, RouteMetadata, ServiceGroup, Trace, DashboardEvent, LogLevel, LogEntry } from './types/index';
+/**
+ * VisionCore - Main orchestrator for the Vision Dashboard
+ */
+export declare class VisionCore {
+    private server;
+    private traceStore;
+    private tracer;
+    private logStore;
+    private consoleInterceptor?;
+    private routes;
+    private services;
+    private appStatus;
+    constructor(options?: VisionServerOptions);
+    /**
+     * Register all JSON-RPC methods
+     */
+    private registerMethods;
+    /**
+     * Update app status
+     */
+    setAppStatus(status: Partial<AppStatus>): void;
+    /**
+     * Register routes from adapter
+     */
+    registerRoutes(routes: RouteMetadata[]): void;
+    /**
+     * Register grouped services
+     */
+    registerServices(services: ServiceGroup[]): void;
+    /**
+     * Create a new trace
+     */
+    createTrace(method: string, path: string): Trace;
+    /**
+     * Complete a trace
+     */
+    completeTrace(traceId: string, statusCode: number, duration: number): void;
+    /**
+     * Get tracer instance
+     */
+    getTracer(): Tracer;
+    /**
+     * Get WebSocket server instance (for registering JSON-RPC methods)
+     */
+    getServer(): VisionWebSocketServer;
+    /**
+     * Create a span helper for easy span creation
+     * @param traceId - Trace ID to attach spans to
+     * @returns A function that creates spans with automatic error handling
+     *
+     * @example
+     * ```ts
+     * const withSpan = vision.createSpanHelper(traceId)
+     *
+     * const user = withSpan('db.select', { 'db.system': 'sqlite' }, () => {
+     *   return db.select().from(users).get()
+     * })
+     * ```
+     */
+    createSpanHelper(traceId: string): <T>(name: string, attributes: Record<string, any> | undefined, fn: () => T) => T;
+    /**
+     * Get trace store
+     */
+    getTraceStore(): TraceStore;
+    /**
+     * Universal log API - can be called by any logger
+     */
+    log(level: LogLevel, message: string, meta?: Record<string, any>): LogEntry;
+    /**
+     * Get log store instance
+     */
+    getLogStore(): LogStore;
+    /**
+     * Broadcast event to all connected clients
+     */
+    broadcast(event: DashboardEvent): void;
+    /**
+     * Log stdout message
+     */
+    logStdout(message: string): void;
+    /**
+     * Log stderr message
+     */
+    logStderr(message: string): void;
+    /**
+     * Get number of connected dashboard clients
+     */
+    getClientCount(): number;
+    /**
+     * Close the Vision server
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEvC,OAAO,KAAK,EACV,mBAAmB,EACnB,SAAS,EACT,aAAa,EACb,YAAY,EACZ,KAAK,EACL,cAAc,EACd,QAAQ,EACR,QAAQ,EACT,MAAM,eAAe,CAAA;AAEtB;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,QAAQ,CAAU;IAC1B,OAAO,CAAC,kBAAkB,CAAC,CAAoB;IAC/C,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,SAAS,CAKhB;gBAEW,OAAO,GAAE,mBAAwB;IAwB7C;;OAEG;IACH,OAAO,CAAC,eAAe;IA0FvB;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI;IAK9C;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI;IAI7C;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIhD;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK;IAKhD;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAS1E;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,SAAS,IAAI,qBAAqB;IAIlC;;;;;;;;;;;;;OAaG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,IACtB,CAAC,EACP,MAAM,MAAM,EACZ,YAAY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YAAK,EACpC,IAAI,MAAM,CAAC,KACV,CAAC;IAqCN;;OAEG;IACH,aAAa,IAAI,UAAU;IAI3B;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,QAAQ;IAU3E;;OAEG;IACH,WAAW,IAAI,QAAQ;IAIvB;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAItC;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAOhC;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAOhC;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/core.js

@@ -0,0 +1,266 @@
+import { VisionWebSocketServer } from './server';
+import { TraceStore, Tracer } from './tracing';
+import { LogStore } from './logs/store';
+import { ConsoleInterceptor } from './logs/interceptor';
+/**
+ * VisionCore - Main orchestrator for the Vision Dashboard
+ */
+export class VisionCore {
+    server;
+    traceStore;
+    tracer;
+    logStore;
+    consoleInterceptor;
+    routes = [];
+    services = [];
+    appStatus = {
+        name: 'Unknown',
+        version: '0.0.0',
+        environment: 'development',
+        running: false,
+    };
+    constructor(options = {}) {
+        this.server = new VisionWebSocketServer(options);
+        this.traceStore = new TraceStore(options.maxTraces);
+        this.tracer = new Tracer();
+        this.logStore = new LogStore(options.maxLogs);
+        // Optional console intercept
+        if (options.captureConsole !== false) {
+            this.consoleInterceptor = new ConsoleInterceptor(this.logStore, () => {
+                // Broadcast latest log entry to connected clients
+                this.broadcast({
+                    type: 'log.entry',
+                    data: this.logStore.getLogs({ limit: 1 })[0]
+                });
+            });
+            this.consoleInterceptor.start();
+        }
+        this.registerMethods();
+    }
+    /**
+     * Register all JSON-RPC methods
+     */
+    registerMethods() {
+        // App status
+        this.server.registerMethod('status', async () => {
+            return this.appStatus;
+        });
+        // List all traces
+        this.server.registerMethod('traces/list', async (params) => {
+            return this.traceStore.getTraces({
+                method: params?.method,
+                statusCode: params?.statusCode,
+                minDuration: params?.minDuration,
+                limit: params?.limit ?? 100,
+            });
+        });
+        // Get specific trace
+        this.server.registerMethod('traces/get', async (params) => {
+            if (!params?.traceId) {
+                throw new Error('traceId is required');
+            }
+            return this.traceStore.getTrace(params.traceId);
+        });
+        // Clear traces
+        this.server.registerMethod('traces/clear', async () => {
+            this.traceStore.clear();
+            return { success: true };
+        });
+        // Export traces
+        this.server.registerMethod('traces/export', async (params) => {
+            const format = params?.format || 'json';
+            const traces = this.traceStore.getAllTraces();
+            if (format === 'ndjson') {
+                return traces.map(t => JSON.stringify(t)).join('\n');
+            }
+            return JSON.stringify(traces, null, 2);
+        });
+        // Get routes
+        this.server.registerMethod('routes/list', async () => {
+            return this.routes;
+        });
+        // Get services (grouped routes)
+        this.server.registerMethod('services/list', async () => {
+            return this.services;
+        });
+        // Get version
+        this.server.registerMethod('version', async () => {
+            return {
+                version: '0.0.1',
+                name: 'Vision Dashboard',
+            };
+        });
+        // Logs methods
+        this.server.registerMethod('logs/list', async (params) => {
+            return this.logStore.getLogs({
+                level: params?.level,
+                search: params?.search,
+                limit: params?.limit ?? 100,
+                since: params?.since,
+            });
+        });
+        this.server.registerMethod('logs/clear', async () => {
+            this.logStore.clear();
+            return { success: true };
+        });
+        this.server.registerMethod('traces/addClientMetrics', async (params) => {
+            const { traceId, clientDuration } = params;
+            if (!traceId || typeof clientDuration !== 'number') {
+                throw new Error('traceId and clientDuration are required');
+            }
+            const trace = this.traceStore.getTrace(traceId);
+            if (trace) {
+                trace.metadata = { ...(trace.metadata || {}), clientDuration };
+            }
+            return { success: true };
+        });
+    }
+    /**
+     * Update app status
+     */
+    setAppStatus(status) {
+        this.appStatus = { ...this.appStatus, ...status };
+        this.broadcast({ type: 'app.started', data: this.appStatus });
+    }
+    /**
+     * Register routes from adapter
+     */
+    registerRoutes(routes) {
+        this.routes = routes;
+    }
+    /**
+     * Register grouped services
+     */
+    registerServices(services) {
+        this.services = services;
+    }
+    /**
+     * Create a new trace
+     */
+    createTrace(method, path) {
+        const trace = this.traceStore.createTrace(method, path);
+        return trace;
+    }
+    /**
+     * Complete a trace
+     */
+    completeTrace(traceId, statusCode, duration) {
+        this.traceStore.completeTrace(traceId, statusCode, duration);
+        const trace = this.traceStore.getTrace(traceId);
+        if (trace) {
+            this.broadcast({ type: 'trace.new', data: trace });
+        }
+    }
+    /**
+     * Get tracer instance
+     */
+    getTracer() {
+        return this.tracer;
+    }
+    /**
+     * Get WebSocket server instance (for registering JSON-RPC methods)
+     */
+    getServer() {
+        return this.server;
+    }
+    /**
+     * Create a span helper for easy span creation
+     * @param traceId - Trace ID to attach spans to
+     * @returns A function that creates spans with automatic error handling
+     *
+     * @example
+     * ```ts
+     * const withSpan = vision.createSpanHelper(traceId)
+     *
+     * const user = withSpan('db.select', { 'db.system': 'sqlite' }, () => {
+     *   return db.select().from(users).get()
+     * })
+     * ```
+     */
+    createSpanHelper(traceId) {
+        return (name, attributes = {}, fn) => {
+            const span = this.tracer.startSpan(name, traceId);
+            // Add attributes
+            for (const [key, value] of Object.entries(attributes)) {
+                this.tracer.setAttribute(span.id, key, value);
+            }
+            try {
+                const result = fn();
+                const completedSpan = this.tracer.endSpan(span.id);
+                // Add span to trace store
+                if (completedSpan) {
+                    this.traceStore.addSpan(traceId, completedSpan);
+                }
+                return result;
+            }
+            catch (error) {
+                this.tracer.setAttribute(span.id, 'error', true);
+                this.tracer.setAttribute(span.id, 'error.message', error instanceof Error ? error.message : String(error));
+                const completedSpan = this.tracer.endSpan(span.id);
+                // Add span to trace store even on error
+                if (completedSpan) {
+                    this.traceStore.addSpan(traceId, completedSpan);
+                }
+                throw error;
+            }
+        };
+    }
+    /**
+     * Get trace store
+     */
+    getTraceStore() {
+        return this.traceStore;
+    }
+    /**
+     * Universal log API - can be called by any logger
+     */
+    log(level, message, meta) {
+        const args = meta ? [meta] : undefined;
+        const entry = this.logStore.addLog(level, message, args);
+        // Broadcast to connected clients
+        this.broadcast({ type: 'log.entry', data: entry });
+        return entry;
+    }
+    /**
+     * Get log store instance
+     */
+    getLogStore() {
+        return this.logStore;
+    }
+    /**
+     * Broadcast event to all connected clients
+     */
+    broadcast(event) {
+        this.server.broadcast(event);
+    }
+    /**
+     * Log stdout message
+     */
+    logStdout(message) {
+        this.broadcast({
+            type: 'log.stdout',
+            data: { message, timestamp: Date.now() },
+        });
+    }
+    /**
+     * Log stderr message
+     */
+    logStderr(message) {
+        this.broadcast({
+            type: 'log.stderr',
+            data: { message, timestamp: Date.now() },
+        });
+    }
+    /**
+     * Get number of connected dashboard clients
+     */
+    getClientCount() {
+        return this.server.getClientCount();
+    }
+    /**
+     * Close the Vision server
+     */
+    async close() {
+        await this.server.close();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { VisionCore } from './core';
+export { VisionWebSocketServer } from './server/index';
+export { TraceStore, Tracer } from './tracing/index';
+export { generateZodTemplate } from './utils/zod-utils';
+export { autoDetectPackageInfo, autoDetectIntegrations, detectDrizzle, startDrizzleStudio, stopDrizzleStudio, } from './utils/service-detection';
+export type { PackageInfo, IntegrationConfig, DrizzleInfo } from './utils/service-detection';
+export type * from './types/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACnC,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,aAAa,EACb,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,2BAA2B,CAAA;AAClC,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAC5F,mBAAmB,eAAe,CAAA"}

package/dist/logs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './store';
+export * from './interceptor';
+//# sourceMappingURL=index.d.ts.map

package/dist/logs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/logs/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,eAAe,CAAA"}

package/dist/logs/index.js

@@ -0,0 +1,2 @@
+export * from './store';
+export * from './interceptor';

package/dist/logs/interceptor.d.ts

@@ -0,0 +1,21 @@
+import type { LogStore } from './store';
+import type { LogLevel } from '../types/logs';
+/**
+ * Console interceptor to capture logs
+ * Preserves original console behavior while storing logs
+ */
+export declare class ConsoleInterceptor {
+    private originalConsole;
+    private logStore;
+    private onLog?;
+    constructor(logStore: LogStore, onLog?: (level: LogLevel, message: string, args?: any[], stack?: string) => void);
+    /**
+     * Start intercepting console methods
+     */
+    start(): void;
+    /**
+     * Stop intercepting and restore original console
+     */
+    stop(): void;
+}
+//# sourceMappingURL=interceptor.d.ts.map

package/dist/logs/interceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptor.d.ts","sourceRoot":"","sources":["../../src/logs/interceptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE7C;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,eAAe,CAMtB;IAED,OAAO,CAAC,QAAQ,CAAU;IAC1B,OAAO,CAAC,KAAK,CAAC,CAA0E;gBAE5E,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI;IAKhH;;OAEG;IACH,KAAK,IAAI,IAAI;IA2Cb;;OAEG;IACH,IAAI,IAAI,IAAI;CAOb"}