@builder.io/dev-tools 1.35.3-dev.202603251111.584c84aa2 → 1.35.3-dev.202603251414.7060a67a6

package/types/common/logger.d.ts

@@ -93,5 +93,6 @@ export interface CreateLoggerOptions {
     debug?: boolean | (() => boolean);
     level?: LogLevel;
 }
+export declare function setDebuggingEnabled(enabled: boolean): void;
 export declare function createLogger(context?: string, options?: CreateLoggerOptions): Logger;
 export {};

package/types/core/component-map-builder.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Component Map Builder
+ *
+ * Builds a map of component names to their source file locations for the Design tab.
+ * This allows the Design tab to work without requiring React's _debugSource or customer plugins.
+ */
+import type { DevToolsSys } from "../types";
+export interface ComponentLocation {
+    file: string;
+    line: number;
+    column: number;
+    displayName: string;
+}
+export type ComponentMap = Record<string, ComponentLocation[]>;
+/**
+ * Build a map of component names to their source locations
+ */
+export declare function buildComponentMap(sys: DevToolsSys, rootDir?: string): Promise<ComponentMap>;
+/**
+ * Cache for component map with file watching
+ */
+export declare class ComponentMapCache {
+    private cache;
+    private lastBuilt;
+    private building;
+    private readonly ttl;
+    private sys;
+    private rootDir;
+    constructor(sys: DevToolsSys, rootDir?: string);
+    /**
+     * Get the component map, building it if necessary
+     */
+    get(): Promise<ComponentMap>;
+    /**
+     * Invalidate the cache
+     */
+    invalidate(): void;
+    /**
+     * Force rebuild of the component map
+     */
+    rebuild(): Promise<ComponentMap>;
+}

package/types/server/source-map-resolver/cache.d.ts

@@ -0,0 +1,36 @@
+/**
+ * LRU cache for source maps and TraceMap instances
+ */
+import { TraceMap } from "@jridgewell/trace-mapping";
+import type { SourceMapV3 } from "./types";
+interface CachedSourceMap {
+    json: SourceMapV3;
+    /** TraceMap instances keyed by section index (-1 for non-indexed maps) */
+    tracers: Map<number, TraceMap>;
+}
+/**
+ * Get or create cache key from bundled path and source mapping URL
+ */
+export declare function getCacheKey(bundledPath: string, sourceMappingURL: string): string;
+/**
+ * Get cached source map data
+ * Returns undefined if not cached, null if cached as failed
+ */
+export declare function getCached(key: string): CachedSourceMap | null | undefined;
+/**
+ * Cache a successfully loaded source map
+ */
+export declare function setCached(key: string, json: SourceMapV3): CachedSourceMap;
+/**
+ * Cache a failed load attempt (negative caching)
+ */
+export declare function setCachedFailure(key: string): void;
+/**
+ * Get or create a TraceMap for a specific section (or -1 for non-indexed)
+ */
+export declare function getOrCreateTracer(entry: CachedSourceMap, sectionIndex: number, mapJson: SourceMapV3): TraceMap;
+/**
+ * Clear all cached data
+ */
+export declare function clearCache(): void;
+export {};

package/types/server/source-map-resolver/indexed-map-resolver.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Utilities for handling indexed source maps (section maps)
+ */
+import type { SourceMapSection, SectionMatch } from "./types";
+/**
+ * Find the section containing a given position in an indexed source map.
+ * Sections are ordered by offset, so we find the last one that starts
+ * at or before the target position.
+ */
+export declare function findMatchingSection(sections: SourceMapSection[], line: number, column: number): SectionMatch | null;

package/types/server/source-map-resolver/loader.d.ts

