Dev

package.json

@@ -88,22 +88,22 @@
   },
   "prettier": "@webdeveric/prettier-config",
   "devDependencies": {
-    "@types/node": "^22.9.1",
-    "@vitest/coverage-v8": "^2.1.5",
+    "@types/node": "^22.10.1",
+    "@vitest/coverage-v8": "^2.1.6",
     "@webdeveric/eslint-config-ts": "^0.11.0",
     "@webdeveric/prettier-config": "^0.3.0",
-    "cspell": "^8.16.0",
+    "cspell": "^8.16.1",
     "eslint": "^8.57.1",
     "eslint-config-prettier": "^9.1.0",
     "eslint-import-resolver-typescript": "^3.6.3",
     "eslint-plugin-import": "^2.31.0",
     "husky": "^9.1.7",
     "jsdom": "^25.0.1",
     "lint-staged": "^15.2.10",
-    "prettier": "^3.3.3",
+    "prettier": "^3.4.1",
     "rimraf": "^6.0.1",
     "typescript": "^5.7.2",
     "validate-package-exports": "^0.7.0",
-    "vitest": "^2.1.5"
+    "vitest": "^2.1.6"
   }
 }

src/describeInput.ts

@@ -8,7 +8,7 @@ export const describeInput = (input: unknown): string => {
     case 'symbol':
       return input.toString();
     case 'function': {
-      const args = input.toString().match(/^(function\s*\w*)?(?<args>\([^)]*\))/)?.groups?.args;
+      const args = /^(function\s*\w*)?(?<args>\([^)]*\))/.exec(input.toString())?.groups?.['args'];
 
       return `${input.name || 'anonymous'}${args}`;
     }
@@ -18,7 +18,7 @@ export const describeInput = (input: unknown): string => {
           return 'Numeric String';
         }
 
