@visulima/vite-overlay 1.3.5 → 1.3.7

package/dist/overlay/patch-overlay.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Patches Vite's client code to replace the default error overlay with our custom overlay.
+ */
+export declare const patchOverlay: (code: string, showBalloonButton: boolean) => string;
+export default patchOverlay;

package/dist/types.d.ts

@@ -0,0 +1,94 @@
+import type { ErrorLocation } from "@visulima/error/error";
+import type { Solution } from "@visulima/error/solution";
+export type ErrorLike = Error | {
+    message?: string;
+    name?: string;
+    stack?: string;
+};
+export interface PluginPattern {
+    readonly name: string;
+    readonly pattern: RegExp;
+}
+export type SupportedExtension = ".js" | ".ts" | ".mjs" | ".cjs" | ".jsx" | ".tsx" | ".vue" | ".svelte";
+export interface StackLocation {
+    readonly column?: number;
+    readonly file?: string;
+    readonly line?: number;
+}
+export interface VisulimaViteOverlayErrorPayload {
+    readonly errors: ReadonlyArray<ExtendedError>;
+    readonly errorType: "client" | "server";
+    readonly rootPath: string;
+    readonly solution?: Solution;
+}
+export interface ExtendedError extends ErrorProcessingResult {
+    readonly hint?: string;
+    readonly message: string;
+    readonly name: string;
+    readonly stack: string;
+}
+export interface DevelopmentLogger {
+    readonly error: (message: unknown) => void;
+    readonly log: (message: unknown) => void;
+}
+export interface RecentErrorTracker {
+    readonly recentErrors: Map<string, number>;
+    readonly shouldSkip: (signature: string) => boolean;
+}
+export interface RawErrorData {
+    readonly cause?: {
+        readonly cause?: {
+            readonly cause?: any;
+            readonly message?: string | null;
+            readonly name?: string | null;
+            readonly stack?: string | null;
+        } | null;
+        readonly message?: string | null;
+        readonly name?: string | null;
+        readonly stack?: string | null;
+    } | null;
+    readonly column?: number | null;
+    readonly file?: string | null;
+    readonly line?: number | null;
+    readonly message: string;
+    readonly name?: string;
+    readonly ownerStack?: string | null;
+    readonly plugin?: string;
+    readonly stack: string;
+}
+export interface VueErrorInfo {
+    readonly column: number;
+    readonly line: number;
+    readonly message?: string;
+    readonly originalFilePath: string;
+}
+export type ViteErrorData = ErrorLocation & {
+    plugin?: string;
+};
+export interface ResolvedLocation {
+    readonly originalFileColumn: number;
+    readonly originalFileLine: number;
+    readonly originalFilePath: string;
+}
+export interface SourceTexts {
+    readonly compiledSourceText?: string;
+    readonly originalSourceText?: string;
+}
+export interface ErrorProcessingResult {
+    readonly compiledCodeFrameContent?: string;
+    readonly compiledColumn?: number;
+    readonly compiledFilePath?: string;
+    readonly compiledLine?: number;
+    readonly compiledStack?: string;
+    readonly errorCount?: number;
+    readonly fixPrompt: string;
+    readonly message?: string;
+    readonly originalCodeFrameContent?: string;
+    readonly originalFileColumn: number;
+    readonly originalFileLine: number;
+    readonly originalFilePath: string;
+    readonly originalSnippet: string;
+    readonly originalStack?: string;
+    readonly plugin?: string;
+}
+export type StackFrameValidator = (line: string) => boolean;

package/dist/utils/create-vite-solution-finder.d.ts

@@ -0,0 +1,13 @@
+import type { SolutionFinder } from "@visulima/error/solution";
+/**
+ * Creates a solution finder specifically designed for Vite-related errors.
+ * Provides intelligent suggestions for common Vite import resolution and configuration issues.
+ * @param rootPath The root path of the project
+ * @returns A solution finder object for Vite-specific error handling
+ */
+declare const createViteSolutionFinder: (rootPath: string) => SolutionFinder;
+/**
+ * Default export for creating Vite solution finders.
+ * @see createViteSolutionFinder
+ */
+export default createViteSolutionFinder;