@@ -0,0 +1,16 @@
+/**
+ * File and source map loading utilities
+ */
+import type { ResolveContext } from "./types";
+/**
+ * Extract sourceMappingURL from JS file content
+ */
+export declare function extractSourceMappingURL(content: string): string | null;
+/**
+ * Load JS file content from dev server or filesystem
+ */
+export declare function loadJSContent(ctx: ResolveContext, bundledPath: string, isServerChunk: boolean): Promise<string | null>;
+/**
+ * Load source map content from various sources
+ */
+export declare function loadSourceMapContent(ctx: ResolveContext, bundledPath: string, sourceMappingURL: string): Promise<string | null>;

package/types/server/source-map-resolver/security.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Security utilities for path validation and sanitization
+ */
+/**
+ * Check if a resolved path is safely within the project root.
+ * Prevents sibling directory access (e.g., /project-sensitive when root is /project)
+ */
+export declare function isPathWithinRoot(filePath: string, rootPath: string): boolean;
+/**
+ * Sanitize and validate a bundled path input.
+ * Returns decoded path or null if invalid.
+ */
+export declare function sanitizeBundledPath(bundledPath: string): string | null;
+/**
+ * Check if a chunk filename is definitely internal (not user code)
+ */
+export declare function isDefinitelyInternalChunk(filename: string): boolean;
+/**
+ * Check if a resolved source path is framework code
+ */
+export declare function isFrameworkCode(sourcePath: string): boolean;

package/types/server/source-map-resolver/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared types for source map resolution
+ */
+export interface OriginalPosition {
+    source: string;
+    line: number;
+    column: number;
+    name?: string;
+}
+/**
+ * Source Map v3 JSON structure
+ * Based on: https://sourcemaps.info/spec.html
+ */
+export interface SourceMapV3 {
+    version: number;
+    file?: string;
+    sourceRoot?: string;
+    sources?: string[];
+    sourcesContent?: (string | null)[];
+    names?: string[];
+    mappings?: string;
+    sections?: SourceMapSection[];
+}
+export interface SourceMapSection {
+    offset: {
+        line: number;
+        column: number;
+    };
+    map?: SourceMapV3;
+    url?: string;
+}
+export interface ResolveContext {
+    projectRoot: string;
+    devServerUrl: string;
+}
+export interface SectionMatch {
+    section: SourceMapSection;
+    index: number;
+    relativeLine: number;
+    relativeColumn: number;
+}

package/types/server/source-map-resolver/validation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Source map validation utilities
+ */
+import type { SourceMapV3 } from "./types";
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+}
+/**
+ * Validate a source map v3 structure
+ */
+export declare function validateSourceMap(json: unknown): ValidationResult;
+/**
+ * Clean up source map structure before processing
+ */
+export declare function prepareSourceMap(json: SourceMapV3): SourceMapV3;

package/types/server/source-map-resolver.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Server-side source map resolution using @jridgewell/trace-mapping
+ * Fetches bundled files from dev server and resolves to original source locations
+ */
+import type { OriginalPosition } from "./source-map-resolver/types";
+import { clearCache } from "./source-map-resolver/cache";
+export type { OriginalPosition };
+export { clearCache as clearSourceMapCache };
+/**
+ * Resolve a bundled file location to its original source location
+ * @param projectRoot Root directory of the project (for file fallback)
+ * @param devServerUrl Base URL of the dev server (e.g., http://localhost:3000)
+ * @param bundledPath Path to the bundled file (e.g., /_next/static/chunks/app/page.js)
+ * @param line Line number in bundled file (1-indexed)
+ * @param column Column number in bundled file (0-indexed)
+ */
+export declare function resolveSourceLocation(projectRoot: string, devServerUrl: string, bundledPath: string, line: number, column: number): Promise<OriginalPosition | null>;
+/**
+ * Batch resolve multiple source locations with deduplication
+ */
+export declare function batchResolveSourceLocations(projectRoot: string, devServerUrl: string, locations: Array<{
+    bundledPath: string;
+    line: number;
+    column: number;
+}>): Promise<Array<OriginalPosition | null>>;