Improve Object.hasOwn

[lishaduck]

⚙ Compilation target

esnext

⚙ Library

esnext

Missing / Incorrect Definition

Object.hasOwn:

Requested: hasOwn(o: object, v: PropertyKey): boolean; → hasOwn<T extends object = object>(o: T, v: PropertyKey): v is keyof T>;

To my understanding, a type predicate only asserts one way, so this should be sound even if there are excess properties.
As far as I can tell, this shouldn't be breaking.

Right now, I have a helper function that asserts this, but copying it into every project gets annoying and repetitive.

Sample Code

const a = {
  foo: 1
} as const;
const b: string = 'foo';
if (Object.hasOwn(a, b)) {
  console.log(a[b]);
}

Documentation Link

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn

[whzx5byb]

I don't think it's a good idea.

function Object_hasOwn<T extends object = object>(o: T, v: PropertyKey): v is keyof T {
    return Object.hasOwn(o, v);
}

declare const x: { a: 1 } | { b: 2 }
const prop: string = 'a';

if (Object_hasOwn(x, prop)) {
    prop
  // ^? prop: never... what?
}

[lishaduck]

Hmmm.
I can reproduce that, and I don't know why it does that.
Well, it seems this won't work after all.

I don't think it's a good idea.

function Object_hasOwn<T extends object = object>(o: T, v: PropertyKey): v is keyof T {
    return Object.hasOwn(o, v);
}

declare const x: { a: 1 } | { b: 2 }
const prop: string = 'a';

if (Object_hasOwn(x, prop)) {
    prop
  // ^? prop: never... what?
}

If you use a const instead of a declare const, it works. Strange.

function Object_hasOwn<T extends object = object>(
  o: T,
  v: PropertyKey
): v is keyof T {
  return Object.hasOwn(o, v);
}

const x: {a: 1} | {b: 2} = {a: 1};
const prop: string = 'a';

if (Object_hasOwn(x, prop)) {
  prop;
  // ^? prop: "a"
}

[MartinJohns]

Duplicate of #44253.

[fatcerberus]

To my understanding, a type predicate only asserts one way

For future reference, this is not true. x is T means that if the predicate is true, x is indeed a T, but also if it's false, x is not a T, and the compiler will narrow accordingly. Refer to #15048.

Even with one-way type predicates, this wouldn't be sound for excess properties: Object.hasOwn(foo, 'd') where keyof typeof foo is 'a' | 'b' | 'c' would return true, but 'd' is very much not a member of 'a' | 'b' | 'c'.