package/dist/utils/error-processing/index.d.ts

@@ -0,0 +1,21 @@
+import type { ViteDevServer } from "vite";
+import type { ErrorProcessingResult, ViteErrorData } from "../../types.d.ts";
+/**
+ * Builds comprehensive error data including source maps, code frames, and AI prompts.
+ * This function processes runtime errors and extracts all information needed for
+ * the error overlay UI, including original source locations and syntax-highlighted code.
+ * Handles both single errors and AggregateError (multiple errors).
+ * @param error The error object to process (can be AggregateError with multiple errors)
+ * @param server The Vite dev server instance for module resolution
+ * @returns Promise resolving to extended error data object
+ */
+declare const buildExtendedErrorData: (error: Error, server: ViteDevServer, errorIndex?: number, framework?: string, viteErrorData?: ViteErrorData, allErrors?: (Error | {
+    message: string;
+    name?: string;
+    stack?: string;
+})[]) => Promise<ErrorProcessingResult>;
+/**
+ * Default export for building extended error data with source maps and code frames.
+ * @see buildExtendedErrorData
+ */
+export default buildExtendedErrorData;

package/dist/utils/error-processing/parse-vue-compilation-error.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parses Vue SFC compilation error messages to extract file, line, and column information.
+ * @param errorMessage The Vue compilation error message to parse
+ * @returns Object containing parsed error information or null if not a Vue error
+ */
+declare const parseVueCompilationError: (errorMessage: string) => {
+    column: number;
+    line: number;
+    message: string;
+    originalFilePath: string;
+} | undefined;
+export default parseVueCompilationError;

package/dist/utils/error-processing/process-hydration-diff.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Processes React hydration diff content to extract and format relevant differences.
+ * @param error The raw error object containing hydration diff
+ * @returns Formatted diff content with markers and limited context
+ */
+declare const processHydrationDiff: (error: Error) => string | undefined;
+export default processHydrationDiff;

package/dist/utils/error-processing/remap-stack-to-original.d.ts

@@ -0,0 +1,18 @@
+import type { ViteDevServer } from "vite";
+/**
+ * Remaps a stack trace from compiled locations to original source locations using source maps.
+ * Handles React-specific stack frames and module resolution for better debugging experience.
+ * @param server The Vite dev server instance
+ * @param stack The stack trace string to remap
+ * @param header Optional header information for the formatted stack trace
+ * @returns Promise resolving to the remapped stack trace
+ */
+declare const remapStackToOriginal: (server: ViteDevServer, stack: string, header?: {
+    message?: string;
+    name?: string;
+}) => Promise<string>;
+/**
+ * Default export for remapping stack traces to original source locations.
+ * @see remapStackToOriginal
+ */
+export default remapStackToOriginal;

package/dist/utils/error-processing/retrieve-source-texts.d.ts

@@ -0,0 +1,8 @@
+import type { ViteDevServer } from "vite";
+import type { SourceTexts } from "../../types.d.ts";
+/**
+ * Retrieves original and compiled source texts from various sources.
+ * Attempts multiple strategies to find source code for error context.
+ */
+declare const retrieveSourceTexts: (server: ViteDevServer, module_: unknown, filePath: string, idCandidates: ReadonlyArray<string>) => Promise<SourceTexts>;
+export default retrieveSourceTexts;

package/dist/utils/error-processing/shiki-diff-transformer.d.ts

@@ -0,0 +1,8 @@
+import type { ShikiTransformer } from "shiki/types";
+type Options = {
+    classActivePre?: string;
+    classLineAdd?: string;
+    classLineRemove?: string;
+};
+declare const shikiDiffTransformer: (options?: Options) => ShikiTransformer;
+export default shikiDiffTransformer;

package/dist/utils/error-processing/utils/add-query-to-url.d.ts

