142 lines
4.0 KiB
JavaScript
142 lines
4.0 KiB
JavaScript
import { isVueViewModel, isString, isRegExp } from './is.js';
|
|
|
|
/**
|
|
* Truncates given string to the maximum characters count
|
|
*
|
|
* @param str An object that contains serializable values
|
|
* @param max Maximum number of characters in truncated string (0 = unlimited)
|
|
* @returns string Encoded
|
|
*/
|
|
function truncate(str, max = 0) {
|
|
if (typeof str !== 'string' || max === 0) {
|
|
return str;
|
|
}
|
|
return str.length <= max ? str : `${str.slice(0, max)}...`;
|
|
}
|
|
|
|
/**
|
|
* This is basically just `trim_line` from
|
|
* https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67
|
|
*
|
|
* @param str An object that contains serializable values
|
|
* @param max Maximum number of characters in truncated string
|
|
* @returns string Encoded
|
|
*/
|
|
function snipLine(line, colno) {
|
|
let newLine = line;
|
|
const lineLength = newLine.length;
|
|
if (lineLength <= 150) {
|
|
return newLine;
|
|
}
|
|
if (colno > lineLength) {
|
|
// eslint-disable-next-line no-param-reassign
|
|
colno = lineLength;
|
|
}
|
|
|
|
let start = Math.max(colno - 60, 0);
|
|
if (start < 5) {
|
|
start = 0;
|
|
}
|
|
|
|
let end = Math.min(start + 140, lineLength);
|
|
if (end > lineLength - 5) {
|
|
end = lineLength;
|
|
}
|
|
if (end === lineLength) {
|
|
start = Math.max(end - 140, 0);
|
|
}
|
|
|
|
newLine = newLine.slice(start, end);
|
|
if (start > 0) {
|
|
newLine = `'{snip} ${newLine}`;
|
|
}
|
|
if (end < lineLength) {
|
|
newLine += ' {snip}';
|
|
}
|
|
|
|
return newLine;
|
|
}
|
|
|
|
/**
|
|
* Join values in array
|
|
* @param input array of values to be joined together
|
|
* @param delimiter string to be placed in-between values
|
|
* @returns Joined values
|
|
*/
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
function safeJoin(input, delimiter) {
|
|
if (!Array.isArray(input)) {
|
|
return '';
|
|
}
|
|
|
|
const output = [];
|
|
// eslint-disable-next-line @typescript-eslint/prefer-for-of
|
|
for (let i = 0; i < input.length; i++) {
|
|
const value = input[i];
|
|
try {
|
|
// This is a hack to fix a Vue3-specific bug that causes an infinite loop of
|
|
// console warnings. This happens when a Vue template is rendered with
|
|
// an undeclared variable, which we try to stringify, ultimately causing
|
|
// Vue to issue another warning which repeats indefinitely.
|
|
// see: https://github.com/getsentry/sentry-javascript/pull/8981
|
|
if (isVueViewModel(value)) {
|
|
output.push('[VueViewModel]');
|
|
} else {
|
|
output.push(String(value));
|
|
}
|
|
} catch (e) {
|
|
output.push('[value cannot be serialized]');
|
|
}
|
|
}
|
|
|
|
return output.join(delimiter);
|
|
}
|
|
|
|
/**
|
|
* Checks if the given value matches a regex or string
|
|
*
|
|
* @param value The string to test
|
|
* @param pattern Either a regex or a string against which `value` will be matched
|
|
* @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match
|
|
* `pattern` if it contains `pattern`. Only applies to string-type patterns.
|
|
*/
|
|
function isMatchingPattern(
|
|
value,
|
|
pattern,
|
|
requireExactStringMatch = false,
|
|
) {
|
|
if (!isString(value)) {
|
|
return false;
|
|
}
|
|
|
|
if (isRegExp(pattern)) {
|
|
return pattern.test(value);
|
|
}
|
|
if (isString(pattern)) {
|
|
return requireExactStringMatch ? value === pattern : value.includes(pattern);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Test the given string against an array of strings and regexes. By default, string matching is done on a
|
|
* substring-inclusion basis rather than a strict equality basis
|
|
*
|
|
* @param testString The string to test
|
|
* @param patterns The patterns against which to test the string
|
|
* @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to
|
|
* count. If false, `testString` will match a string pattern if it contains that pattern.
|
|
* @returns
|
|
*/
|
|
function stringMatchesSomePattern(
|
|
testString,
|
|
patterns = [],
|
|
requireExactStringMatch = false,
|
|
) {
|
|
return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));
|
|
}
|
|
|
|
export { isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, truncate };
|
|
//# sourceMappingURL=string.js.map
|