[helpers TS conversion] object (#16505)

* Migrate `objectWithoutProperties`

* Migrate `extends`

* Migrate `defaults`

* Migrate `objectSpread`

* Fix: `objectSpread2` ownKeys behavior

* Fix: make `extends` smaller

* Fix: `defaults` reduce changes

* Apply code review suggestions from @nicolo-ribaudo and @liuxingbaoyu

* Updates to `objectSpread2`

* Updates to `extends.ts`

* Update `objectSpread`

* Regenerate helpers

* Regenerate runtime

---------

Co-authored-by: Nicolò Ribaudo <hello@nicr.dev>

packages/babel-helpers/src/helpers-generated.ts

@@ -204,7 +204,7 @@ const helpers: Record<string, Helper> = {
   // size: 252, gzip size: 188
   extends: helper(
     "7.0.0-beta.0",
-    "export default function _extends(){return _extends=Object.assign?Object.assign.bind():function(n){for(var e=1;e<arguments.length;e++){var t=arguments[e];for(var r in t)({}).hasOwnProperty.call(t,r)&&(n[r]=t[r])}return n},_extends.apply(this,arguments)}",
+    "export default function _extends(){return _extends=Object.assign?Object.assign.bind():function(n){for(var e=1;e<arguments.length;e++){var t=arguments[e];for(var r in t)({}).hasOwnProperty.call(t,r)&&(n[r]=t[r])}return n},_extends.apply(null,arguments)}",
   ),
   // size: 319, gzip size: 225
   get: helper(

packages/babel-helpers/src/helpers/defaults.ts

@@ -0,0 +1,22 @@
+/* @minVersion 7.0.0-beta.0 */
+
+export default function _defaults<T extends object, S extends object>(
+  obj: T,
+  defaults: S,
+): NonNullable<T & S> {
+  for (
+    var keys: string[] = Object.getOwnPropertyNames(defaults), i = 0;
+    i < keys.length;
+    i++
+  ) {
+    var key: string = keys[i],
+      value: PropertyDescriptor | undefined = Object.getOwnPropertyDescriptor(
+        defaults,
+        key,
+      );
+    if (value && value.configurable && obj[key as keyof T] === undefined) {
+      Object.defineProperty(obj, key, value);
+    }
+  }
+  return obj as NonNullable<T & S>;
+}

packages/babel-helpers/src/helpers/extends.ts

@@ -0,0 +1,33 @@
+/* @minVersion 7.0.0-beta.0 */
+
+type Intersection<R extends any[]> = R extends [infer H, ...infer S]
+  ? H & Intersection<S>
+  : unknown;
+
+export default function _extends<T extends object, U extends unknown[]>(
+  target: T,
+  ...sources: U
+): T & Intersection<U>;
+export default function _extends() {
+  // @ts-expect-error explicitly assign to function
+  _extends = Object.assign
+    ? // need a bind because https://github.com/babel/babel/issues/14527
+      // @ts-expect-error -- intentionally omitting the argument
+      Object.assign.bind(/* undefined */)
+    : function (target: any) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+
+  return _extends.apply(
+    null,
+    arguments as any as [source: object, ...target: any[]],
+  );
+}

packages/babel-helpers/src/helpers/objectDestructuringEmpty.ts

@@ -0,0 +1,7 @@
+/* @minVersion 7.0.0-beta.0 */
+
+export default function _objectDestructuringEmpty<T>(
+  obj: T | null | undefined,
+): asserts obj is T {
+  if (obj == null) throw new TypeError("Cannot destructure " + obj);
+}

packages/babel-helpers/src/helpers/objectSpread.ts

@@ -0,0 +1,33 @@
+/* @minVersion 7.0.0-beta.0 */
+/* @onlyBabel7 */
+
+// @ts-expect-error Migrate in another PR
+import defineProperty from "./defineProperty.ts";
+
+type Intersection<R extends any[]> = R extends [infer H, ...infer S]
+  ? H & Intersection<S>
+  : unknown;
+
+export default function _objectSpread<T extends object, U extends unknown[]>(
+  target: T,
+  ...sources: U
+): T & Intersection<U>;
+export default function _objectSpread(target: object) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source: object = arguments[i] != null ? Object(arguments[i]) : {};
+    var ownKeys: PropertyKey[] = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys.push.apply(
+        ownKeys,
+        Object.getOwnPropertySymbols(source).filter(function (sym) {
+          // sym already comes from `Object.getOwnPropertySymbols`, so getOwnPropertyDescriptor should always be defined
+          return Object.getOwnPropertyDescriptor(source, sym)!.enumerable;
+        }),
+      );
+    }
+    ownKeys.forEach(function (key) {
+      defineProperty(target, key, source[key as keyof typeof source]);
+    });
+  }
+  return target;
+}

