NativeScript/packages/core/inspector_modules.ts

import './globals';
import './debugger/webinspector-network';
import './debugger/webinspector-dom';
import './debugger/webinspector-css';
import { File, knownFolders } from './file-system';
// import/destructure style helps commonjs/esm build issues
import * as sourceMapJs from 'source-map-js';
const { SourceMapConsumer } = sourceMapJs;

// note: bundlers can by default use 'source-map' files with runtimes v9+
// helps avoid having to decode the inline base64 source maps
const usingSourceMapFiles = true;
let loadedSourceMaps: Map<string, any>;
let consumerCache: Map<string, any>;

function getConsumer(mapPath: string, sourceMap: any) {
	if (!consumerCache) {
		consumerCache = new Map();
	}
	let c = consumerCache.get(mapPath);
	if (!c) {
		try {
			c = new SourceMapConsumer(sourceMap);
			consumerCache.set(mapPath, c);
		} catch (error) {
			// Keep quiet in production-like console; failures just fall back to original stack
			console.debug && console.debug(`SourceMapConsumer failed for ${mapPath}:`, error);
			return null;
		}
	}
	return c;
}

function safeReadText(path: string): string | null {
	try {
		if (File.exists(path)) {
			return File.fromPath(path).readTextSync();
		}
	} catch (_) {}
	return null;
}

