RequestIdleCallback Polyfill

CHANGELOG.md

@@ -1,5 +1,6 @@
 # Changelog
 ### Unreleased
+- Added polyfill for `requestIdleCallback`
 - Improved the way of inner iterators cleaning in iterator helpers
 - Slight performance improvement for engines with native `Array#fill` on `ArrayBuffer` constructor and `%TypedArray%#fill`
 - Compat data improvements:

docs/web/docs/features/web-standards/idle-callback.md

@@ -0,0 +1,42 @@
+# Idle Callback
+[Specification](https://w3c.github.io/requestidlecallback/)\
+[MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/requestIdleCallback)
+
+Note that `requestIdleCallback` cannot really be polyfilled as we don't know when an idle period happens.  However, the polyfill contained in core-js uses `requestAnimationFrame` to ensure that operations contained in `requestIdleCallback` will not significantly throttle the rendering of graphics.
+
+## Modules 
+[`web.request-idle-callback`](https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/web.request-idle-callback.js)
+
+## Built-ins signatures
+```ts
+function requestIdleCallback(
+  callback: (deadline: IdleDeadline) => void,
+  options?: { timeout: number }
+): number;
+function cancelIdleCallback(handle: number): void;
+interface IdleDeadline {
+  timeRemaining(): number;
+  readonly didTimeout: boolean;
+}
+```
+
+## [Entry points]({docs-version}/docs/usage#h-entry-points)
+```plaintext
+core-js(-pure)/stable|actual|full|web/request-idle-callback
+core-js(-pure)/stable|actual|full|web/cancel-idle-callback
+core-js(-pure)/stable|actual|full|web/idle-deadline
+```
+
+- Some browsers (like Safari's Technical Preview) has only some components `requestIdleCallback`, `cancelIdleCallback`, and `IdleDeadline` exposed.  In this case, importing any of those functions will use polyfilled versions.
+- Polyfilled versions are not compatible with browser native versions in terms of request / cancel.  Therefore it is strongly recommended to import all of the above-mentioned entry points together.
+- Multiple polyfilled instances also do not have handles compatible with each other.
+
+## Examples
+```js
+requestIdleCallback(
+  deadline => {
+    console.log('Did timeout:', deadline.didTimeout, '| Time remaining (ms):', deadline.timeRemaining());
+  },
+  { timeout: 2000 } // forces callback with timeout after 2 seconds max
+);
+```

docs/web/docs/menu.json

@@ -413,6 +413,10 @@
           {
             "title": "Iterable DOM collections",
             "url": "{docs-version}/docs/features/web-standards/iterable-dom-collections"
+          },
+          {
+            "title": "Idle Callback",
+            "url": "{docs-version}/docs/features/web-standards/idle-callback"
           }
         ]
       },

packages/core-js-compat/src/data.mjs

@@ -3210,6 +3210,10 @@ export const data = {
     node: '19.8',
     safari: '17.0',
   },