packages/babel-helpers/src/helpers/objectSpread2.js → packages/babel-helpers/src/helpers/objectSpread2.ts

@@ -1,26 +1,39 @@
 /* @minVersion 7.5.0 */
 
-import defineProperty from "defineProperty";
+// @ts-expect-error Migrate in another PR
+import defineProperty from "./defineProperty.ts";
 
 // This function is different to "Reflect.ownKeys". The enumerableOnly
 // filters on symbol properties only. Returned string properties are always
 // enumerable. It is good to use in objectSpread.
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
+function ownKeys(
+  object: object,
+  enumerableOnly?: boolean | undefined,
+): (string | symbol)[] {
+  var keys: (string | symbol)[] = Object.keys(object);
   if (Object.getOwnPropertySymbols) {
     var symbols = Object.getOwnPropertySymbols(object);
     if (enumerableOnly) {
       symbols = symbols.filter(function (sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        // sym already comes from `Object.getOwnPropertySymbols`, so getOwnPropertyDescriptor should always be defined
+        return Object.getOwnPropertyDescriptor(object, sym)!.enumerable;
       });
     }
     keys.push.apply(keys, symbols);
   }
   return keys;
 }
 
-export default function _objectSpread2(target) {
+type Intersection<R extends any[]> = R extends [infer H, ...infer S]
+  ? H & Intersection<S>
+  : unknown;
+
+export default function _objectSpread2<T extends object, U extends unknown[]>(
+  target: T,
+  ...sources: U
+): T & Intersection<U>;
+export default function _objectSpread2(target: object) {
   for (var i = 1; i < arguments.length; i++) {
     var source = arguments[i] != null ? arguments[i] : {};
     if (i % 2) {
@@ -34,7 +47,8 @@ export default function _objectSpread2(target) {
         Object.defineProperty(
           target,
           key,
-          Object.getOwnPropertyDescriptor(source, key),
+          // key already comes from ownKeys, so getOwnPropertyDescriptor should always be defined
+          Object.getOwnPropertyDescriptor(source, key)!,
         );
       });
     }

packages/babel-helpers/src/helpers/objectWithoutProperties.ts

@@ -0,0 +1,39 @@
+/* @minVersion 7.0.0-beta.0 */
+
+import objectWithoutPropertiesLoose from "./objectWithoutPropertiesLoose.ts";
+
+export default function _objectWithoutProperties(
+  source: null | undefined,
+  excluded: PropertyKey[],
+): Record<string, never>;
+export default function _objectWithoutProperties<
+  T extends object,
+  K extends PropertyKey[],
+>(
+  source: T | null | undefined,
+  excluded: K,
+): Pick<T, Exclude<keyof T, K[number]>>;
+export default function _objectWithoutProperties<
+  T extends object,
+  K extends PropertyKey[],
+>(
+  source: T | null | undefined,
+  excluded: K,
+): Pick<T, Exclude<keyof T, K[number]>> | Record<string, never> {
+  if (source == null) return {};
+
+  var target = objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i] as keyof typeof source & keyof typeof target;
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}

packages/babel-helpers/src/helpers/objectWithoutPropertiesLoose.ts

@@ -0,0 +1,30 @@
+/* @minVersion 7.0.0-beta.0 */
+
+export default function _objectWithoutPropertiesLoose<
+  T extends object,
+  K extends PropertyKey[],
+>(
+  source: T | null | undefined,
+  excluded: K,
+): Pick<T, Exclude<keyof T, K[number]>>;
+export default function _objectWithoutPropertiesLoose<
+  T extends object,
+  K extends Array<keyof T>,
+>(source: T | null | undefined, excluded: K): Omit<T, K[number]>;
+export default function _objectWithoutPropertiesLoose<T extends object>(
+  source: T | null | undefined,
+  excluded: PropertyKey[],
+): Partial<T> {
+  if (source == null) return {};
+
+  var target: Partial<T> = {};
+
+  for (var key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}

packages/babel-runtime-corejs3/helpers/esm/extends.js

@@ -8,5 +8,5 @@ export default function _extends() {
       for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
     }
     return n;
-  }, _extends.apply(this, arguments);
+  }, _extends.apply(null, arguments);
 }