complete-common 2.28.0 → 2.30.0

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;
 }
 

package/src/index.ts

@@ -17,8 +17,10 @@ export type * from "./interfaces/SemanticVersion.js";
 export type * from "./types/AddSubtract.js";
 export type * from "./types/CompositionTypeSatisfiesEnum.js";
 export type * from "./types/ERange.js";
+export type * from "./types/Expect.js";
 export type * from "./types/Immutable.js";
 export type * from "./types/IRange.js";
+export type * from "./types/KeysMatch.js";
 export type * from "./types/NaturalNumbersLessThan.js";
 export type * from "./types/NaturalNumbersLessThanOrEqualTo.js";
 export type * from "./types/ObjectValues.js";

package/src/types/Expect.ts

@@ -0,0 +1,5 @@
+/**
+ * Helper type used for testing other interfaces/types. Only `true` is assignable, anything else
+ * errors.
+ */
+export type Expect<T extends true> = T;

package/src/types/KeysMatch.ts

@@ -0,0 +1,28 @@
+/**
+ * Helper type to ensure that an array of keys matches an interface.
+ *
+ * For example:
+ *
+ * ```ts
+ * interface Foo {
+ *   arg1: string;
+ *   arg2: string;
+ * }
+ *
+ * const FOO_KEYS = ["arg1", "arg2"] as const;
+ * type _ = Expect<KeysMatch<Foo, typeof FOO_KEYS>>;
+ * ```
+ */
+export type KeysMatch<T, Keys extends readonly PropertyKey[]> = [
+  keyof T,
+] extends [Keys[number]]
+  ? [Keys[number]] extends [keyof T]
+    ? true
+    : {
+        error: "Extra keys not in interface";
+        extra: Exclude<Keys[number], keyof T>;
+      }
+  : {
+      error: "Missing keys from interface";
+      missing: Exclude<keyof T, Keys[number]>;
+    };