@openobserve/browser-core 0.2.11-rc1 → 0.2.12-beta.1

package/src/tools/monitor.ts

@@ -50,13 +50,17 @@ export function callMonitored<T extends (...args: any[]) => any>(
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return fn.apply(context, args)
   } catch (e) {
-    displayIfDebugEnabled(e)
-    if (onMonitorErrorCollected) {
-      try {
-        onMonitorErrorCollected(e)
-      } catch (e) {
-        displayIfDebugEnabled(e)
-      }
+    monitorError(e)
+  }
+}
+
+export function monitorError(e: unknown) {
+  displayIfDebugEnabled(e)
+  if (onMonitorErrorCollected) {
+    try {
+      onMonitorErrorCollected(e)
+    } catch (e) {
+      displayIfDebugEnabled(e)
     }
   }
 }

package/src/tools/observable.ts

@@ -1,31 +1,42 @@
+import { queueMicrotask } from './queueMicrotask'
+
 export interface Subscription {
   unsubscribe: () => void
 }
 
+type Observer<T> = (data: T) => void
+
+// eslint-disable-next-line no-restricted-syntax
 export class Observable<T> {
-  private observers: Array<(data: T) => void> = []
+  protected observers: Array<Observer<T>> = []
   private onLastUnsubscribe?: () => void
 
   constructor(private onFirstSubscribe?: (observable: Observable<T>) => (() => void) | void) {}
 
-  subscribe(f: (data: T) => void): Subscription {
-    if (!this.observers.length && this.onFirstSubscribe) {
-      this.onLastUnsubscribe = this.onFirstSubscribe(this) || undefined
-    }
-    this.observers.push(f)
+  subscribe(observer: Observer<T>): Subscription {
+    this.addObserver(observer)
     return {
-      unsubscribe: () => {
-        this.observers = this.observers.filter((other) => f !== other)
-        if (!this.observers.length && this.onLastUnsubscribe) {
-          this.onLastUnsubscribe()
-        }
-      },
+      unsubscribe: () => this.removeObserver(observer),
     }
   }
 
   notify(data: T) {
     this.observers.forEach((observer) => observer(data))
   }
+
+  protected addObserver(observer: Observer<T>) {
+    this.observers.push(observer)
+    if (this.observers.length === 1 && this.onFirstSubscribe) {
+      this.onLastUnsubscribe = this.onFirstSubscribe(this) || undefined
+    }
+  }
+
+  protected removeObserver(observer: Observer<T>) {
+    this.observers = this.observers.filter((other) => observer !== other)
+    if (!this.observers.length && this.onLastUnsubscribe) {
+      this.onLastUnsubscribe()
+    }
+  }
 }
 
 export function mergeObservables<T>(...observables: Array<Observable<T>>) {
@@ -36,3 +47,58 @@ export function mergeObservables<T>(...observables: Array<Observable<T>>) {
     return () => subscriptions.forEach((subscription) => subscription.unsubscribe())
   })
 }
+
+// eslint-disable-next-line no-restricted-syntax
+export class BufferedObservable<T> extends Observable<T> {
+  private buffer: T[] = []
+
+  constructor(private maxBufferSize: number) {
+    super()
+  }
+
+  notify(data: T) {
+    this.buffer.push(data)
+    if (this.buffer.length > this.maxBufferSize) {
+      this.buffer.shift()
+    }
+    super.notify(data)
+  }
+
+  subscribe(observer: Observer<T>): Subscription {
+    let closed = false
+
+    const subscription = {
+      unsubscribe: () => {
+        closed = true
+        this.removeObserver(observer)
+      },
+    }
+
+    queueMicrotask(() => {
+      for (const data of this.buffer) {
+        if (closed) {
+          return
+        }
+        observer(data)
+      }
+
+      if (!closed) {
+        this.addObserver(observer)
+      }
+    })
+
+    return subscription
+  }
+
+  /**
+   * Drop buffered data and don't buffer future data. This is to avoid leaking memory when it's not
+   * needed anymore. This can be seen as a performance optimization, and things will work probably
+   * even if this method isn't called, but still useful to clarify our intent and lowering our
+   * memory impact.
+   */
+  unbuffer() {
+    queueMicrotask(() => {
+      this.maxBufferSize = this.buffer.length = 0
+    })
+  }
+}

