tidewave 0.6.0 → 0.8.0

package/dist/core.d.ts

@@ -19,7 +19,7 @@ export interface InternalResolvedModule {
 }
 export interface ExtractionRequest {
     readonly module: string;
-    readonly symbol: string;
+    readonly symbol?: string;
     readonly member?: string;
     readonly isStatic?: boolean;
 }
@@ -32,6 +32,18 @@ export interface SymbolInfo {
     readonly location: string;
     readonly jsDoc?: string;
 }
+export interface ExportSummary {
+    readonly name: string;
+    readonly kind: string;
+    readonly line: number;
+    readonly documentation?: string;
+}
+export interface FileInfo {
+    readonly path: string;
+    readonly overview?: string;
+    readonly exportCount: number;
+    readonly exports: ExportSummary[];
+}
 export interface ExtractorOptions {
     readonly prefix?: string;
 }
@@ -62,21 +74,23 @@ export interface EvaluatedModuleResult {
     stderr: string;
 }
 export type ResolveResult = ResolvedModule | ResolveError;
-export type ExtractResult = SymbolInfo | ExtractError;
+export type ExtractResult = SymbolInfo | FileInfo | ExtractError;
 export type InternalResolveResult = InternalResolvedModule | ResolveError;
-export declare function isError(result: ResolveResult | ExtractResult): boolean;
 export declare function isResolveError(result: ResolveResult | InternalResolveResult): result is ResolveError;
 export declare function isExtractError(result: ExtractResult): result is ExtractError;
