tidewave 0.5.5 → 0.7.0

package/dist/next-js/instrumentation.d.ts

@@ -1,7 +1,2 @@
-/**
- * Tidewave OpenTelemetry processors for Next.js
- *
- * Importing this module will automatically patch console.log to capture console output.
- * You can then add the processors to your OpenTelemetry setup.
- */
-export { TidewaveSpanProcessor, TidewaveLogRecordProcessor } from '../logger/instrumentation';
+export { TidewaveSpanProcessor } from '../logger/tidewave-span-processor';
+export { TidewaveLogRecordProcessor } from '../logger/tidewave-log-record-processor';

package/dist/next-js/instrumentation.js

@@ -4,47 +4,73 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/logger/circular-buffer.ts
-class CircularBuffer {
-  buffer;
-  maxSize;
-  writeIndex = 0;
-  count = 0;
-  constructor(maxSize = 1024) {
-    this.buffer = new Array(maxSize);
-    this.maxSize = maxSize;
+// src/logger/tidewave-logger.ts
+import { appendFile, readFile } from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+
+class TidewaveLogger {
+  logFilePath;
+  constructor() {
+    const cwd = process.cwd();
+    const digest = crypto.createHash("md5").update(cwd).digest("hex").slice(0, 16);
+    const tempDir = os.tmpdir();
+    this.logFilePath = path.join(tempDir, `${digest}.tidewave.ndjson`);
   }
-  addLog(log) {
-    this.buffer[this.writeIndex] = log;
-    this.writeIndex = (this.writeIndex + 1) % this.maxSize;
-    this.count = Math.min(this.count + 1, this.maxSize);
+  async addLog(log) {
+    const line = JSON.stringify(log) + `
+`;
+    try {
+      await appendFile(this.logFilePath, line, "utf8");
+    } catch (error) {
+      console.log("[Tidewave] failed to write to log file, error:", error);
+    }
   }
-  getLogs(options) {
-    let logs = this.getAllLogs();
+  async getLogs(options) {
+    let logs = await this.getAllLogs();
     if (options?.level) {
       const level = options.level.toUpperCase();
       logs = logs.filter((log) => log.severityText === level);
@@ -62,34 +88,100 @@ class CircularBuffer {
     }
     return logs;
   }
-  getAllLogs() {
-    if (this.count < this.maxSize) {
-      return this.buffer.slice(0, this.count).filter(Boolean);
+  async getAllLogs() {
+    try {
+      const content = await readFile(this.logFilePath, "utf8");
+      return content.split(`
+`).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter((log) => log !== null);
+    } catch (error) {
+      console.log("[Tidewave] failed to read from log file, error:", error);
+      return [];
     }
-    return [...this.buffer.slice(this.writeIndex), ...this.buffer.slice(0, this.writeIndex)].filter(Boolean);
   }
-  getStats() {
-    return {
-      totalLogs: this.count,
-      bufferSize: this.maxSize,
-      bufferUsage: Math.min(this.count / this.maxSize * 100, 100).toFixed(1) + "%"
-    };
+}
+var tidewaveLogger;
+var init_tidewave_logger = __esm(() => {
+  tidewaveLogger = new TidewaveLogger;
+});
+
+// src/logger/console-patch.ts
+var exports_console_patch = {};
+__export(exports_console_patch, {
+  patchConsole: () => patchConsole
+});
+function stripAnsiCodes(text) {
+  return text.replace(ANSI_REGEX, "");
+}
+function patchConsole() {
+  const isBrowser = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+  if (isBrowser) {
+    return;
   }
-  clear() {
-    this.buffer = new Array(this.maxSize);
-    this.writeIndex = 0;
-    this.count = 0;
+  if (globalThis.__TIDEWAVE_CONSOLE_PATCHED__) {
+    return;
   }
+  const severityMap = {
+    log: "INFO",
+    info: "INFO",
+    warn: "WARN",
+    error: "ERROR",
+    debug: "DEBUG"
+  };
+  Object.entries(severityMap).forEach(([method, severity]) => {
+    const original = console[method].bind(console);
+    console[method] = (...args) => {
+      try {
+        const body = args.map((arg) => {
+          if (typeof arg === "string")
+            return arg;
+          if (arg instanceof Error) {
+            return String(arg.stack);
+          }
+          if (typeof arg === "object") {
+            try {
+              return JSON.stringify(arg);
+            } catch {
+              return String(arg);
+            }
+          }
+          return String(arg);
+        }).map(stripAnsiCodes).join(" ");
+        const isAllWhitespace = body.match(/^\s+$/);
+        if (!isAllWhitespace) {
+          tidewaveLogger.addLog({
+            timestamp: new Date().toISOString(),
+            severityText: severity,
+            body,
+            attributes: {
+              "log.origin": "console",
+              "log.method": method
+            }
+          });
+        }
+      } catch {}
+      original(...args);
+    };
+  });
+  globalThis.__TIDEWAVE_CONSOLE_PATCHED__ = true;
 }
-var circularBuffer;
-var init_circular_buffer = __esm(() => {
-  if (!globalThis.__tidewaveCircularBuffer) {
-    globalThis.__tidewaveCircularBuffer = new CircularBuffer(1024);
-  }
-  circularBuffer = globalThis.__tidewaveCircularBuffer;
+var ANSI_REGEX;
+var init_console_patch = __esm(() => {
+  init_tidewave_logger();
+  ANSI_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
 });
 
+// src/next-js/instrumentation.ts
+init_console_patch();
+
 // src/logger/tidewave-span-processor.ts
+init_tidewave_logger();
+
 class TidewaveSpanProcessor {
   onStart(_span, _parentContext) {}
   onEnd(span) {
@@ -108,8 +200,8 @@ class TidewaveSpanProcessor {
       const httpUrl = span.attributes["http.url"];
       const httpTarget = span.attributes["http.target"];
       const httpStatusCode = span.attributes["http.status_code"];
-      const path = route || httpTarget || httpUrl || "unknown";
-      if (typeof path === "string" && path.startsWith("/tidewave")) {
+      const path2 = route || httpTarget || httpUrl || "unknown";
+      if (typeof path2 === "string" && path2.startsWith("/tidewave")) {
         return;
       }
       const durationMs = this.calculateDuration(span);
@@ -118,7 +210,7 @@ class TidewaveSpanProcessor {
       if (spanType === "BaseServer.handleRequest") {
         const method = httpMethod || "UNKNOWN";
         const status = httpStatusCode || "unknown";
-        message = `${method} ${path} ${status} ${durationMs.toFixed(2)}ms`;
+        message = `${method} ${path2} ${status} ${durationMs.toFixed(2)}ms`;
         if (typeof httpStatusCode === "number") {
           if (httpStatusCode >= 500)
             severity = "ERROR";
@@ -130,7 +222,7 @@ class TidewaveSpanProcessor {
       } else if (spanType === "AppRouteRouteHandlers.runHandler") {
         message = `API route: ${route || "unknown"} (${durationMs.toFixed(2)}ms)`;
       }
-      circularBuffer.addLog({
+      tidewaveLogger.addLog({
         timestamp: new Date(span.endTime[0] * 1000 + span.endTime[1] / 1e6).toISOString(),
         severityText: severity,
         body: message,
@@ -155,100 +247,27 @@ class TidewaveSpanProcessor {
   async forceFlush() {}
   async shutdown() {}
 }
-var init_tidewave_span_processor = __esm(() => {
-  init_circular_buffer();
-});
-
 // src/logger/tidewave-log-record-processor.ts
+init_tidewave_logger();
+
 class TidewaveLogRecordProcessor {
   onEmit(logRecord, _context) {
     try {
       const body = String(logRecord.body || "");
-      circularBuffer.addLog({
+      tidewaveLogger.addLog({
         timestamp: new Date(logRecord.hrTime[0] * 1000 + logRecord.hrTime[1] / 1e6).toISOString(),
         severityText: logRecord.severityText || "INFO",
         body,
-        attributes: logRecord.attributes,
-        resource: logRecord.resource?.attributes
+        attributes: logRecord.attributes
       });
     } catch (_error) {}
   }
   async forceFlush() {}
   async shutdown() {}
 }
-var init_tidewave_log_record_processor = __esm(() => {
-  init_circular_buffer();
-});
-
-// src/logger/instrumentation.ts
-var exports_instrumentation = {};
-__export(exports_instrumentation, {
-  TidewaveSpanProcessor: () => TidewaveSpanProcessor,
-  TidewaveLogRecordProcessor: () => TidewaveLogRecordProcessor
-});
-function stripAnsiCodes(text) {
-  return text.replace(ANSI_REGEX, "");
-}
-function patchConsole() {
-  const isBrowser = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
-  if (isBrowser) {
-    return;
-  }
-  if (globalThis.__TIDEWAVE_CONSOLE_PATCHED__) {
-    return;
-  }
-  const severityMap = {
-    log: "INFO",
-    info: "INFO",
-    warn: "WARN",
-    error: "ERROR",
-    debug: "DEBUG"
-  };
-  Object.entries(severityMap).forEach(([method, severity]) => {
-    const original = console[method].bind(console);
-    console[method] = (...args) => {
-      try {
-        const body = args.map((arg) => {
-          if (typeof arg === "string")
-            return arg;
-          if (arg instanceof Error) {
-            return String(arg.stack);
-          }
-          if (typeof arg === "object") {
-            try {
-              return JSON.stringify(arg);
-            } catch {
-              return String(arg);
-            }
-          }
-          return String(arg);
-        }).map(stripAnsiCodes).join(" ");
-        circularBuffer.addLog({
-          timestamp: new Date().toISOString(),
-          severityText: severity,
-          body,
-          attributes: {
-            "log.origin": "console",
-            "log.method": method
-          }
-        });
-      } catch {}
-      original(...args);
-    };
-  });
-  globalThis.__TIDEWAVE_CONSOLE_PATCHED__ = true;
-}
-var ANSI_REGEX;
-var init_instrumentation = __esm(() => {
-  init_circular_buffer();
-  init_tidewave_span_processor();
-  init_tidewave_log_record_processor();
-  ANSI_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
-  patchConsole();
-});
 
 // src/next-js/instrumentation.ts
-init_instrumentation();
+patchConsole();
 export {
   TidewaveSpanProcessor,
   TidewaveLogRecordProcessor

package/dist/resolution/formatters.d.ts

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import type { SymbolInfo } from '../core';
+import type { SymbolInfo, FileInfo } from '../core';
 export declare function getSignature(checker: ts.TypeChecker, symbol: ts.Symbol, type: ts.Type): string;
 export declare function getTypeString(checker: ts.TypeChecker, symbol: ts.Symbol, type: ts.Type): string;
-export declare function formatOutput(info: SymbolInfo): string;
+export declare function formatOutput(info: SymbolInfo | FileInfo): string;

package/dist/resolution/index.d.ts

@@ -1,6 +1,5 @@
 import type { ExtractionRequest, ExtractResult, ExtractorOptions, ResolveResult } from '../core';
-import { formatOutput } from './formatters';
 export declare function extractDocs(modulePath: string): Promise<ExtractResult>;
 export declare function getSourceLocation(reference: string): Promise<ResolveResult>;
 export declare function extractSymbol(request: ExtractionRequest, options?: ExtractorOptions): Promise<ExtractResult>;
-export { formatOutput };
+export { formatOutput } from './formatters';

package/dist/resolution/symbol-finder.d.ts

@@ -1,4 +1,4 @@
 import ts from 'typescript';
-import type { ExtractResult } from '../core';
+import type { SymbolInfo, ExtractError } from '../core';
 export declare function findSymbolInJavaScriptFile(sourceFile: ts.SourceFile, checker: ts.TypeChecker, symbolName: string): ts.Symbol | undefined;
-export declare function getSymbolInfo(checker: ts.TypeChecker, symbol: ts.Symbol, member?: string, isStatic?: boolean): ExtractResult;
+export declare function getSymbolInfo(checker: ts.TypeChecker, symbol: ts.Symbol, member?: string, isStatic?: boolean): SymbolInfo | ExtractError;

package/dist/resolution/utils.d.ts

@@ -3,3 +3,4 @@ export declare function getLocation(symbol: ts.Symbol): string;
 export declare function getDocumentation(checker: ts.TypeChecker, symbol: ts.Symbol): string;
 export declare function getJSDoc(checker: ts.TypeChecker, symbol: ts.Symbol): string;
 export declare function getSymbolKind(symbol: ts.Symbol): string;
+export declare function getFileOverview(sourceFile: ts.SourceFile): string | undefined;

package/dist/tanstack.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tanstack.js

@@ -0,0 +1,181 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/logger/tidewave-logger.ts
+import { appendFile, readFile } from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+
+class TidewaveLogger {
+  logFilePath;
+  constructor() {
+    const cwd = process.cwd();
+    const digest = crypto.createHash("md5").update(cwd).digest("hex").slice(0, 16);
+    const tempDir = os.tmpdir();
+    this.logFilePath = path.join(tempDir, `${digest}.tidewave.ndjson`);
+  }
+  async addLog(log) {
+    const line = JSON.stringify(log) + `
+`;
+    try {
+      await appendFile(this.logFilePath, line, "utf8");
+    } catch (error) {
+      console.log("[Tidewave] failed to write to log file, error:", error);
+    }
+  }
+  async getLogs(options) {
+    let logs = await this.getAllLogs();
+    if (options?.level) {
+      const level = options.level.toUpperCase();
+      logs = logs.filter((log) => log.severityText === level);
+    }
+    if (options?.since) {
+      const sinceDate = new Date(options.since);
+      logs = logs.filter((log) => new Date(log.timestamp) >= sinceDate);
+    }
+    if (options?.grep) {
+      const regex = new RegExp(options.grep, "i");
+      logs = logs.filter((log) => regex.test(log.body) || regex.test(JSON.stringify(log.attributes)));
+    }
+    if (options?.tail) {
+      logs = logs.slice(-options.tail);
+    }
+    return logs;
+  }
+  async getAllLogs() {
+    try {
+      const content = await readFile(this.logFilePath, "utf8");
+      return content.split(`
+`).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter((log) => log !== null);
+    } catch (error) {
+      console.log("[Tidewave] failed to read from log file, error:", error);
+      return [];
+    }
+  }
+}
+var tidewaveLogger;
+var init_tidewave_logger = __esm(() => {
+  tidewaveLogger = new TidewaveLogger;
+});
+
+// src/logger/console-patch.ts
+var exports_console_patch = {};
+__export(exports_console_patch, {
+  patchConsole: () => patchConsole
+});
+function stripAnsiCodes(text) {
+  return text.replace(ANSI_REGEX, "");
+}
+function patchConsole() {
+  const isBrowser = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+  if (isBrowser) {
+    return;
+  }
+  if (globalThis.__TIDEWAVE_CONSOLE_PATCHED__) {
+    return;
+  }
+  const severityMap = {
+    log: "INFO",
+    info: "INFO",
+    warn: "WARN",
+    error: "ERROR",
+    debug: "DEBUG"
+  };
+  Object.entries(severityMap).forEach(([method, severity]) => {
+    const original = console[method].bind(console);
+    console[method] = (...args) => {
+      try {
+        const body = args.map((arg) => {
+          if (typeof arg === "string")
+            return arg;
+          if (arg instanceof Error) {
+            return String(arg.stack);
+          }
+          if (typeof arg === "object") {
+            try {
+              return JSON.stringify(arg);
+            } catch {
+              return String(arg);
+            }
+          }
+          return String(arg);
+        }).map(stripAnsiCodes).join(" ");
+        const isAllWhitespace = body.match(/^\s+$/);
+        if (!isAllWhitespace) {
+          tidewaveLogger.addLog({
+            timestamp: new Date().toISOString(),
+            severityText: severity,
+            body,
+            attributes: {
+              "log.origin": "console",
+              "log.method": method
+            }
+          });
+        }
+      } catch {}
+      original(...args);
+    };
+  });
+  globalThis.__TIDEWAVE_CONSOLE_PATCHED__ = true;
+}
+var ANSI_REGEX;
+var init_console_patch = __esm(() => {
+  init_tidewave_logger();
+  ANSI_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+});
+
+// src/tanstack.ts
+init_console_patch();
+patchConsole();

package/dist/vite-plugin.d.ts

@@ -1,4 +1,3 @@
 import type { TidewaveConfig } from './core';
 import type { Plugin } from 'vite';
-import './logger/instrumentation';
 export default function tidewave(config?: TidewaveConfig): Plugin;