fix the return type of typedHasProperty yet again

package.json

@@ -1,6 +1,6 @@
 {
     "name": "augment-vir",
-    "version": "3.0.1",
+    "version": "3.0.2",
     "homepage": "https://github.com/electrovir/augment-vir",
     "bugs": {
         "url": "https://github.com/electrovir/augment-vir/issues"

src/augments/object.test.ts

@@ -258,14 +258,17 @@ describe(typedHasProperty.name, () => {
         const idkWhatThisIs: unknown = (() => {}) as unknown;
         if (typedHasProperty(idkWhatThisIs, 'name')) {
             idkWhatThisIs.name;
+            if (typedHasProperty(idkWhatThisIs, 'derp')) {
+                idkWhatThisIs.derp;
+            }
         } else {
             // @ts-expect-error
             idkWhatThisIs.name;
         }
     });
 
     it('should preserve property value type when it exists', () => {
-        const whatever = {} as {name: string} | string;
+        const whatever = {} as {name: string} | string | {derp: string};
 
         // should not be able to access the property directly
         // @ts-expect-error
@@ -300,6 +303,38 @@ describe(typedHasProperty.name, () => {
             }
         }
     });
+
+    it('should allow type narrowing', () => {
+        function assertOutputProperty(
+            keyPath: string,
+            testExpectations: object,
+            outputKey: string,
+        ): void {
+            if (!typedHasProperty(testExpectations, outputKey)) {
+                throw new Error(`${keyPath} > ${outputKey} is missing.`);
+            }
+
+            const value = testExpectations[outputKey];
+
+            if (typeof value !== 'string' && !isObject(value)) {
+                throw new Error(`${keyPath} > "${outputKey}" is invalid. Got "${value}"`);
+            } else if (isObject(value)) {
+                if (!typedHasProperty(value, 'type') || value.type !== 'regexp') {
+                    throw new Error(
+                        `${keyPath} > "${outputKey}".type is invalid. Expected "regexp".`,
+                    );
+                }
+
+                value;
+
+                if (!typedHasProperty(value, 'value') || typeof value.value !== 'string') {
+                    throw new Error(
+                        `${keyPath} > "${outputKey}".value is invalid. Expected a string.`,
+                    );
+                }
+            }
+        }
+    });
 });
 
 describe(typedHasProperties.name, () => {

src/augments/object.ts

@@ -72,17 +72,17 @@ export function getObjectTypedValues<ObjectGeneric extends unknown>(
     ) as ObjectGeneric[keyof ObjectGeneric][];
 }
 
-type CombineTypeWithKey<
+type CombinedParentValue<
     KeyGeneric extends PropertyKey,
     ParentGeneric,
-> = ParentGeneric extends Partial<Record<KeyGeneric, unknown>>
-    ? ParentGeneric & RequiredBy<ParentGeneric, KeyGeneric>
-    : ParentGeneric extends
-          | Record<KeyGeneric, infer ValueGeneric>
-          | Partial<Record<KeyGeneric, infer ValueGeneric>>
-          | {}
-    ? Extract<ParentGeneric, RequiredBy<Record<KeyGeneric, ValueGeneric>, KeyGeneric>>
-    : ParentGeneric & Record<KeyGeneric, unknown>;
+> = KeyGeneric extends keyof ParentGeneric
+    ? RequiredBy<ParentGeneric, KeyGeneric>[KeyGeneric]
+    : KeyGeneric extends keyof Extract<ParentGeneric, Record<KeyGeneric, any>>
+    ? RequiredBy<Extract<ParentGeneric, Record<KeyGeneric, any>>, KeyGeneric>[KeyGeneric]
+    : unknown;
+
+type CombineTypeWithKey<KeyGeneric extends PropertyKey, ParentGeneric> = ParentGeneric &
+    RequiredBy<Record<KeyGeneric, CombinedParentValue<KeyGeneric, ParentGeneric>>, KeyGeneric>;
 
 export function typedHasProperty<KeyGeneric extends PropertyKey, ParentGeneric>(
     inputObject: ParentGeneric,

src/augments/type-test.test.ts

@@ -0,0 +1,12 @@
+import {describe, it} from 'mocha';
+import {DoesExtend, ExpectFalse, ExpectTrue} from './type-test';
+
+describe('DoesExtend', () => {
+    it('should work on types', () => {
+        type one = ExpectTrue<DoesExtend<unknown, Record<PropertyKey, any>>>;
+        type two = ExpectFalse<DoesExtend<Record<PropertyKey, any>, unknown>>;
+        // type three = ExpectFalse<DoesExtend<Record<'name', any>, {name: string} | string>>;
+        type four = ExpectTrue<DoesExtend<{name: string} | string, Record<'name', any>>>;
+        type five = ExpectTrue<DoesExtend<{name: string} | string, Record<'name', any>>>;
+    });
+});