package/src/tools/queueMicrotask.ts

@@ -0,0 +1,13 @@
+import { monitor } from './monitor'
+import { globalObject } from './globalObject'
+
+export function queueMicrotask(callback: () => void) {
+  const nativeImplementation = globalObject.queueMicrotask?.bind(globalObject)
+
+  if (typeof nativeImplementation === 'function') {
+    nativeImplementation(monitor(callback))
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- the callback is monitored, so it'll never throw
+    Promise.resolve().then(monitor(callback))
+  }
+}

package/src/tools/readBytesFromStream.ts

@@ -1,77 +1,37 @@
-import { monitor } from './monitor'
+import type { Uint8ArrayBuffer } from './utils/byteUtils'
+import { concatBuffers } from './utils/byteUtils'
 import { noop } from './utils/functionUtils'
 
-type Options = {
-  bytesLimit: number
+interface Options {
+  // TODO(next-major): always collect stream body when `trackEarlyRequests` is removed, as we don't
+  // need to use this function to just wait for the end of the stream without collecting it
   collectStreamBody?: boolean
 }
+
 /**
- * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of
- * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit
- * has been exceeded if more bytes were available.
+ * Read bytes from a ReadableStream until the end of the stream.
+ * Returns the bytes if collectStreamBody is true, otherwise returns undefined.
  */
-export function readBytesFromStream(
-  stream: ReadableStream<Uint8Array>,
-  callback: (error?: Error, bytes?: Uint8Array, limitExceeded?: boolean) => void,
-  options: Options
-) {
+export async function readBytesFromStream(stream: ReadableStream<Uint8ArrayBuffer>, options: Options) {
   const reader = stream.getReader()
-  const chunks: Uint8Array[] = []
-  let readBytesCount = 0
-
-  readMore()
-
-  function readMore() {
-    reader.read().then(
-      monitor((result: ReadableStreamReadResult<Uint8Array>) => {
-        if (result.done) {
-          onDone()
-          return
-        }
-
-        if (options.collectStreamBody) {
-          chunks.push(result.value)
-        }
-        readBytesCount += result.value.length
-
-        if (readBytesCount > options.bytesLimit) {
-          onDone()
-        } else {
-          readMore()
-        }
-      }),
-      monitor((error) => callback(error))
-    )
-  }
+  const chunks: Uint8ArrayBuffer[] = []
 
-  function onDone() {
-    reader.cancel().catch(
-      // we don't care if cancel fails, but we still need to catch the error to avoid reporting it
-      // as an unhandled rejection
-      noop
-    )
+  while (true) {
+    const result = await reader.read()
+    if (result.done) {
+      break
+    }
 
-    let bytes: Uint8Array | undefined
-    let limitExceeded: boolean | undefined
     if (options.collectStreamBody) {
-      let completeBuffer: Uint8Array
-      if (chunks.length === 1) {
-        // optimization: if the response is small enough to fit in a single buffer (provided by the browser), just
-        // use it directly.
-        completeBuffer = chunks[0]
-      } else {
-        // else, we need to copy buffers into a larger buffer to concatenate them.
-        completeBuffer = new Uint8Array(readBytesCount)
-        let offset = 0
-        chunks.forEach((chunk) => {
-          completeBuffer.set(chunk, offset)
-          offset += chunk.length
-        })
-      }
-      bytes = completeBuffer.slice(0, options.bytesLimit)
-      limitExceeded = completeBuffer.length > options.bytesLimit
+      chunks.push(result.value)
     }
-
-    callback(undefined, bytes, limitExceeded)
   }
+
+  reader.cancel().catch(
+    // we don't care if cancel fails, but we still need to catch the error to avoid reporting it
+    // as an unhandled rejection
+    noop
+  )
+
+  return options.collectStreamBody ? concatBuffers(chunks) : undefined
 }

package/src/tools/requestIdleCallback.ts

@@ -0,0 +1,40 @@
+import { setTimeout, clearTimeout } from './timer'
+import { monitor } from './monitor'
+import { dateNow } from './utils/timeUtils'
+
+// This type is not yet supported in TS 3.8. Imported from the TS source until we upgrade the
+// minimum supported TS version.
+// https://github.com/microsoft/TypeScript/blob/13c374a868c926f6a907666a5599992c1351b773/src/lib/dom.generated.d.ts#L9513-L9516
+export interface IdleDeadline {
+  readonly didTimeout: boolean
+  timeRemaining(): DOMHighResTimeStamp
+}
+
+/**
+ * 'requestIdleCallback' with a shim.
+ */
+export function requestIdleCallback(callback: (deadline: IdleDeadline) => void, opts?: { timeout?: number }) {
+  // Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.
+  if (window.requestIdleCallback && window.cancelIdleCallback) {
+    const id = window.requestIdleCallback(monitor(callback), opts)
+    return () => window.cancelIdleCallback(id)
+  }
+  return requestIdleCallbackShim(callback)
+}
+
+export const MAX_TASK_TIME = 50
+
+/*
+ * Shim from https://developer.chrome.com/blog/using-requestidlecallback#checking_for_requestidlecallback
+ * Note: there is no simple way to support the "timeout" option, so we ignore it.
+ */
+export function requestIdleCallbackShim(callback: (deadline: IdleDeadline) => void) {
+  const start = dateNow()
+  const timeoutId = setTimeout(() => {
+    callback({
+      didTimeout: false,
+      timeRemaining: () => Math.max(0, MAX_TASK_TIME - (dateNow() - start)),
+    })
+  }, 0)
+  return () => clearTimeout(timeoutId)
+}

package/src/tools/sendToExtension.ts

@@ -1,3 +1,5 @@
+import { globalObject } from './globalObject'
+
 interface BrowserWindow {
   __ooBrowserSdkExtensionCallback?: (message: unknown) => void
 }
@@ -5,7 +7,7 @@ interface BrowserWindow {
 type ExtensionMessageType = 'logs' | 'record' | 'rum' | 'telemetry'
 
 export function sendToExtension(type: ExtensionMessageType, payload: unknown) {
-  const callback = (window as BrowserWindow).__ooBrowserSdkExtensionCallback
+  const callback = (globalObject as BrowserWindow).__ooBrowserSdkExtensionCallback
   if (callback) {
     callback({ type, payload })
   }

package/src/tools/serialisation/context.ts

@@ -4,5 +4,8 @@ export interface Context {
 
 export type ContextValue = string | number | boolean | Context | ContextArray | undefined | null
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
+/**
+ * @hidden
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface ContextArray extends Array<ContextValue> {}

package/src/tools/serialisation/sanitize.ts

@@ -4,18 +4,27 @@ import type { Context, ContextArray, ContextValue } from './context'
 import type { ObjectWithToJsonMethod } from './jsonStringify'
 import { detachToJsonMethod } from './jsonStringify'
 
-// eslint-disable-next-line @typescript-eslint/ban-types
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 type PrimitivesAndFunctions = string | number | boolean | undefined | null | symbol | bigint | Function
 type ExtendedContextValue = PrimitivesAndFunctions | object | ExtendedContext | ExtendedContextArray
-type ExtendedContext = { [key: string]: ExtendedContextValue }
+interface ExtendedContext {
+  [key: string]: ExtendedContextValue
+}
 type ExtendedContextArray = ExtendedContextValue[]
 
-type ContainerElementToProcess = {
+interface ContainerElementToProcess {
   source: ExtendedContextArray | ExtendedContext
   target: ContextArray | Context
   path: string
 }
 
+interface SanitizedEvent extends Context {
+  type: string
+  isTrusted: boolean
+  currentTarget: string | null | undefined
+  target: string | null | undefined
+}
+
 // The maximum size of a single event is 256KiB. By default, we ensure that user-provided data
 // going through sanitize fits inside our events, while leaving room for other contexts, metadata, ...
 const SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE
@@ -38,8 +47,8 @@ const KEY_DECORATION_LENGTH = 3
  * - Size does not take into account indentation that can be applied to JSON.stringify
  * - Non-numerical properties of Arrays are ignored. Same behavior as JSON.stringify
  *
- * @param source              User-provided data meant to be serialized using JSON.stringify
- * @param maxCharacterCount   Maximum number of characters allowed in serialized form
+ * @param source              - User-provided data meant to be serialized using JSON.stringify
+ * @param maxCharacterCount   - Maximum number of characters allowed in serialized form
  */
 export function sanitize(source: string, maxCharacterCount?: number): string | undefined
 export function sanitize(source: Context, maxCharacterCount?: number): Context
@@ -59,7 +68,9 @@ export function sanitize(source: unknown, maxCharacterCount = SANITIZE_DEFAULT_M
     containerQueue,
     visitedObjectsWithPath
   )
-  let accumulatedCharacterCount = JSON.stringify(sanitizedData)?.length || 0
+  const serializedSanitizedData = JSON.stringify(sanitizedData)
+  let accumulatedCharacterCount = serializedSanitizedData ? serializedSanitizedData.length : 0
+
   if (accumulatedCharacterCount > maxCharacterCount) {
     warnOverCharacterLimit(maxCharacterCount, 'discarded', source)
     return undefined
@@ -201,17 +212,15 @@ function sanitizePrimitivesAndFunctions(value: PrimitivesAndFunctions) {
  * LIMITATIONS
  * - If a class defines a toStringTag Symbol, it will fall in the catch-all method and prevent enumeration of properties.
  * To avoid this, a toJSON method can be defined.
- * - IE11 does not return a distinct type for objects such as Map, WeakMap, ... These objects will pass through and their
- * properties enumerated if any.
- *
  */
-function sanitizeObjects(value: object) {
+function sanitizeObjects(value: object): string | SanitizedEvent {
   try {
-    // Handle events - Keep a simple implementation to avoid breaking changes
     if (value instanceof Event) {
-      return {
-        isTrusted: value.isTrusted,
-      }
+      return sanitizeEvent(value)
+    }
+
+    if (value instanceof RegExp) {
+      return `[RegExp] ${value.toString()}`
     }
 
     // Handle all remaining object types in a generic way
@@ -227,6 +236,15 @@ function sanitizeObjects(value: object) {
   return '[Unserializable]'
 }
 
+function sanitizeEvent(event: Event): SanitizedEvent {
+  return {
+    type: event.type,
+    isTrusted: event.isTrusted,
+    currentTarget: event.currentTarget ? (sanitizeObjects(event.currentTarget) as string) : null,
+    target: event.target ? (sanitizeObjects(event.target) as string) : null,
+  }
+}
+
 /**
  * Checks if a toJSON function exists and tries to execute it
  *

package/src/{domain/error → tools/stackTrace}/computeStackTrace.ts

@@ -4,8 +4,6 @@
  * Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js
  */
 
-import { startsWith } from '../../tools/utils/polyfills'
-
 export interface StackFrame {
   url?: string
   func?: string
@@ -33,7 +31,7 @@ export function computeStackTrace(ex: unknown): StackTrace {
 
   let stackProperty = tryToGetString(ex, 'stack')
   const exString = String(ex)
-  if (stackProperty && startsWith(stackProperty, exString)) {
+  if (stackProperty && stackProperty.startsWith(exString)) {
     stackProperty = stackProperty.slice(exString.length)
   }
   if (stackProperty) {
@@ -50,13 +48,37 @@ export function computeStackTrace(ex: unknown): StackTrace {
     })
   }
 
+  if (stack.length > 0 && isWronglyReportingCustomErrors() && ex instanceof Error) {
+    // if we are wrongly reporting custom errors
+    const constructors: string[] = []
+
+    // go through each inherited constructor
+    let currentPrototype: object | undefined = ex
+    while (
+      (currentPrototype = Object.getPrototypeOf(currentPrototype)) &&
+      isNonNativeClassPrototype(currentPrototype)
+    ) {
+      const constructorName = currentPrototype.constructor?.name || UNKNOWN_FUNCTION
+      constructors.push(constructorName)
+    }
+
+    // traverse the stacktrace in reverse order because the stacktrace starts with the last inherited constructor
+    // we check constructor names to ensure we remove the correct frame (and there isn't a weird unsupported environment behavior)
+    for (let i = constructors.length - 1; i >= 0 && stack[0]?.func === constructors[i]; i--) {
+      // if the first stack frame is the custom error constructor
+      // null stack frames may represent frames that failed to be parsed because the error class did not have a constructor
+      stack.shift() // remove it
+    }
+  }
+
   return {
     message: tryToGetString(ex, 'message'),
     name: tryToGetString(ex, 'name'),
     stack,
   }
 }
-const fileUrl = '((?:file|https?|blob|chrome-extension|native|eval|webpack|snippet|<anonymous>|\\w+\\.|\\/).*?)'
+const fileUrl =
+  '((?:file|https?|blob|chrome-extension|electron|native|eval|webpack|snippet|<anonymous>|\\w+\\.|\\/).*?)'
 const filePosition = '(?::(\\d+))'
 const CHROME_LINE_RE = new RegExp(`^\\s*at (.*?) ?\\(${fileUrl}${filePosition}?${filePosition}?\\)?\\s*$`, 'i')
 
@@ -126,7 +148,7 @@ function parseWinLine(line: string): StackFrame | undefined {
 }
 
 const GECKO_LINE_RE =
-  /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i
+  /^\s*(.*?)(?:\((.*?)\))?(?:(?:(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\[native).*?|[^@]*bundle|\[wasm code\])(?::(\d+))?(?::(\d+))?)|@)\s*$/i
 const GECKO_EVAL_RE = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i
 
 function parseGeckoLine(line: string): StackFrame | undefined {
@@ -162,13 +184,20 @@ function tryToGetString(candidate: unknown, property: string) {
   return typeof value === 'string' ? value : undefined
 }
 
-export function computeStackTraceFromOnErrorMessage(messageObj: unknown, url?: string, line?: number, column?: number) {
-  const stack = [{ url, column, line }]
+export function computeStackTraceFromOnErrorMessage(
+  messageObj: unknown,
+  url?: string,
+  line?: number,
+  column?: number
+): StackTrace | undefined {
+  if (url === undefined) {
+    return
+  }
   const { name, message } = tryToParseMessage(messageObj)
   return {
     name,
     message,
-    stack,
+    stack: [{ url, column, line }],
   }
 }
 
@@ -184,3 +213,38 @@ function tryToParseMessage(messageObj: unknown) {
   }
   return { name, message }
 }
+
+// Custom error stacktrace fix
+// Some browsers (safari/firefox) add the error constructor as a frame in the stacktrace
+// In order to normalize the stacktrace, we need to remove it
+
+function isNonNativeClassPrototype(prototype: object) {
+  return String(prototype.constructor).startsWith('class ')
+}
+
+let isWronglyReportingCustomErrorsCache: boolean | undefined
+
+function isWronglyReportingCustomErrors() {
+  if (isWronglyReportingCustomErrorsCache !== undefined) {
+    return isWronglyReportingCustomErrorsCache
+  }
+
+  /* eslint-disable no-restricted-syntax */
+  class DatadogTestCustomError extends Error {
+    constructor() {
+      super()
+      this.name = 'Error' // set name to Error so that no browser would default to the constructor name
+    }
+  }
+
+  const [customError, nativeError] = [DatadogTestCustomError, Error].map((errConstructor) => new errConstructor()) // so that both errors should exactly have the same stacktrace
+
+  isWronglyReportingCustomErrorsCache =
+    // If customError is not a class, it means that this was built with ES5 as target, converting the class to a normal object.
+    // Thus, error constructors will be reported on all browsers, which is the expected behavior.
+    isNonNativeClassPrototype(Object.getPrototypeOf(customError)) &&
+    // If the browser is correctly reporting the stacktrace, the normal error stacktrace should be the same as the custom error stacktrace
+    nativeError.stack !== customError.stack
+
+  return isWronglyReportingCustomErrorsCache
+}

package/src/tools/stackTrace/handlingStack.ts

@@ -0,0 +1,48 @@
+import { callMonitored } from '../monitor'
+import type { StackTrace } from './computeStackTrace'
+import { computeStackTrace } from './computeStackTrace'
+
+/**
+ * Creates a stacktrace without SDK internal frames.
+ * Constraints:
+ * - Has to be called at the utmost position of the call stack.
+ * - No monitored function should encapsulate it, that is why we need to use callMonitored inside it.
+ */
+export function createHandlingStack(
+  type: 'console error' | 'action' | 'error' | 'instrumented method' | 'log' | 'react error'
+): string {
+  /**
+   * Skip the two internal frames:
+   * - SDK API (console.error, ...)
+   * - this function
+   * in order to keep only the user calls
+   */
+  const internalFramesToSkip = 2
+  const error = new Error(type)
+  error.name = 'HandlingStack'
+  let formattedStack: string
+
+  callMonitored(() => {
+    const stackTrace = computeStackTrace(error)
+    stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip)
+    formattedStack = toStackTraceString(stackTrace)
+  })
+
+  return formattedStack!
+}
+
+export function toStackTraceString(stack: StackTrace) {
+  let result = formatErrorMessage(stack)
+  stack.stack.forEach((frame) => {
+    const func = frame.func === '?' ? '<anonymous>' : frame.func
+    const args = frame.args && frame.args.length > 0 ? `(${frame.args.join(', ')})` : ''
+    const line = frame.line ? `:${frame.line}` : ''
+    const column = frame.line && frame.column ? `:${frame.column}` : ''
+    result += `\n  at ${func!}${args} @ ${frame.url!}${line}${column}`
+  })
+  return result
+}
+
+export function formatErrorMessage(stack: StackTrace) {
+  return `${stack.name || 'Error'}: ${stack.message!}`
+}

package/src/tools/taskQueue.ts

@@ -0,0 +1,63 @@
+import { ONE_SECOND } from './utils/timeUtils'
+import { requestIdleCallback } from './requestIdleCallback'
+
+/**
+ * Maximum delay before starting to execute tasks in the queue. We don't want to wait too long
+ * before running tasks, as it might hurt reliability (ex: if the user navigates away, we might lose
+ * the opportunity to send some data). We also don't want to run tasks too often, as it might hurt
+ * performance.
+ */
+const IDLE_CALLBACK_TIMEOUT = ONE_SECOND
+
+/**
+ * Maximum amount of time allocated to running tasks when a timeout (`IDLE_CALLBACK_TIMEOUT`) is
+ * reached. We should not run tasks for too long as it will hurt performance, but we should still
+ * run some tasks to avoid postponing them forever.
+ *
+ * Rational: Running tasks for 30ms every second (IDLE_CALLBACK_TIMEOUT) should be acceptable.
+ */
+export const MAX_EXECUTION_TIME_ON_TIMEOUT = 30
+
+export interface TaskQueue {
+  push(task: Task): void
+  stop(): void
+}
+
+type Task = () => void
+
+export function createTaskQueue(): TaskQueue {
+  const pendingTasks: Task[] = []
+
+  function run(deadline: IdleDeadline) {
+    let executionTimeRemaining: () => number
+    if (deadline.didTimeout) {
+      const start = performance.now()
+      executionTimeRemaining = () => MAX_EXECUTION_TIME_ON_TIMEOUT - (performance.now() - start)
+    } else {
+      executionTimeRemaining = deadline.timeRemaining.bind(deadline)
+    }
+
+    while (executionTimeRemaining() > 0 && pendingTasks.length) {
+      pendingTasks.shift()!()
+    }
+
+    if (pendingTasks.length) {
+      scheduleNextRun()
+    }
+  }
+
+  function scheduleNextRun() {
+    requestIdleCallback(run, { timeout: IDLE_CALLBACK_TIMEOUT })
+  }
+
+  return {
+    push(task) {
+      if (pendingTasks.push(task) === 1) {
+        scheduleNextRun()
+      }
+    },
+    stop() {
+      pendingTasks.length = 0
+    },
+  }
+}

package/src/tools/timer.ts

@@ -1,6 +1,6 @@
 import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
 import { monitor } from './monitor'
-import { getGlobalObject } from './getGlobalObject'
+import { getGlobalObject } from './globalObject'
 
 export type TimeoutId = ReturnType<typeof globalThis.setTimeout>
 

package/src/tools/utils/arrayUtils.ts

@@ -1,7 +1,15 @@
-import { arrayFrom } from './polyfills'
-
 export function removeDuplicates<T>(array: T[]) {
   const set = new Set<T>()
   array.forEach((item) => set.add(item))
-  return arrayFrom(set)
+  return Array.from(set)
+}
+
+export function removeItem<T>(array: T[], item: T) {
+  const index = array.indexOf(item)
+  if (index >= 0) {
+    array.splice(index, 1)
+  }
+}
+export function isNonEmptyArray<T>(value: unknown): value is T[] {
+  return Array.isArray(value) && value.length > 0
 }