complete-common 2.29.0 → 2.31.0

package/src/functions/string.ts

@@ -14,25 +14,25 @@ import { parseIntSafe } from "./utils.js";
 // they will return inconsistent results due to the `lastIndex` property persisting between calls.
 
 /** We use a "*" instead of a "+" so that an empty string will match. */
-// eslint-disable-next-line no-control-regex
-const ASCII_REGEX = /^[\u0000-\u007F]*$/;
+const ASCII_REGEX = /^\p{ASCII}*$/v;
 
-const DIACRITIC_REGEX = /\p{Diacritic}/u;
+const DIACRITIC_REGEX = /\p{Diacritic}/v;
+const FIRST_LETTER_CAPITALIZED_REGEX = /^\p{Lu}/v;
 
 /**
- * - We can't use `/\p{Emoji}/u` because it has a false positive on "#" characters.
- * - We can't use `/\p{Extended_Pictographic}/u` because it has a false negative on keycap emojis.
+ * - We can't use `/\p{Emoji}/v` because it has a false positive on "#" characters.
+ * - We can't use `/\p{Extended_Pictographic}/v` because it has a false negative on keycap emojis.
  */
-const EMOJI_REGEX = /(\p{Extended_Pictographic}|[#*0-9]\uFE0F?\u20E3)/u;
+const EMOJI_REGEX = /\p{Extended_Pictographic}|[#*0-9]\u{FE0F}?\u{20E3}/v;
 
-const FIRST_LETTER_CAPITALIZED_REGEX = /^\p{Lu}/u;
-const KEBAB_CASE_REGEX = /^[\da-z]+(?:-[\da-z]+)*$/;
-const SEMANTIC_VERSION_REGEX = /^v*(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)/;
-const WHITESPACE_REGEX = /\s/;
-const WHITESPACE_GLOBAL_REGEX = /\s/g;
-const TITLE_CASE_BOUNDARY_REGEX = /(?<=[\da-z])(?=[A-Z])/g;
-const UPPERCASE_REGEX = /^[A-Z]*$/;
-const LOWERCASE_REGEX = /^[a-z]*$/;
+const KEBAB_CASE_REGEX = /^[\da-z]+(?:-[\da-z]+)*$/v;
+const SEMANTIC_VERSION_REGEX =
+  /^v*(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)/v;
+const WHITESPACE_REGEX = /\s/v;
+const WHITESPACE_GLOBAL_REGEX = /\s/gv;
+const TITLE_CASE_BOUNDARY_REGEX = /(?<=[\da-z])(?=[A-Z])/gv;
+const UPPERCASE_REGEX = /^[A-Z]*$/v;
+const LOWERCASE_REGEX = /^[a-z]*$/v;
 
 /** Helper function to capitalize the first letter of a string. */
 export function capitalizeFirstLetter(string: string): string {
@@ -124,6 +124,7 @@ export function isASCII(str: string): boolean {
  * https://stackoverflow.com/questions/8334606/check-if-first-letter-of-word-is-a-capital-letter
  */
 export function isFirstLetterCapitalized(string: string): boolean {
+  // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
   return FIRST_LETTER_CAPITALIZED_REGEX.test(string);
 }
 
@@ -157,8 +158,8 @@ export function isUpperCase(string: string): boolean {
 
 /** Helper function to convert a string from kebab-case to camelCase. */
 export function kebabCaseToCamelCase(string: string): string {
-  return string.replaceAll(/-./g, (match) => {
-    const firstLetterOfWord = match[1];
+  return string.replaceAll(/-./gv, (match) => {
+    const firstLetterOfWord = match.at(1);
     return firstLetterOfWord === undefined
       ? ""
       : firstLetterOfWord.toUpperCase();
@@ -189,11 +190,11 @@ export function normalizeString(string: string): string {
 
   // Normalize newlines.
   sanitizedString = sanitizedString.replaceAll("\n\r", "\n");
-  sanitizedString = sanitizedString.replaceAll(/\p{Zl}/gu, "\n");
-  sanitizedString = sanitizedString.replaceAll(/\p{Zp}/gu, "\n");
+  sanitizedString = sanitizedString.replaceAll(/\p{Zl}/gv, "\n");
+  sanitizedString = sanitizedString.replaceAll(/\p{Zp}/gv, "\n");
 
   // Normalize spaces.
-  sanitizedString = sanitizedString.replaceAll(/\p{Zs}/gu, " ");
+  sanitizedString = sanitizedString.replaceAll(/\p{Zs}/gv, " ");
 
   // Remove leading/trailing whitespace.
   sanitizedString = sanitizedString.trim();
@@ -210,7 +211,7 @@ export function normalizeString(string: string): string {
 export function parseSemanticVersion(
   versionString: string,
 ): SemanticVersion | undefined {
-  const match = versionString.match(SEMANTIC_VERSION_REGEX);
+  const match = SEMANTIC_VERSION_REGEX.exec(versionString);
   if (match === null || match.groups === undefined) {
     return undefined;
   }
@@ -232,7 +233,11 @@ export function parseSemanticVersion(
     return undefined;
   }
 
-  return { majorVersion, minorVersion, patchVersion };
+  return {
+    majorVersion,
+    minorVersion,
+    patchVersion,
+  };
 }
 
 /* eslint-disable jsdoc/escape-inline-tags */
@@ -301,7 +306,7 @@ export function removeLinesMatching(string: string, match: string): string {
  * https://stackoverflow.com/questions/11598786/how-to-replace-non-printable-unicode-characters-javascript
  */
 export function removeNonPrintableCharacters(string: string): string {
-  return string.replaceAll(/\p{C}/gu, "");
+  return string.replaceAll(/\p{C}/gv, "");
 }
 
 /** Helper function to remove all whitespace characters from a string. */
@@ -353,7 +358,7 @@ export function satisfiesSemanticVersion(
 export function titleCaseToKebabCase(string: string): string {
   return string
     .replaceAll(TITLE_CASE_BOUNDARY_REGEX, "-")
-    .replaceAll(/ +/g, "-")
+    .replaceAll(/ +/gv, "-")
     .toLowerCase();
 }
 

package/src/functions/time.ts

@@ -17,10 +17,13 @@
  * const elapsedSeconds = getElapsedSeconds(startTime);
  * ```
  */
-export function getElapsedSeconds(startTime: number): number {
+export function getElapsedSeconds(
+  startTime: number,
+  roundToInteger = true,
+): number {
   const endTime = Date.now();
   const elapsedMilliseconds = endTime - startTime;
   const elapsedSeconds = elapsedMilliseconds / 1000;
 
-  return Math.floor(elapsedSeconds);
+  return roundToInteger ? Math.floor(elapsedSeconds) : elapsedSeconds;
 }

package/src/functions/tuple.ts

@@ -13,7 +13,7 @@ type TupleValue<T extends readonly unknown[]> = T[0];
 type TupleEntry<T extends readonly unknown[]> = [TupleKey<T>, TupleValue<T>]; // eslint-disable-line perfectionist/sort-modules
 
 /**
- * Helper function to get the entries (i.e. indexes and values) of a tuple in a type-safe way.
+ * Helper function to get the entries (i.e., indexes and values) of a tuple in a type-safe way.
  *
  * This is useful because the vanilla `Array.entries` method will always have the keys be of type
  * `number`.
@@ -25,7 +25,7 @@ export function* tupleEntries<T extends readonly unknown[]>(
 }
 
 /**
- * Helper function to get the keys (i.e. indexes) of a tuple in a type-safe way.
+ * Helper function to get the keys (i.e., indexes) of a tuple in a type-safe way.
  *
  * This is useful because the vanilla `Array.keys` method will always have the keys be of type
  * `number`.

package/src/functions/types.ts

@@ -5,7 +5,7 @@
  */
 
 /**
- * Helper function to narrow an unknown value to an object (i.e. a TypeScript record).
+ * Helper function to narrow an unknown value to an object (i.e., a TypeScript record).
  *
  * Under the hood, this checks for `typeof variable === "object"`, `variable !== null`, and
  * `!Array.isArray(variable)`.

package/src/functions/utils.ts

@@ -7,8 +7,8 @@
 // When regexes are located at the root instead of inside the function, the functions are tested to
 // perform 11% faster.
 
-const FLOAT_REGEX = /^-?\d*\.?\d+$/;
-const INTEGER_REGEX = /^-?\d+$/;
+const FLOAT_REGEX = /^-?(?:\d+(?:\.\d+)?|\.\d+)$/v;
+const INTEGER_REGEX = /^-?\d+$/v;
 
 /**
  * Helper function to get an iterator of integers with the specified range, inclusive on the lower
@@ -99,7 +99,7 @@ export function isKeyOf<T extends object>(
   key: PropertyKey,
   target: T,
 ): key is keyof T {
-  return key in target;
+  return Object.hasOwn(target, key);
 }
 
 /**
@@ -115,10 +115,8 @@ export function noop(): void {}
  * - `undefined` is returned instead of `Number.NaN`, which is helpful in conjunction with
  *   TypeScript type narrowing patterns.
  * - Strings that are a mixture of numbers and letters will result in undefined instead of the part
- *   of the string that is the number. (e.g. "1a" --> undefined instead of "1a" --> 1)
+ *   of the string that is the number. (e.g., "1a" --> undefined instead of "1a" --> 1)
  * - Non-strings will result in undefined instead of being coerced to a number.
- *
- * @param string A string to convert to an integer.
  */
 export function parseFloatSafe(string: string): number | undefined {
   if (typeof string !== "string") {
@@ -128,11 +126,13 @@ export function parseFloatSafe(string: string): number | undefined {
   const trimmedString = string.trim();
 
   // If the string does not entirely consist of numbers, return undefined.
-  if (FLOAT_REGEX.exec(trimmedString) === null) {
+  if (!FLOAT_REGEX.test(trimmedString)) {
     return undefined;
   }
 
-  const number = Number.parseFloat(trimmedString);
+  // The "Number" constructor is used instead of "Number.parseFloat":
+  // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-number-coercion.md
+  const number = Number(trimmedString);
   return Number.isNaN(number) ? undefined : number;
 }
 
@@ -142,7 +142,7 @@ export function parseFloatSafe(string: string): number | undefined {
  * - `undefined` is returned instead of `Number.NaN`, which is helpful in conjunction with
  *   TypeScript type narrowing patterns.
  * - Strings that are a mixture of numbers and letters will result in undefined instead of the part
- *   of the string that is the number. (e.g. "1a" --> undefined instead of "1a" --> 1)
+ *   of the string that is the number. (e.g., "1a" --> undefined instead of "1a" --> 1)
  * - Non-strings will result in undefined instead of being coerced to a number.
  *
  * If you have to use a radix other than 10, use the vanilla `Number.parseInt` function instead,
@@ -156,11 +156,13 @@ export function parseIntSafe(string: string): number | undefined {
   const trimmedString = string.trim();
 
   // If the string does not entirely consist of numbers, return undefined.
-  if (INTEGER_REGEX.exec(trimmedString) === null) {
+  if (!INTEGER_REGEX.test(trimmedString)) {
     return undefined;
   }
 
-  const number = Number.parseInt(trimmedString, 10);
+  // The "Number" constructor is used instead of "Number.parseInt":
+  // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-number-coercion.md
+  const number = Math.trunc(Number(trimmedString));
   return Number.isNaN(number) ? undefined : number;
 }