+export declare function isFileInfo(result: ExtractResult): result is FileInfo;
 export declare function resolveError(specifier: ModuleRequest['specifier'], source: ModuleRequest['source']): ResolveError;
 export declare function createExtractError(code: ExtractError['error']['code'], message: string, details?: unknown): ExtractError;
 export interface TidewaveConfig {
     port?: number;
     host?: string;
     clientUrl?: string;
+    toolbar?: boolean;
     allowRemoteAccess?: boolean;
     allowedOrigins?: string[];
     projectName?: string;
     framework?: string;
+    tmpDir?: string;
     team?: {
         id?: string;
         token?: string;

package/dist/http/handlers/config.d.ts

@@ -1,3 +1,13 @@
-import type { Handler } from '../index';
 import type { TidewaveConfig } from '../../core';
-export declare function createHandleConfig(config: TidewaveConfig): Handler;
+import type { TidewaveHandler } from '../types';
+export type LocalPortGetter = () => number | undefined;
+export interface TidewaveConfigPayload {
+    project_name: string;
+    framework_type: string;
+    tidewave_version: string;
+    team: NonNullable<TidewaveConfig['team']> | Record<string, never>;
+    local_port: number | undefined;
+    tmp_dir: string;
+}
+export declare function tidewaveConfig(config: TidewaveConfig, getLocalPort?: LocalPortGetter): TidewaveConfigPayload;
+export declare function createHandleConfig(config: TidewaveConfig, getLocalPort?: LocalPortGetter): TidewaveHandler;

package/dist/http/handlers/html.d.ts

@@ -1,3 +1,4 @@
-import type { Handler } from '../index';
 import type { TidewaveConfig } from '../../core';
-export declare function createHandleHtml(config: TidewaveConfig): Handler;
+import type { TidewaveHandler } from '../types';
+export declare function createHandleHtml(config: TidewaveConfig): TidewaveHandler;
+export declare function createHandleAppHtml(config: TidewaveConfig): TidewaveHandler;

package/dist/http/handlers/mcp.d.ts

@@ -1,2 +1,2 @@
-import { type Request, type Response, type NextFn } from '..';
-export declare function handleMcp(req: Request, res: Response, next: NextFn): Promise<void>;
+import type { TidewaveNext, TidewaveRequest, TidewaveResponse } from '../types';
+export declare function handleMcp(req: TidewaveRequest, res: TidewaveResponse, next: TidewaveNext): Promise<void>;

package/dist/http/handlers/upload.d.ts

@@ -0,0 +1,3 @@
+import type { TidewaveConfig } from '../../core';
+import type { TidewaveHandler } from '../types';
+export declare function createHandleUpload(config: TidewaveConfig): TidewaveHandler;

package/dist/http/headers.d.ts

@@ -0,0 +1,4 @@
+import type { TidewaveConfig } from '../core';
+import type { LocalPortGetter } from './handlers/config';
+import type { TidewaveHandler } from './types';
+export declare function createHandleResponseHeaders(config: TidewaveConfig, getLocalPort?: LocalPortGetter): TidewaveHandler;

package/dist/http/index.d.ts

@@ -1,16 +1,8 @@
-import type { ServerResponse } from 'http';
-import type { IncomingMessage, NextFunction, Server } from 'connect';
+import { type LocalPortGetter } from './handlers/config';
 import type { TidewaveConfig } from '../core';
-export interface Request extends IncomingMessage {
-    body?: Record<string, unknown>;
-}
-export type Response = ServerResponse<IncomingMessage>;
-export type NextFn = NextFunction;
+import type { TidewaveMiddlewareServer } from './types';
 export declare const ENDPOINT: "/tidewave";
-export type Handler = (req: Request, res: Response, next: NextFn) => Promise<void>;
-declare function getHandlers(config: TidewaveConfig): Record<string, Handler>;
-export declare function configureServer(server?: Server, config?: TidewaveConfig): Server;
-export declare function serve(server: Server, config?: TidewaveConfig): void;
-export declare function checkSecurity(config: TidewaveConfig): (req: Request, res: Response, next: NextFn) => void;
-export declare function methodNotAllowed(res: Response): void;
-export { getHandlers };
+export interface HandlerOptions {
+    getLocalPort?: LocalPortGetter;
+}
+export declare function configureServer(server: TidewaveMiddlewareServer, config?: TidewaveConfig, options?: HandlerOptions): TidewaveMiddlewareServer;

package/dist/http/magic-bytes.d.ts

@@ -0,0 +1,2 @@
+export type MagicByteType = 'jpg' | 'png' | 'webm' | 'unknown';
+export declare function magicByteType(bytes: Uint8Array): MagicByteType;

package/dist/http/security.d.ts

@@ -1,8 +1,7 @@
 import type { TidewaveConfig } from '../core';
-import type { Request, Response } from './index';
-export declare function checkRemoteIp(req: Request, res: Response, config: TidewaveConfig): boolean;
-export declare function isLocalIp(ip?: string): boolean;
-export declare function checkOrigin(req: Request, res: Response, config: TidewaveConfig): boolean;
+import type { TidewaveRequest, TidewaveResponse } from './types';
+export declare function checkRemoteIp(req: TidewaveRequest, res: TidewaveResponse, config: TidewaveConfig): boolean;
+export declare function checkOrigin(req: TidewaveRequest, res: TidewaveResponse, config: TidewaveConfig): boolean;
 export declare function getDefaultAllowedOrigins(config: TidewaveConfig): string[];
 export declare function parseUrl(url: string): {
     scheme?: string;
@@ -10,3 +9,4 @@ export declare function parseUrl(url: string): {
     port?: number;
 } | null;
 export declare function isOriginAllowed(origin: ReturnType<typeof parseUrl>, allowed: ReturnType<typeof parseUrl>): boolean;
+export declare function isLocalIp(ip?: string): boolean;

package/dist/http/types.d.ts

@@ -0,0 +1,11 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export interface TidewaveRequest extends IncomingMessage {
+    body?: Record<string, unknown>;
+}
+export type TidewaveResponse = ServerResponse<IncomingMessage>;
+export type TidewaveNext = (err?: unknown) => void;
+export type TidewaveHandler = (req: TidewaveRequest, res: TidewaveResponse, next: TidewaveNext) => Promise<void>;
+export interface TidewaveMiddlewareServer {
+    use(handler: unknown): void;
+    use(route: string, handler: unknown): void;
+}

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.js

@@ -4,25 +4,43 @@ 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);
@@ -87,16 +105,10 @@ class TidewaveLogger {
     }
   }
 }
-var tidewaveLogger;
-var init_tidewave_logger = __esm(() => {
-  tidewaveLogger = new TidewaveLogger;
-});
+var tidewaveLogger = new TidewaveLogger;
 
 // src/logger/console-patch.ts
-var exports_console_patch = {};
-__export(exports_console_patch, {
-  patchConsole: () => patchConsole
-});
+var ANSI_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
 function stripAnsiCodes(text) {
   return text.replace(ANSI_REGEX, "");
 }
@@ -152,12 +164,6 @@ function patchConsole() {
   });
   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/toolbar.d.ts

@@ -0,0 +1,4 @@
+import type { TidewaveConfig } from './core';
+import { type LocalPortGetter } from './http/handlers/config';
+export declare function injectToolbarHtml(html: string, config: TidewaveConfig, getLocalPort?: LocalPortGetter): string;
+export declare function toolbarAlreadyInjected(html: string): boolean;