webpack-sources/lib/helpers/getFromStreamChunks.js

Source code handling classes for webpack

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/

"use strict";

const { createMappingsWriter } = require("./createMappingsSerializer");

/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
/** @typedef {import("../Source").SourceAndMap} SourceAndMap */
/** @typedef {import("./streamChunks").Options} Options */
/** @typedef {import("./streamChunks").StreamChunksFunction} StreamChunksFunction */

/** @typedef {{ streamChunks: StreamChunksFunction }} SourceLikeWithStreamChunks */

/** @type {typeof import("./scopes") | undefined} */
let scopesHelpers;

/**
 * Loads the scopes helpers on first use. They are only reachable through the
 * `scopes` option, so requiring them eagerly would put the encoder in the
 * module graph of every caller that never asks for the field.
 * @returns {ReturnType<typeof import("./scopes").createScopesWriter>} writer
 */
const createScopesWriter = () => {
	if (scopesHelpers === undefined) scopesHelpers = require("./scopes");
	return scopesHelpers.createScopesWriter();
};

/**
 * Assign `value` at index `i` of `arr`, padding earlier slots with `null`.
 * Hoisted helper so `getMap` and `getSourceAndMap` share one
 * implementation. Uses `push` rather than `arr.length = i + 1` because the
 * latter forces V8's HOLEY_ELEMENTS kind permanently — push keeps the
 * backing store PACKED, which the downstream source-map serializer iterates
 * over far more efficiently.
 * @template T
 * @param {(T | null)[]} arr destination array
 * @param {number} i index to assign
 * @param {T} value value to assign
 * @returns {void}
 */
const setAtIndex = (arr, i, value) => {
	while (arr.length < i) arr.push(null);
	// `arr[i] = value` where `i === arr.length` extends the array exactly
	// like `push` (V8 keeps PACKED_ELEMENTS); after the while-loop
	// `i <= arr.length` always, so the hole case that would force HOLEY is
	// impossible here.
	arr[i] = value;
};

/**
 * @param {SourceLikeWithStreamChunks} source source
 * @param {Options=} options options
 * @returns {RawSourceMap | null} map
 */
module.exports.getMap = (source, options) => {
	/** @type {(string | null)[]} */
	const potentialSources = [];
	/** @type {(string | null)[]} */
	const potentialSourcesContent = [];
	/** @type {(string | null)[]} */
	const potentialNames = [];
	const mappingsWriter = createMappingsWriter(options);
	const addMapping = mappingsWriter.add;
	const scopesWriter =
		options && options.scopes ? createScopesWriter() : undefined;
	// Chosen once rather than tested per segment: this callback is the whole of
	// the mapping loop, so a branch in it is measurable on every map built.
	const generated = source.streamChunks(
		{ ...options, source: false, finalSource: true },
		scopesWriter === undefined
			? (
					chunk,
					generatedLine,
					generatedColumn,
					sourceIndex,
					originalLine,
					originalColumn,
					nameIndex,
				) => {
					addMapping(
						generatedLine,
						generatedColumn,
						sourceIndex,
						originalLine,
						originalColumn,
						nameIndex,
					);
				}
			: (
					chunk,
					generatedLine,
					generatedColumn,
					sourceIndex,
					originalLine,
					originalColumn,
					nameIndex,
				) => {
					addMapping(
						generatedLine,
						generatedColumn,
						sourceIndex,
						originalLine,
						originalColumn,
						nameIndex,
					);
					scopesWriter.add(
						generatedLine,
						generatedColumn,
						sourceIndex,
						originalLine,
					);
				},
		(sourceIndex, source, sourceContent, scopeBindings) => {
			setAtIndex(potentialSources, sourceIndex, source);
			if (sourceContent !== undefined) {
				setAtIndex(potentialSourcesContent, sourceIndex, sourceContent);
			}
			if (scopesWriter !== undefined) {
				scopesWriter.addSource(sourceIndex, scopeBindings);
			}
		},
		(nameIndex, name) => {
			setAtIndex(potentialNames, nameIndex, name);
		},
	);
	const mappings = mappingsWriter.finish();
	if (mappings.length === 0) return null;
	/** @type {RawSourceMap} */
	const map = {
		version: 3,
		file: "x",
		mappings,
		// We handle broken sources as `null`, in spec this field should be string, but no information what we should do in such cases if we change type it will be breaking change
		sources: /** @type {string[]} */ (potentialSources),
		sourcesContent:
			potentialSourcesContent.length > 0
				? /** @type {string[]} */ (potentialSourcesContent)
				: undefined,
		names: /** @type {string[]} */ (potentialNames),
	};
	if (scopesWriter !== undefined) {
		scopesWriter.finish(
			map,
			generated.generatedLine,
			generated.generatedColumn,
		);
	}
	return map;
};

