mirror of
https://github.com/renovatebot/renovate.git
synced 2025-03-15 08:34:54 +00:00
170 lines
4.1 KiB
TypeScript
170 lines
4.1 KiB
TypeScript
// Return true if the match string is found at index in content
|
|
export function matchAt(
|
|
content: string,
|
|
index: number,
|
|
match: string,
|
|
): boolean {
|
|
return content.substring(index, index + match.length) === match;
|
|
}
|
|
|
|
// Replace oldString with newString at location index of content
|
|
export function replaceAt(
|
|
content: string,
|
|
index: number,
|
|
oldString: string,
|
|
newString: string,
|
|
): string {
|
|
return (
|
|
content.substring(0, index) +
|
|
newString +
|
|
content.substring(index + oldString.length)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Converts from utf-8 string to base64-encoded string
|
|
*/
|
|
export function toBase64(input: string): string {
|
|
return Buffer.from(input).toString('base64');
|
|
}
|
|
|
|
/**
|
|
* Converts from base64-encoded string to utf-8 string
|
|
*/
|
|
export function fromBase64(input: string): string {
|
|
return Buffer.from(input, 'base64').toString();
|
|
}
|
|
|
|
export function uniqueStrings(
|
|
element: string,
|
|
index: number,
|
|
elements: string[],
|
|
): boolean {
|
|
return elements.indexOf(element) === index;
|
|
}
|
|
|
|
export function looseEquals(
|
|
a: string | null | undefined,
|
|
b: string | null | undefined,
|
|
): boolean {
|
|
if (!(a && b)) {
|
|
return a === b;
|
|
}
|
|
return a.localeCompare(b, undefined, { sensitivity: 'base' }) === 0;
|
|
}
|
|
|
|
export function titleCase(input: string): string {
|
|
const words = input.toLowerCase().split(' ');
|
|
|
|
for (let i = 0; i < words.length; i++) {
|
|
const word = words[i];
|
|
words[i] = word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
|
|
}
|
|
|
|
return words.join(' ');
|
|
}
|
|
|
|
/**
|
|
* Sometimes we extract small strings from a multi-megabyte files.
|
|
* If we then save them in the in-memory cache, V8 may not free
|
|
* the initial buffer, which can lead to memory leaks:
|
|
*
|
|
* https://bugs.chromium.org/p/v8/issues/detail?id=2869
|
|
*
|
|
*/
|
|
export function copystr(x: string): string {
|
|
const len = Buffer.byteLength(x, 'utf8');
|
|
const buf = Buffer.allocUnsafeSlow(len);
|
|
buf.write(x, 'utf8');
|
|
return buf.toString('utf8');
|
|
}
|
|
|
|
/**
|
|
* Coerce a value to a string with optional default value.
|
|
* @param val value to coerce
|
|
* @returns the coerced value.
|
|
*/
|
|
export function coerceString(
|
|
val: string | null | undefined,
|
|
def?: string,
|
|
): string {
|
|
return val ?? def ?? '';
|
|
}
|
|
|
|
/**
|
|
* Remove templates from string.
|
|
*
|
|
* This is more performant version of this code:
|
|
*
|
|
* ```
|
|
* content
|
|
* .replaceAll(regEx(/{{`.+?`}}/gs), '')
|
|
* .replaceAll(regEx(/{{.+?}}/gs), '')
|
|
* .replaceAll(regEx(/{%`.+?`%}/gs), '')
|
|
* .replaceAll(regEx(/{%.+?%}/gs), '')
|
|
* .replaceAll(regEx(/{#.+?#}/gs), '')
|
|
* ```
|
|
*/
|
|
export function stripTemplates(content: string): string {
|
|
const result: string[] = [];
|
|
|
|
const len = content.length;
|
|
let idx = 0;
|
|
let lastPos = 0; // Tracks the start index of the next chunk to push
|
|
while (idx < len) {
|
|
if (content[idx] === '{' && idx + 1 < len) {
|
|
let closing: string | undefined;
|
|
let skipLength = 0;
|
|
|
|
if (content[idx + 1] === '%') {
|
|
if (idx + 2 < len && content[idx + 2] === '`') {
|
|
// Handle `{%` ... `%}`
|
|
closing = '`%}';
|
|
skipLength = 3;
|
|
} else {
|
|
// Handle `{% ... %}`
|
|
closing = '%}';
|
|
skipLength = 2;
|
|
}
|
|
} else if (content[idx + 1] === '{') {
|
|
if (idx + 2 < len && content[idx + 2] === '`') {
|
|
// Handle `{{` ... `}}`
|
|
closing = '`}}';
|
|
skipLength = 3;
|
|
} else {
|
|
// Handle `{{ ... }}`
|
|
closing = '}}';
|
|
skipLength = 2;
|
|
}
|
|
} else if (content[idx + 1] === '#') {
|
|
// Handle `{# ... #}`
|
|
closing = '#}';
|
|
skipLength = 2;
|
|
}
|
|
|
|
if (closing) {
|
|
const end = content.indexOf(closing, idx + skipLength);
|
|
if (end !== -1) {
|
|
// Append the content before the pattern
|
|
if (idx > lastPos) {
|
|
result.push(content.slice(lastPos, idx));
|
|
}
|
|
|
|
// Move `idx` past the closing tag
|
|
idx = end + closing.length;
|
|
lastPos = idx; // Update the last position
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
idx++;
|
|
}
|
|
|
|
// Append any remaining content after the last pattern
|
|
if (lastPos < len) {
|
|
result.push(content.slice(lastPos));
|
|
}
|
|
|
|
return result.join('');
|
|
}
|