function findInlineOrLinkedMapFromJs(jsPath: string): { key: string; text: string } | null {
	const jsText = safeReadText(jsPath);
	if (!jsText) return null;

	// Look for the last sourceMappingURL directive
	// Supports both //# and /*# */ styles; capture up to line end or */
	const re = /[#@]\s*sourceMappingURL=([^\s*]+)(?:\s*\*\/)?/g;
	let match: RegExpExecArray | null = null;
	let last: RegExpExecArray | null = null;
	while ((match = re.exec(jsText))) last = match;
	if (!last) return null;

	const url = last[1];
	if (url.startsWith('data:application/json')) {
		const base64 = url.split(',')[1];
		if (!base64) return null;
		try {
			const text = atob(base64);
			return { key: `inline:${jsPath}`, text };
		} catch (_) {
			return null;
		}
	}

	// Linked .map file (relative)
	const jsDir = jsPath.substring(0, jsPath.lastIndexOf('/'));
	const mapPath = `${jsDir}/${url}`;
	const text = safeReadText(mapPath);
	if (text) {
		return { key: mapPath, text };
	}
	return null;
}

function loadAndExtractMap(mapPath: string, fallbackJsPath?: string) {
	// check cache first
	if (!loadedSourceMaps) {
		loadedSourceMaps = new Map();
	}
	let mapText = loadedSourceMaps.get(mapPath);
	if (mapText) {
		return mapText; // already loaded
	} else {
		if (File.exists(mapPath)) {
			try {
				const contents = File.fromPath(mapPath).readTextSync();

				// Note: we may want to do this, keeping for reference if needed in future.
				// Check size before processing (skip very large source maps)
				// const maxSizeBytes = 10 * 1024 * 1024; // 10MB limit
				// if (contents.length > maxSizeBytes) {
				// 	console.warn(`Source map ${mapPath} is too large (${contents.length} bytes), skipping...`);
				// 	return null;
				// }

				if (usingSourceMapFiles) {
					mapText = contents;
				} else {
					// parse out the inline base64
					const match = contents.match(/\/\/[#@] sourceMappingURL=data:application\/json[^,]+,(.+)$/);
					if (!match) {
						console.warn(`Invalid source map format in ${mapPath}`);
						return null;
					}
					const base64 = match[1];
					const binary = atob(base64);
					// this is the raw text of the source map
					// seems to work without doing decodeURIComponent tricks
					mapText = binary;
				}
			} catch (error) {
				console.debug && console.debug(`Failed to load source map ${mapPath}:`, error);
				return null;
			}
		} else {
			// Try fallback: read inline or linked map from the JS file itself
			if (fallbackJsPath) {
				const alt = findInlineOrLinkedMapFromJs(fallbackJsPath);
				if (alt && alt.text) {
					mapText = alt.text;
					// Cache under both the requested key and the alt key so future lookups are fast
					loadedSourceMaps.set(alt.key, alt.text);
				} else {
					return null;
				}
			} else {
				// no source maps
				return null;
			}
		}
	}
	loadedSourceMaps.set(mapPath, mapText); // cache it
	return mapText;
}

function remapFrame(file: string, line: number, column: number) {
	/**
	 * bundlers can use source map files or inline.
	 * To use source map files, run with `--env.sourceMap=source-map`.
	 * Notes:
	 * Starting with @nativescript/webpack 5.0.25, `source-map` files are used by default when using runtimes v9+.
	 */

	const appPath = knownFolders.currentApp().path;
	let sourceMapFileExt = '';
	if (usingSourceMapFiles) {
		sourceMapFileExt = '.map';
	}
	const rel = file.replace('file:///app/', '');
	const jsPath = `${appPath}/${rel}`;
	let mapPath = `${jsPath}${sourceMapFileExt}`; // default: same name + .map

	// Fallback: if .mjs.map missing, try .js.map
	if (!File.exists(mapPath) && rel.endsWith('.mjs')) {
		const jsMapFallback = `${appPath}/${rel.replace(/\.mjs$/, '.js.map')}`;
		if (File.exists(jsMapFallback)) {
			mapPath = jsMapFallback;
		}
	}

	const sourceMap = loadAndExtractMap(mapPath, jsPath);

	if (!sourceMap) {
		return { source: null, line: 0, column: 0 };
	}

	const consumer = getConsumer(mapPath, sourceMap);
	if (!consumer) {
		return { source: null, line: 0, column: 0 };
	}

	try {
		return consumer.originalPositionFor({ line, column });
	} catch (error) {
		console.debug && console.debug(`Remap failed for ${file}:${line}:${column}:`, error);
		return { source: null, line: 0, column: 0 };
	}
}

function remapStack(raw: string): string {
	const lines = raw.split('\n');
	const out = lines.map((line) => {
		// 1) Parenthesized frame: at fn (file:...:L:C)
		let m = /\((.+):(\d+):(\d+)\)/.exec(line);
		if (m) {
			try {
				const [_, file, l, c] = m;
				const orig = remapFrame(file, +l, +c);
				if (!orig.source) return line;
				return line.replace(/\(.+\)/, `(${orig.source}:${orig.line}:${orig.column})`);
			} catch (error) {
				console.debug && console.debug('Remap failed for frame:', line, error);
				return line;
			}
		}

		// 2) Bare frame: at file:///app/vendor.js:L:C (no parentheses)
		const bare = /(\s+at\s+)([^\s()]+):(\d+):(\d+)/.exec(line);
		if (bare) {
			try {
				const [, prefix, file, l, c] = bare;
				const orig = remapFrame(file, +l, +c);
				if (!orig.source) return line;
				const replacement = `${prefix}${orig.source}:${orig.line}:${orig.column}`;
				return line.replace(bare[0], replacement);
			} catch (error) {
				console.debug && console.debug('Remap failed for bare frame:', line, error);
				return line;
			}
		}

		return line;
	});
	return out.join('\n');
}

/**
 * Added with 9.0 runtimes.
 * Allows the runtime to remap stack traces before displaying them via in-flight error screens.
 */
(global as any).__ns_remapStack = (rawStack: string) => {
	// console.log('Remapping stack trace...');
	try {
		return remapStack(rawStack);
	} catch (error) {
		console.debug && console.debug('Remap failed, returning original:', error);
		return rawStack; // fallback to original stack trace
	}
};
/**
 * End of source map remapping for stack traces
 */