-        const authType = input.match(/^(?<authType>Basic|Bearer)\s.+/i)?.groups?.authType;
+        const authType = /^(?<authType>Basic|Bearer)\s.+/i.exec(input)?.groups?.['authType'];
 
         if (authType) {
           return `${authType} Authorization`;

src/getPackageName.ts

@@ -1,3 +1,3 @@
 export function getPackageName(input: string): string | undefined {
-  return input.match(/^(?<pkg>(?:(?<scope>@[^/]+)\/)?(?<name>[a-z][^/]+))/i)?.groups?.pkg;
+  return /^(?<pkg>(?:(?<scope>@[^/]+)\/)?(?<name>[a-z][^/]+))/i.exec(input)?.groups?.['pkg'];
 }

src/predicate/index.ts

@@ -1,3 +1,5 @@
+export * from './isAnyObject.js';
+export * from './isAnyObjectWith.js';
 export * from './isAsyncIterable.js';
 export * from './isBigInt.js';
 export * from './isBigIntArray.js';

src/predicate/isAnyObject.ts

@@ -0,0 +1,6 @@
+import type { UnknownRecord } from '../types/records.js';
+
+/**
+ * Determine if `input` is any non-null object.
+ */
+export const isAnyObject = <T>(input: T): input is T & UnknownRecord => input !== null && typeof input === 'object';

src/predicate/isAnyObjectWith.ts

@@ -0,0 +1,13 @@
+import { asArray } from '../asArray.js';
+
+import { isAnyObject } from './isAnyObject.js';
+
+/**
+ * Determine if `input` is an object and has the provided properties.
+ */
+export const isAnyObjectWith = <T, P extends PropertyKey>(
+  input: T,
+  properties: P | P[],
+): input is T & Record<P, unknown> => {
+  return isAnyObject(input) && asArray(properties).every((property) => property in input);
+};

src/predicate/isObject.ts

@@ -1,5 +1,7 @@
+import type { UnknownRecord } from '../types/records.js';
+
 /**
- * Determine if `input` is an object and not null or an array.
+ * Determine if `input` is a non-null object and not an array.
  */
-export const isObject = (input: unknown): input is object =>
+export const isObject = <T>(input: T): input is T & UnknownRecord =>
   input !== null && typeof input === 'object' && !Array.isArray(input);

src/trimIndentation.ts

@@ -2,8 +2,9 @@ const isWhitespaceOnly = (input: string): boolean => /^\s*$/.test(input);
 
 export function trimIndentation(input: string): string {
   const lines = input.split('\n');
-  const firstNonWhitespaceLine = lines.find((line) => !isWhitespaceOnly(line));
-  const whiteSpace = firstNonWhitespaceLine?.match(/^(?<whiteSpace>\s*)/)?.groups?.whiteSpace;
+  const whiteSpace = lines.find((line) => !isWhitespaceOnly(line))?.match(/^(?<whiteSpace>\s*)/)?.groups?.[
+    'whiteSpace'
+  ];
 
   if (whiteSpace) {
     const wsPattern = new RegExp(`^${whiteSpace}`);

test/predicate/isAnyObject.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+
+import { isAnyObject } from '../../src/predicate/isAnyObject.js';
+
+describe('isAnyObject()', () => {
+  it.each([{}, [], new Object(), new Date()])('Returns true for valid inputs', (item) => {
+    expect(isAnyObject(item)).toBeTruthy();
+  });
+
+  it.each([null, false, 'string', Math.PI, Symbol(), undefined])('Returns false for invalid inputs', (item) => {
+    expect(isAnyObject(item)).toBeFalsy();
+  });
+});

test/predicate/isAnyObjectWith.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+
+import { isAnyObjectWith } from '../../src/predicate/isAnyObjectWith.js';
+
+describe('isAnyObjectWith()', () => {
+  it('Returns true for valid inputs', () => {
+    expect(isAnyObjectWith({ property: true }, 'property')).toBeTruthy();
+    expect(isAnyObjectWith({ name: 'Test Testerson', age: 100 }, ['name', 'age'])).toBeTruthy();
+    expect(isAnyObjectWith(['item'], 'length')).toBeTruthy();
+  });
+
+  it.each([null, false, 'string', Math.PI, Symbol()])('Returns false for invalid inputs', (item) => {
+    expect(isAnyObjectWith(item, 'property')).toBeFalsy();
+    expect(isAnyObjectWith(item, ['property'])).toBeFalsy();
+  });
+});

test/predicate/isObject.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+
+import { isObject } from '../../src/predicate/isObject.js';
+
+describe('isObject()', () => {
+  it.each([{}, new Object(), new Date()])('Returns true for valid inputs', (item) => {
+    expect(isObject(item)).toBeTruthy();
+  });
+
+  it.each([null, false, 'string', Math.PI, Symbol(), undefined, []])('Returns false for invalid inputs', (item) => {
+    expect(isObject(item)).toBeFalsy();
+  });
+});

test/type-predicate.test.ts

@@ -22,7 +22,6 @@ import {
   isNumericString,
   isNumericValue,
   isNumericValueArray,
-  isObject,
   isOptionalBigInt,
   isOptionalBoolean,
   isOptionalISODateString,
@@ -466,17 +465,6 @@ describe('isAsyncIterable()', () => {
   });
 });
 
-describe('isObject()', () => {
-  it('Returns true for valid inputs', () => {
-    expect(isObject({})).toBeTruthy();
-  });
-
-  it('Returns false for invalid inputs', () => {
-    expect(isObject('test')).toBeFalsy();
-    expect(isObject(null)).toBeFalsy();
-  });
-});
-
 describe('isLengthAware()', () => {
   it('Returns true for valid inputs', () => {
     expect(isLengthAware([])).toBeTruthy();

test/until.test.ts

@@ -206,13 +206,13 @@ describe('until()', () => {
     it('Keeps track of arbitrary data', async () => {
       const result = await until<UntilContext>(
         (resolve, _reject, context) => {
-          context.data.demo = true;
+          context.data['demo'] = true;
           resolve(context);
         },
         { delay: 0, timeout: 10 },
       );
 
-      expect(result.data.demo).toBeTruthy();
+      expect(result.data['demo']).toBeTruthy();
     });
 
     it('Keeps track of options', async () => {

tsconfig.json

@@ -16,6 +16,7 @@
     "moduleResolution": "node",
     "esModuleInterop": true,
     "skipLibCheck": true,
+    "noPropertyAccessFromIndexSignature": true,
     "noUncheckedIndexedAccess": true,
     "forceConsistentCasingInFileNames": true,
     "allowUnusedLabels": false,