import { createRequire } from "node:module";
import { COMMENT_USE_STRICT_REGEX, CodeInjection, createComponentNameAnnotateHooks, createDebugIdUploadFunction, createSentryBuildPluginManager, generateModuleMetadataInjectorCode, generateReleaseInjectorCode, getDebugIdSnippet, globFiles, isJsFile, replaceBooleanFlagsInCode, sentryCliBinaryExists, shouldSkipCodeInjection, stringToUUID } from "@sentry/bundler-plugin-core";
import MagicString from "magic-string";
import * as path from "node:path";
//#region src/index.ts
function hasExistingDebugID(code) {
	const chunkStartSnippet = code.slice(0, 6e3);
	const chunkEndSnippet = code.slice(-500);
	if (chunkStartSnippet.includes("_sentryDebugIdIdentifier") || chunkEndSnippet.includes("//# debugId=")) return true;
	return false;
}
function getRollupMajorVersion() {
	try {
		return createRequire(import.meta.url)("rollup").VERSION?.split(".")[0];
	} catch (err) {}
}
/**
* @ignore - this is the internal plugin factory function only used for the Vite plugin!
*/
function _rollupPluginInternal(userOptions = {}, buildTool, buildToolMajorVersion) {
	const sentryBuildPluginManager = createSentryBuildPluginManager(userOptions, {
		loggerPrefix: userOptions._metaOptions?.loggerPrefixOverride ?? `[sentry-${buildTool}-plugin]`,
		buildTool,
		buildToolMajorVersion: buildToolMajorVersion || getRollupMajorVersion()
	});
	const { logger, normalizedOptions: options, bundleSizeOptimizationReplacementValues: replacementValues, bundleMetadata, createDependencyOnBuildArtifacts } = sentryBuildPluginManager;
	if (options.disable) return { name: "sentry-noop-plugin" };
	if (process.cwd().match(/\\node_modules\\|\/node_modules\//)) logger.warn("Running Sentry plugin from within a `node_modules` folder. Some features may not work.");
	const freeGlobalDependencyOnBuildArtifacts = createDependencyOnBuildArtifacts();
	const upload = createDebugIdUploadFunction({ sentryBuildPluginManager });
	const sourcemapsEnabled = options.sourcemaps?.disable !== true;
	const staticInjectionCode = new CodeInjection();
	if (!options.release.inject) logger.debug("Release injection disabled via `release.inject` option. Will not inject release.");
	else if (!options.release.name) logger.debug("No release name provided. Will not inject release. Please set the `release.name` option to identify your release.");
	else staticInjectionCode.append(generateReleaseInjectorCode({
		release: options.release.name,
		injectBuildInformation: options._experiments.injectBuildInformation || false
	}));
	if (Object.keys(bundleMetadata).length > 0) staticInjectionCode.append(generateModuleMetadataInjectorCode(bundleMetadata));
	const transformAnnotations = options.reactComponentAnnotation?.enabled ? createComponentNameAnnotateHooks(options.reactComponentAnnotation?.ignoredComponents || [], !!options.reactComponentAnnotation?._experimentalInjectIntoHtml) : void 0;
	const transformReplace = Object.keys(replacementValues).length > 0;
	const shouldTransform = transformAnnotations || transformReplace;
	function buildStart() {
		sentryBuildPluginManager.telemetry.emitBundlerPluginExecutionSignal().catch(() => {});
	}
	async function transform(code, id) {
		if (transformAnnotations?.transform) {
			const result = await transformAnnotations.transform(code, id);
			if (result) return result;
		}
		if (transformReplace) return replaceBooleanFlagsInCode(code, replacementValues);
		return null;
	}
	function renderChunk(code, chunk, _, meta) {
		if (!isJsFile(chunk.fileName)) return null;
		if (shouldSkipCodeInjection(code, chunk.facadeModuleId)) return null;
		const injectCode = staticInjectionCode.clone();
		if (sourcemapsEnabled && !hasExistingDebugID(code)) {
			const debugId = stringToUUID(code);
			injectCode.append(getDebugIdSnippet(debugId));
		}
		if (injectCode.isEmpty()) return null;
		const ms = meta?.magicString || new MagicString(code, { filename: chunk.fileName });
		const match = code.match(COMMENT_USE_STRICT_REGEX)?.[0];
		if (match) ms.appendLeft(match.length, injectCode.code());
		else ms.prepend(injectCode.code());
		if (ms?.constructor?.name === "BindingMagicString") return { code: ms };
		return {
			code: ms.toString(),
			map: ms.generateMap({
				file: chunk.fileName,
				hires: "boundary"
			})
		};
	}
	async function writeBundle(outputOptions, bundle) {
		try {
			await sentryBuildPluginManager.createRelease();
			if (sourcemapsEnabled && options.sourcemaps?.disable !== "disable-upload") if (outputOptions.dir) {
				const outputDir = outputOptions.dir;
				await upload(await globFiles([
					"/**/*.js",
					"/**/*.mjs",
					"/**/*.cjs",
					"/**/*.js.map",
					"/**/*.mjs.map",
					"/**/*.cjs.map"
				].map((q) => `${q}?(\\?*)?(#*)`), { root: outputDir }));
			} else if (outputOptions.file) await upload([outputOptions.file]);
			else await upload(Object.keys(bundle).map((asset) => path.join(path.resolve(), asset)));
		} finally {
			freeGlobalDependencyOnBuildArtifacts();
			await sentryBuildPluginManager.deleteArtifacts();
		}
	}
	const name = `sentry-${buildTool}-plugin`;
	if (shouldTransform) return {
		name,
		buildStart,
		transform,
		renderChunk,
		writeBundle
	};
	return {
		name,
		buildStart,
		renderChunk,
		writeBundle
	};
}
function sentryRollupPlugin(userOptions = {}) {
	return [_rollupPluginInternal(userOptions, "rollup")];
}
//#endregion
export { _rollupPluginInternal, sentryCliBinaryExists, sentryRollupPlugin };

//# sourceMappingURL=index.mjs.map