electron/lib/common/timers-shim.ts

// Drop-in replacement for timers-browserify@1.4.2.
// Provides the Node.js 'timers' API surface for renderer/web bundles
// without relying on window.postMessage (which the newer timers-browserify 2.x
// polyfill uses and can interfere with Electron IPC).

const immediateIds: Record<number, boolean> = {};
let nextImmediateId = 0;

// --- DOM timer wrappers ------------------------------------------------
// Wrap the global setTimeout/setInterval so we return Timeout objects that
// expose ref/unref/close matching the Node.js API shape.

class Timeout {
  _id: ReturnType<typeof globalThis.setTimeout>;
  _clearFn: (id: ReturnType<typeof globalThis.setTimeout>) => void;

  constructor (id: ReturnType<typeof globalThis.setTimeout>, clearFn: (id: ReturnType<typeof globalThis.setTimeout>) => void) {
    this._id = id;
    this._clearFn = clearFn;
  }

  unref () {}
  ref () {}

  close () {
    this._clearFn.call(globalThis, this._id);
  }
}

export const setTimeout = function (...args: Parameters<typeof globalThis.setTimeout>): Timeout {
  return new Timeout(globalThis.setTimeout(...args), globalThis.clearTimeout);
};

export const setInterval = function (...args: Parameters<typeof globalThis.setInterval>): Timeout {
  return new Timeout(globalThis.setInterval(...args), globalThis.clearInterval);
};

export const clearTimeout = function (timeout: Timeout | undefined) {
  if (timeout) timeout.close();
};

export const clearInterval = clearTimeout;

// --- Legacy enroll/unenroll (Node < 11 API, preserved for compatibility) ------

interface EnrollableItem {
  _idleTimeoutId?: ReturnType<typeof setTimeout>;
  _idleTimeout?: number;
  _onTimeout?: () => void;
}

export const enroll = function (item: EnrollableItem, msecs: number) {
  clearTimeout(item._idleTimeoutId);
  item._idleTimeout = msecs;
};

export const unenroll = function (item: EnrollableItem) {
  clearTimeout(item._idleTimeoutId);
  item._idleTimeout = -1;
};

export const active = function (item: EnrollableItem) {
  clearTimeout(item._idleTimeoutId);

  const msecs = item._idleTimeout;
  if (msecs !== undefined && msecs >= 0) {
    item._idleTimeoutId = setTimeout(function onTimeout () {
      if (item._onTimeout) item._onTimeout();
    }, msecs);
  }
};

export const _unrefActive = active;

// --- setImmediate / clearImmediate -------------------------------------
// Prefer the native implementations when available. Fall back to a
// nextTick-based shim that avoids window.postMessage.

const clearImmediateFallback = function (id: number) {
  delete immediateIds[id];
};

export const setImmediate = typeof globalThis.setImmediate === 'function'
  ? globalThis.setImmediate
  : function (fn: (...args: unknown[]) => void, ...rest: unknown[]) {
    const id = nextImmediateId++;

    immediateIds[id] = true;

    Promise.resolve().then(function onMicrotask () {
      if (immediateIds[id]) {
        fn(...rest);
        clearImmediateFallback(id);
      }
    });

    return id;
  };

export const clearImmediate = typeof globalThis.clearImmediate === 'function'
  ? globalThis.clearImmediate
  : clearImmediateFallback;