@@ -0,0 +1,2 @@
+declare const addQueryToUrl: (baseUrl: string, query: string) => string;
+export default addQueryToUrl;

package/dist/utils/error-processing/utils/extract-query-from-http-url.d.ts

@@ -0,0 +1,2 @@
+declare const extractQueryFromHttpUrl: (url: string) => string;
+export default extractQueryFromHttpUrl;

package/dist/utils/esbuild-error.d.ts

@@ -0,0 +1,29 @@
+export interface ESBuildMessage extends Error {
+    location?: {
+        column?: number;
+        file?: string;
+        line?: number;
+    };
+    pluginName?: string;
+    text: string;
+}
+/**
+ * Checks if an array contains ESBuild error objects.
+ * @param errors Array of potential ESBuild errors
+ * @returns True if the array contains ESBuild errors
+ */
+export declare const isESBuildErrorArray: (errors: any[]) => boolean;
+/**
+ * Processes ESBuild error messages into a standardized format.
+ * @param esbuildErrors Array of ESBuild error messages
+ * @returns Array of processed error objects with standardized structure
+ */
+export declare const processESBuildErrors: (esbuildErrors: ESBuildMessage[]) => {
+    column?: number;
+    file?: string;
+    line?: number;
+    message: string;
+    name: string;
+    plugin?: string;
+    stack: string;
+}[];

package/dist/utils/find-error-in-source.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Finds the location of an error message within source code by analyzing error patterns.
+ * @param sourceCode The source code to search in
+ * @param errorMessage The error message to locate
+ * @param occurrenceIndex The index of occurrence to find (default: 0)
+ * @returns The line and column location of the error, or null if not found
+ */
+declare const findErrorInSourceCode: (sourceCode: string, errorMessage: string, occurrenceIndex?: number) => {
+    column: number;
+    line: number;
+} | null;
+export default findErrorInSourceCode;

package/dist/utils/find-module-for-path.d.ts

@@ -0,0 +1,9 @@
+import type { ModuleNode, ViteDevServer } from "vite";
+/**
+ * Finds a module in Vite's module graph using various strategies and candidate paths.
+ * @param server The Vite dev server instance
+ * @param candidates Array of candidate file paths to search for
+ * @returns The matching module node or undefined if not found
+ */
+declare const findModuleForPath: (server: ViteDevServer, candidates: string[]) => ModuleNode | undefined;
+export default findModuleForPath;

package/dist/utils/generate-client-script.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates the client-side script for error interception and reporting.
+ * @param mode The current Vite mode (development/production)
+ * @param forwardedConsoleMethods Array of console method names to forward
+ * @returns The client-side JavaScript code as a string
+ */
+declare const generateClientScript: (mode: string, forwardedConsoleMethods: string[]) => string;
+export default generateClientScript;

package/dist/utils/get-source-from-map.d.ts

@@ -0,0 +1,6 @@
+interface SourceMap {
+    sources?: string[];
+    sourcesContent?: (string | null)[];
+}
+declare const getSourceFromMap: (map: SourceMap, wantedSource: string | undefined) => string | undefined;
+export default getSourceFromMap;

package/dist/utils/normalize-id-candidates.d.ts

@@ -0,0 +1,2 @@
+export declare const isHttpUrl: (value: string) => boolean;
+export declare const normalizeIdCandidates: (filePath: string) => string[];

package/dist/utils/position-aligner.d.ts

@@ -0,0 +1,6 @@
+interface Position {
+    column: number;
+    line: number;
+}
+declare const realignOriginalPosition: (compiledSource: string, compiledLine: number, compiledColumn: number, originalSource: string) => Position | null;
+export default realignOriginalPosition;

package/dist/utils/resolve-original-location.d.ts

