Improve the hasProperty function

src/misc.test-d.ts

@@ -1,6 +1,6 @@
 import { expectAssignable, expectNotAssignable } from 'tsd';
 
-import { isObject, hasProperty, RuntimeObject } from '.';
+import { isObject, hasProperty, RuntimeObject } from './misc';
 
 //=============================================================================
 // isObject
@@ -36,6 +36,20 @@ if (isObject(unknownObject)) {
   expectNotAssignable<Record<'foo', unknown>>(unknownObject);
 }
 
+// An object is accepted after `hasProperty` is used to prove that it has the required property.
+if (isObject(unknownObject) && hasProperty(unknownObject, 'foo')) {
+  expectAssignable<Record<'foo', unknown>>(unknownObject);
+}
+
+// An object is accepted after `hasProperty` is used to prove that it has all required properties.
+if (
+  isObject(unknownObject) &&
+  hasProperty(unknownObject, 'foo') &&
+  hasProperty(unknownObject, 'bar')
+) {
+  expectAssignable<Record<'foo' | 'bar', unknown>>(unknownObject);
+}
+
 // An object is not accepted after `hasProperty` has only been used to establish that some required properties exist.
 if (isObject(unknownObject) && hasProperty(unknownObject, 'foo')) {
   expectNotAssignable<Record<'foo' | 'bar', unknown>>(unknownObject);

src/misc.test.ts

@@ -109,10 +109,7 @@ describe('miscellaneous', () => {
         [
           [{}, 'a'],
           [{ a: 1 }, 'b'],
-          // Object.hasOwnProperty does not work for arrays
-          // [['foo'], 0],
-          // [['foo'], '0'],
-        ] as any[]
+        ] as const
       ).forEach(([objectValue, property]) => {
         expect(hasProperty(objectValue, property)).toBe(false);
       });

src/misc.ts

@@ -32,10 +32,9 @@ export type PartialOrAbsent<Value> = Partial<Value> | null | undefined;
 export type NonEmptyArray<Element> = [Element, ...Element[]];
 
 /**
- * A JavaScript object that is not `null`, a function, or an array. The object
- * can still be an instance of a class.
+ * A JavaScript object that is not `null`, a function, or an array.
  */
-export type RuntimeObject = Record<number | string | symbol, unknown>;
+export type RuntimeObject = Record<PropertyKey, unknown>;
 
 //
 // Type Guards
@@ -80,17 +79,21 @@ export function isObject(value: unknown): value is RuntimeObject {
 //
 
 /**
- * An alias for {@link Object.hasOwnProperty}.
+ * A type guard for ensuring an object has a property.
  *
- * @param object - The object to check.
+ * @param objectToCheck - The object to check.
  * @param name - The property name to check for.
  * @returns Whether the specified object has an own property with the specified
  * name, regardless of whether it is enumerable or not.
  */
-export const hasProperty = (
-  object: RuntimeObject,
-  name: string | number | symbol,
-): boolean => Object.hasOwnProperty.call(object, name);
+export const hasProperty = <
+  ObjectToCheck extends RuntimeObject,
+  Property extends PropertyKey,
+>(
+  objectToCheck: ObjectToCheck,
+  name: Property,
+): objectToCheck is ObjectToCheck & Record<Property, unknown> =>
+  Object.hasOwnProperty.call(objectToCheck, name);
 
 export type PlainObject = Record<number | string | symbol, unknown>;