+  'web.request-idle-callback': {
+    chrome: '47',
+    // firefox: '55', -- incorrect type for timeout
+  },
 };
 
 export const renamed = new Map([

packages/core-js-compat/src/modules-by-versions.mjs

@@ -323,4 +323,7 @@ export default {
     'es.weak-map.get-or-insert',
     'es.weak-map.get-or-insert-computed',
   ],
+  '3.50': [
+    'web.request-idle-callback',
+  ],
 };

packages/core-js/actual/cancel-idle-callback.js

@@ -0,0 +1,4 @@
+'use strict';
+var parent = require('../stable/cancel-idle-callback');
+
+module.exports = parent;

packages/core-js/actual/idle-deadline.js

@@ -0,0 +1,4 @@
+'use strict';
+var parent = require('../stable/idle-deadline');
+
+module.exports = parent;

packages/core-js/actual/request-idle-callback.js

@@ -0,0 +1,4 @@
+'use strict';
+var parent = require('../stable/request-idle-callback');
+
+module.exports = parent;

packages/core-js/full/cancel-idle-callback.js

@@ -0,0 +1,4 @@
+'use strict';
+var parent = require('../actual/cancel-idle-callback');
+
+module.exports = parent;

packages/core-js/full/idle-deadline.js

@@ -0,0 +1,4 @@
+'use strict';
+var parent = require('../actual/idle-deadline');
+
+module.exports = parent;

packages/core-js/full/request-idle-callback.js

@@ -0,0 +1,4 @@
+'use strict';
+var parent = require('../actual/request-idle-callback');
+
+module.exports = parent;

packages/core-js/internals/idle-callback-detection.js

@@ -0,0 +1,6 @@
+'use strict';
+var globalThis = require('../internals/global-this');
+var Firefox = require('../internals/environment-ff-version');
+
+exports.BASIC = globalThis.requestIdleCallback && globalThis.cancelIdleCallback && globalThis.IdleDeadline;
+exports.BOUNDS = !Firefox;

packages/core-js/internals/queue.js

@@ -6,19 +6,57 @@ var Queue = function () {
 
 Queue.prototype = {
   add: function (item) {
-    var entry = { item: item, next: null };
+    var entry = { item: item, next: null, prev: this.tail, queue: this };
     var tail = this.tail;
     if (tail) tail.next = entry;
     else this.head = entry;
     this.tail = entry;
+    return entry;
+  },
+  addEntry: function (entry) {
+    var queue = entry.queue;
+    if (queue) queue.erase(entry);
+
+    entry.prev = this.tail;
+    entry.next = null;
+    entry.queue = this;
+
+    var tail = this.tail;
+    if (tail) tail.next = entry;
+    else this.head = entry;
+    this.tail = entry;
+    return entry;
   },
   get: function () {
+    var entry = this.getEntry();
+    if (entry) return entry.item;
+  },
+  getEntry: function () {
     var entry = this.head;
     if (entry) {
       var next = this.head = entry.next;
       if (next === null) this.tail = null;
-      return entry.item;
+      else next.prev = null;
+      entry.prev = null;
+      entry.next = null;
+      entry.queue = null;
+      return entry;
     }
+  },
+  erase: function (entry) {
+    if (entry.queue !== this) return;
+    var prev = entry.prev;
+    var next = entry.next;
+    if (prev) prev.next = next;
+    else this.head = next;
+    if (next) next.prev = prev;
+    else this.tail = prev;
+    entry.prev = null;
+    entry.next = null;
+    entry.queue = null;
+  },
+  empty: function () {
+    return !this.head;
   }
 };
 

packages/core-js/internals/to-number.js

@@ -0,0 +1,51 @@
+'use strict';
+var globalThis = require('./global-this');
+var uncurryThis = require('./function-uncurry-this');
+var isSymbol = require('./is-symbol');
+var toPrimitive = require('./to-primitive');
+var trim = require('./string-trim').trim;
+
+var TypeError = globalThis.TypeError;
+var stringSlice = uncurryThis(''.slice);
+var charCodeAt = uncurryThis(''.charCodeAt);
+
+// `ToNumber` abstract operation
+// https://tc39.es/ecma262/#sec-tonumber
+module.exports = function (argument) {
+  var it = toPrimitive(argument, 'number');
+  var first, third, radix, maxCode, digits, length, index, code;
+  if (isSymbol(it)) throw new TypeError('Cannot convert a Symbol value to a number');
+  if (typeof it == 'string' && it.length > 2) {
+    it = trim(it);
+    first = charCodeAt(it, 0);
+    if (first === 43 || first === 45) {
+      third = charCodeAt(it, 2);
+      if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
+    } else if (first === 48) {
+      switch (charCodeAt(it, 1)) {
+        // fast equal of /^0b[01]+$/i
+        case 66:
+        case 98:
+          radix = 2;
+          maxCode = 49;
+          break;
+        // fast equal of /^0o[0-7]+$/i
+        case 79:
+        case 111:
+          radix = 8;
+          maxCode = 55;
+          break;
+        default:
+          return +it;
+      }
+      digits = stringSlice(it, 2);
+      length = digits.length;
+      for (index = 0; index < length; index++) {
+        code = charCodeAt(digits, index);
+        // parseInt parses a string to a first unavailable symbol
+        // but ToNumber should return NaN if a string contains unavailable symbols
+        if (code < 48 || code > maxCode) return NaN;
+      } return parseInt(digits, radix);
+    }
+  } return +it;
+};

packages/core-js/internals/to-unsigned-long.js

@@ -0,0 +1,20 @@
+'use strict';
+var toNumber = require('./to-number');
+
+var $isNaN = isNaN;
+var abs = Math.abs;
+var floor = Math.floor;
+var MOD = 0x100000000;
+
+// WebIDL Unsigned Long
+module.exports = function toUnsignedLong(value) {
+  value = toNumber(value);
+  // Normalize -0
+  if (value === 0) value = 0;
+  if ($isNaN(value) || value === Infinity || value === -Infinity) return 0;
+  var r = floor(abs(value));
+  if (value < 0) r = -r;
+  value = r;
+  value = ((value % MOD) + MOD) % MOD;
+  return value;
+};

packages/core-js/modules/es.number.constructor.js

@@ -4,27 +4,22 @@ var IS_PURE = require('../internals/is-pure');
 var DESCRIPTORS = require('../internals/descriptors');
 var globalThis = require('../internals/global-this');
 var path = require('../internals/path');
-var uncurryThis = require('../internals/function-uncurry-this');
 var isForced = require('../internals/is-forced');
 var hasOwn = require('../internals/has-own-property');
 var inheritIfRequired = require('../internals/inherit-if-required');
 var isPrototypeOf = require('../internals/object-is-prototype-of');
-var isSymbol = require('../internals/is-symbol');
 var toPrimitive = require('../internals/to-primitive');
 var fails = require('../internals/fails');
 var getOwnPropertyNames = require('../internals/object-get-own-property-names').f;
 var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
 var defineProperty = require('../internals/object-define-property').f;
 var thisNumberValue = require('../internals/this-number-value');
-var trim = require('../internals/string-trim').trim;
+var toNumber = require('../internals/to-number');
 
 var NUMBER = 'Number';
 var NativeNumber = globalThis[NUMBER];
 var PureNumberNamespace = path[NUMBER];
 var NumberPrototype = NativeNumber.prototype;
-var TypeError = globalThis.TypeError;
-var stringSlice = uncurryThis(''.slice);
-var charCodeAt = uncurryThis(''.charCodeAt);
 
 // `ToNumeric` abstract operation
 // https://tc39.es/ecma262/#sec-tonumeric
@@ -33,47 +28,6 @@ var toNumeric = function (value) {
   return typeof primValue == 'bigint' ? primValue : toNumber(primValue);
 };
 
-// `ToNumber` abstract operation
-// https://tc39.es/ecma262/#sec-tonumber
-var toNumber = function (argument) {
-  var it = toPrimitive(argument, 'number');
-  var first, third, radix, maxCode, digits, length, index, code;
-  if (isSymbol(it)) throw new TypeError('Cannot convert a Symbol value to a number');
-  if (typeof it == 'string' && it.length > 2) {
-    it = trim(it);
-    first = charCodeAt(it, 0);
-    if (first === 43 || first === 45) {
-      third = charCodeAt(it, 2);
-      if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
-    } else if (first === 48) {
-      switch (charCodeAt(it, 1)) {
-        // fast equal of /^0b[01]+$/i
-        case 66:
-        case 98:
-          radix = 2;
-          maxCode = 49;
-          break;
-        // fast equal of /^0o[0-7]+$/i
-        case 79:
-        case 111:
-          radix = 8;
-          maxCode = 55;
-          break;
-        default:
-          return +it;
-      }
-      digits = stringSlice(it, 2);
-      length = digits.length;
-      for (index = 0; index < length; index++) {
-        code = charCodeAt(digits, index);
-        // parseInt parses a string to a first unavailable symbol
-        // but ToNumber should return NaN if a string contains unavailable symbols
-        if (code < 48 || code > maxCode) return NaN;
-      } return parseInt(digits, radix);
-    }
-  } return +it;
-};
-
 var FORCED = isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'));
 
 var calledWithNew = function (dummy) {