@@ -0,0 +1,29 @@
+import type { ViteDevServer } from "vite";
+interface ResolvedLocation {
+    originalFileColumn: number;
+    originalFileLine: number;
+    originalFilePath: string;
+}
+interface ViteModule {
+    id?: string | null;
+    transformResult?: {
+        code?: string;
+        map?: any;
+    } | null;
+    url?: string;
+}
+/**
+ * Resolves the original source location from a compiled location using source maps.
+ * Uses Vite's built-in source map resolution for consistency with browser behavior.
+ * Falls back to source code search for error messages when source maps are unreliable.
+ * @param server The Vite dev server instance
+ * @param module_ The Vite module containing transform result
+ * @param filePath The original file path
+ * @param fileLine The line number in the compiled source
+ * @param fileColumn The column number in the compiled source
+ * @param errorMessage Optional error message to search for in source code
+ * @param errorIndex Index of this error in a cause chain (0-based)
+ * @returns Object with resolved filePath, fileLine, and fileColumn
+ */
+declare const resolveOriginalLocation: (server: ViteDevServer, module_: ViteModule, filePath: string, fileLine: number, fileColumn: number, errorMessage?: string, errorIndex?: number) => Promise<ResolvedLocation>;
+export default resolveOriginalLocation;

package/dist/utils/ssr-error-enhancer.d.ts

@@ -0,0 +1,8 @@
+import type { ViteDevServer } from "vite";
+/**
+ * Enhances SSR errors with better stack traces and contextual hints.
+ * - Fixes stack traces via Vite's SSR helper
+ * - Detects common SSR failure patterns and enriches message/loc
+ */
+declare const enhanceViteSsrError: (rawError: unknown, server: ViteDevServer) => Promise<Error>;
+export default enhanceViteSsrError;

package/dist/utils/stack-trace.d.ts

@@ -0,0 +1,38 @@
+import type { StackFrameValidator } from "../types.d.ts";
+/**
+ * Validates if a stack trace line represents a valid stack frame.
+ * @param line The stack trace line to validate
+ * @returns True if the line is a valid stack frame
+ */
+export declare const isValidStackFrame: StackFrameValidator;
+/**
+ * Cleans an error stack trace by normalizing line endings and filtering invalid stack frames.
+ * @param stack The raw stack trace string
+ * @returns The cleaned stack trace
+ */
+export declare const cleanErrorStack: (stack: string) => string;
+/**
+ * Cleans an error message by removing VT control characters.
+ * @param error The error object or error message string
+ * @returns The cleaned error message
+ */
+export declare const cleanErrorMessage: (error: Error | string) => string;
+/**
+ * Checks if an error is an AggregateError (contains multiple errors).
+ * @param error The error to check
+ * @returns True if the error is an AggregateError
+ */
+export declare const isAggregateError: (error: any) => error is AggregateError;
+/**
+ * Extracts individual errors from an AggregateError or returns the error as-is.
+ * @param error The error to process
+ * @returns Array of individual errors
+ */
+export declare const extractErrors: (error: any) => Error[];
+/**
+ * Converts HTTP URLs in stack traces to absolute filesystem paths
+ * @param stack Raw stack trace with HTTP URLs
+ * @param rootPath Root directory for path resolution
+ * @returns Stack trace with absolute paths
+ */
+export declare const absolutizeStackUrls: (stack: string, rootPath: string) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/vite-overlay",
-  "version": "1.3.5",
+  "version": "1.3.7",
   "description": "Improved vite overlay",
   "keywords": [
     "vite",
@@ -57,12 +57,12 @@
   ],
   "dependencies": {
     "@jridgewell/trace-mapping": "^0.3.31",
-    "@shikijs/cli": "3.14.0",
-    "@shikijs/langs": "3.14.0",
-    "@shikijs/themes": "3.14.0",
-    "@visulima/error": "5.0.4",
+    "@shikijs/cli": "3.15.0",
+    "@shikijs/langs": "3.15.0",
+    "@shikijs/themes": "3.15.0",
+    "@visulima/error": "5.0.6",
     "fastest-levenshtein": "^1.0.16",
-    "shiki": "3.14.0"
+    "shiki": "3.15.0"
   },
   "peerDependencies": {
     "vite": "^6 || ^7 || ^8"