Add typed return for Object.defineProperties

Search Terms

Object.defineProperties typed

Suggestion

const newObject = Object.defineProperties(o, map);

Use Cases

Creating extensions of certain properties while still being able to type-check them

Examples

/** @type {NodeList} */
const nodeListObject = Object.defineProperties(/** @type {Node[]} */ ([]), {
    item: {
      enumerable: false,
      /** @param {number} [index] */
      value: function item(index) { return this[index]; },
    },
  });

Checklist

My suggestion meets these guidelines:

• This wouldn’t be a breaking change in existing TypeScript/JavaScript code
• This wouldn’t change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn’t a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript’s Design Goals.

The current type I’m using is the following:

interface ObjectConstructor {
  defineProperties<T1, T2 = PropertyDescriptorMap>(o: T1, properties: T2 & ThisType<T1>): T1 & {
        [K in keyof T2]: (
          T2[K]['get'] extends Function ? ReturnType<T2[K]['get']> :
          T2[K]['set'] extends Function ? Parameters<T2[K]['set']>[0] :
          T2[K]['value'] extends undefined ? any : T2[K]['value']
        )
      };
}

It seems alright but I would love to get some feedback. Currently, I’m targeting against .get() first, then .set(arg0) and finally .value.

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

[ExE-Boss]

Yours won’t correctly handle non‑writable properties, whereas mine is much more correct:

interface ObjectConstructor {
	defineProperty<
		T,
		P extends PropertyKey,
		V = P extends keyof T ? T[P] : unknown,
		W = P extends keyof T ? true : false
	>(
		target: T,
		property: P,
		descriptor: TypedPropertyDescriptor<V> & { readonly writable?: W },
	): (T &
		{ readonly [K in P as W extends false ? K : never]: V } &
		{ -readonly [K in P as W extends true ? K : never]: V })
		// Needs https://github.com/microsoft/TypeScript/issues/40562:
		// & (asserts target is T &
		//	{ readonly [K in P as W extends false ? K : never]: V } &
		//	{ -readonly [K in P as W extends true ? K : never]: V });

	defineProperties<
		T,
		M extends Record<string | symbol, PropertyDescriptor>
	>(
		target: T,
		properties: M & ThisType<T>,
	): ({} extends M ? T : T & {
			readonly [K in keyof M as M[K] extends { readonly writable: false } ? K : (K extends keyof T ? never : K)]:
				M[K] extends Readonly<TypedPropertyDescriptor<infer V>> ? V : any;
		} & {
			-readonly [K in keyof M as M[K] extends { readonly writable: true } ? K : (K extends keyof T ? K : never)]:
				M[K] extends Readonly<TypedPropertyDescriptor<infer V>> ? V : any;
		})
		// Needs https://github.com/microsoft/TypeScript/issues/40562:
		// & (asserts target is ({} extends M ? T : T & {
		//	readonly [K in keyof M as M[K] extends { readonly writable: false } ? K : (K extends keyof T ? never : K)]:
		//		M[K] extends Readonly<TypedPropertyDescriptor<infer V>> ? V : any;
		// } & {
		//	-readonly [K in keyof M as M[K] extends { readonly writable: true } ? K : (K extends keyof T ? K : never)]:
		//		M[K] extends Readonly<TypedPropertyDescriptor<infer V>> ? V : any;
		// }))
}

[edemaine]

@ExE-Boss Your definition seems far more useful. Perhaps it would make sense to turn into a PR? Is #40562 essential?

Adding proper definitions of Object.defineProperties would be one way to approach getters/setters in CoffeeScript, which doesn’t currently have built-in support so recommends using defineProperty. Lack of TypeScript support came up in this discussion.