tidewave 0.7.0 → 0.8.0

package/dist/core.d.ts

@@ -82,10 +82,15 @@ 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,4 +1,13 @@
-import { type Request, type Handler } from '../index';
 import type { TidewaveConfig } from '../../core';
-export type LocalPortGetter = (req: Request) => number | undefined;
-export declare function createHandleConfig(config: TidewaveConfig, getLocalPort?: LocalPortGetter): 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,20 +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>;
 export interface HandlerOptions {
     getLocalPort?: LocalPortGetter;
 }
-declare function getHandlers(config: TidewaveConfig, options?: HandlerOptions): Record<string, Handler>;
-export declare function configureServer(server?: Server, config?: TidewaveConfig, options?: HandlerOptions): Server;
-export declare function checkSecurity(config: TidewaveConfig): (req: Request, res: Response, next: NextFn) => void;
-export declare function methodNotAllowed(res: Response): void;
-export declare function originNotAllowed(res: Response): void;
-export { getHandlers };
+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,4 +1,12 @@
 import type { TidewaveConfig } from '../core';
-import type { Request, Response } from './index';
-export declare function checkRemoteIp(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;
+    host: 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/tanstack.js

@@ -105,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, "");
 }
@@ -170,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;