/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Mark Knichel @mknichel
*/
"use strict";
let dualStringBufferCaching = true;
/**
* @returns {boolean} Whether the optimization to cache copies of both the
* string and buffer version of source content is enabled. This is enabled by
* default to improve performance but can consume more memory since values are
* stored twice.
*/
function isDualStringBufferCachingEnabled() {
return dualStringBufferCaching;
}
/**
* Enables an optimization to save both string and buffer in memory to avoid
* repeat conversions between the two formats when they are requested. This
* is enabled by default. This option can improve performance but can consume
* additional memory since values are stored twice.
* @returns {void}
*/
function enableDualStringBufferCaching() {
dualStringBufferCaching = true;
}
/**
* Disables the optimization to save both string and buffer in memory. This
* may increase performance but should reduce memory usage in the Webpack
* compiler.
* @returns {void}
*/
function disableDualStringBufferCaching() {
dualStringBufferCaching = false;
}
const interningStringMap = new Map();
let enableStringInterningRefCount = 0;
/**
* @returns {boolean} value
*/
function isStringInterningEnabled() {
return enableStringInterningRefCount > 0;
}
/**
* Starts a memory optimization to avoid repeat copies of the same string in
* memory by caching a single reference to the string. This can reduce memory
* usage if the same string is repeated many times in the compiler, such as
* when Webpack layers are used with the same files.
*
* {@link exitStringInterningRange} should be called when string interning is
* no longer necessary to free up the memory used by the interned strings. If
* {@link enterStringInterningRange} has been called multiple times, then
* this method may not immediately free all the memory until
* {@link exitStringInterningRange} has been called to end all string
* interning ranges.
* @returns {void}
*/
function enterStringInterningRange() {
enableStringInterningRefCount++;
}
/**
* Stops the current string interning range. Once all string interning ranges
* have been exited, this method will free all the memory used by the interned
* strings. This method should be called once for each time that
* {@link enterStringInterningRange} was called.
* @returns {void}
*/
function exitStringInterningRange() {
if (--enableStringInterningRefCount <= 0) {
interningStringMap.clear();
enableStringInterningRefCount = 0;
}
}
/**
* Saves the string in a map to ensure that only one copy of the string exists
* in memory at a given time. This is controlled by {@link enableStringInterning}
* and {@link disableStringInterning}. Callers are expect to manage the memory
* of the interned strings by calling {@link disableStringInterning} after the
* compiler no longer needs to save the interned memory.
* @param {string} str A string to be interned.
* @returns {string} The original string or a reference to an existing string of the same value if it has already been interned.
*/
function internString(str) {
if (
!isStringInterningEnabled() ||
!str ||
str.length < 128 ||
typeof str !== "string"
) {
return str;
}
let internedString = interningStringMap.get(str);
if (internedString === undefined) {
internedString = str;
interningStringMap.set(str, internedString);
}
return internedString;
}
module.exports = {
disableDualStringBufferCaching,
enableDualStringBufferCaching,
internString,
isDualStringBufferCachingEnabled,
enterStringInterningRange,
exitStringInterningRange,
};