timers: enable timers to be used as primitives

doc/api/timers.md

@@ -90,6 +90,12 @@ of the Node.js application.
 
 Returns a reference to the `Timeout`.
 
+### timeout[Symbol.toPrimitive]()
+
+When coercing a `Timeout` to a primitive, a primitive will be generated that can be used with the appropriate function that can be used to clear the `Timeout`. This allows enhanced compatibility with browser `setTimeout`, and `setInterval` implementations.
+
+Returns a `number`.
+
 ## Scheduling Timers
 
 A timer in Node.js is an internal construct that calls a given function after

lib/timers.js

@@ -145,6 +145,8 @@ const kRefed = Symbol('refed');
 const refedLists = Object.create(null);
 const unrefedLists = Object.create(null);
 
+const KNOWN_TIMERS = Object.create(null);
+
 
 // Schedule or re-schedule a timer.
 // The item must have been enroll()'d first.
@@ -453,6 +455,12 @@ function rearm(timer, start = TimerWrap.now()) {
 
 
 const clearTimeout = exports.clearTimeout = function(timer) {
+  if (typeof timer === 'number' || typeof timer === 'string') {
+    if (timer in KNOWN_TIMERS) {
+      clearTimeout(KNOWN_TIMERS[timer]);
+    }
+    return;
+  }
   if (timer && timer._onTimeout) {
     timer._onTimeout = null;
     if (timer instanceof Timeout) {
@@ -496,7 +504,13 @@ exports.setInterval = function(callback, repeat, arg1, arg2, arg3) {
   return timeout;
 };
 
-exports.clearInterval = function(timer) {
+const clearInterval = exports.clearInterval = function(timer) {
+  if (typeof timer === 'number' || typeof timer === 'string') {
+    if (timer in KNOWN_TIMERS) {
+      clearInterval(KNOWN_TIMERS[timer]);
+    }
+    return;
+  }
   if (timer && timer._repeat) {
     timer._repeat = null;
     clearTimeout(timer);
@@ -521,6 +535,11 @@ function unrefdHandle(timer, now) {
   return true;
 }
 
+Timeout.prototype[Symbol.toPrimitive] = function() {
+  const id = this[async_id_symbol];
+  KNOWN_TIMERS[id] = this;
+  return id;
+};
 
 Timeout.prototype.unref = function() {
   if (this._handle) {
@@ -558,6 +577,9 @@ Timeout.prototype.ref = function() {
 
 Timeout.prototype.close = function() {
   this._onTimeout = null;
+  if (typeof this[async_id_symbol] === 'number') {
+    delete KNOWN_TIMERS[this[async_id_symbol]];
+  }
   if (this._handle) {
     if (destroyHooksExist() &&
         typeof this[async_id_symbol] === 'number' &&

test/parallel/test-timers-toPrimitive.js

@@ -0,0 +1,23 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const timeout1 = setTimeout(common.mustNotCall(), 0);
+const timeout2 = setInterval(common.mustNotCall(), 0);
+
+assert.strictEqual(Number.isNaN(+timeout1), false);
+assert.strictEqual(Number.isNaN(+timeout2), false);
+
+assert.notStrictEqual(`${timeout1}`, Object.prototype.toString.call(timeout1));
+assert.notStrictEqual(`${timeout2}`, Object.prototype.toString.call(timeout2));
+
+assert.notStrictEqual(+timeout1, +timeout2);
+
+const o = {};
+o[timeout1] = timeout1;
+o[timeout2] = timeout2;
+const keys = Object.keys(o);
+assert.deepStrictEqual(keys, [`${timeout1}`, `${timeout2}`]);
+
+clearTimeout(keys[0]);
+clearInterval(keys[1]);