/**
 * @param {SourceLikeWithStreamChunks} inputSource input source
 * @param {Options=} options options
 * @returns {SourceAndMap} map
 */
module.exports.getSourceAndMap = (inputSource, options) => {
	let code = "";
	/** @type {(string | null)[]} */
	const potentialSources = [];
	/** @type {(string | null)[]} */
	const potentialSourcesContent = [];
	/** @type {(string | null)[]} */
	const potentialNames = [];
	const mappingsWriter = createMappingsWriter(options);
	const addMapping = mappingsWriter.add;
	const scopesWriter =
		options && options.scopes ? createScopesWriter() : undefined;
	const generated = inputSource.streamChunks(
		// `source: true` overrides any `source: false` a caller forwarded
		// (e.g. the streamChunks fallback passing getMap options through
		// sourceAndMap) — this helper always consumes the source.
		{ ...options, finalSource: true, source: true },
		(
			chunk,
			generatedLine,
			generatedColumn,
			sourceIndex,
			originalLine,
			originalColumn,
			nameIndex,
		) => {
			if (chunk !== undefined) code += chunk;
			addMapping(
				generatedLine,
				generatedColumn,
				sourceIndex,
				originalLine,
				originalColumn,
				nameIndex,
			);
			if (scopesWriter !== undefined) {
				scopesWriter.add(
					generatedLine,
					generatedColumn,
					sourceIndex,
					originalLine,
				);
			}
		},
		(sourceIndex, source, sourceContent, scopeBindings) => {
			if (scopesWriter !== undefined) {
				scopesWriter.addSource(sourceIndex, scopeBindings);
			}
			while (potentialSources.length < sourceIndex) {
				potentialSources.push(null);
			}
			potentialSources[sourceIndex] = source;
			if (sourceContent !== undefined) {
				while (potentialSourcesContent.length < sourceIndex) {
					potentialSourcesContent.push(null);
				}
				potentialSourcesContent[sourceIndex] = sourceContent;
			}
		},
		(nameIndex, name) => {
			while (potentialNames.length < nameIndex) {
				potentialNames.push(null);
			}
			potentialNames[nameIndex] = name;
		},
	);
	const mappings = mappingsWriter.finish();
	const { source } = generated;
	/** @type {RawSourceMap | null} */
	let map = null;
	if (mappings.length > 0) {
		map = {
			version: 3,
			file: "x",
			mappings,
			// We handle broken sources as `null`, in spec this field should be string, but no information what we should do in such cases if we change type it will be breaking change
			sources: /** @type {string[]} */ (potentialSources),
			sourcesContent:
				potentialSourcesContent.length > 0
					? /** @type {string[]} */ (potentialSourcesContent)
					: undefined,
			names: /** @type {string[]} */ (potentialNames),
		};
		if (scopesWriter !== undefined) {
			scopesWriter.finish(
				map,
				generated.generatedLine,
				generated.generatedColumn,
			);
		}
	}
	return { source: source !== undefined ? source : code, map };
};