react-tooltip 6.0.0-beta.1179.rc.6 → 6.0.0-beta.1179.rc.7

package/{CONTRIBUTION.md → CONTRIBUTING.md}

@@ -35,4 +35,3 @@ To this:
 
 OBS: do not commit this change or the docs will broken the deployment and will not be updated.
 
-

package/README.md

@@ -181,7 +181,7 @@ We would gladly accept a new maintainer to help out!
 
 ## Contributing
 
-We welcome your contribution! Fork the repo, make some changes, submit a pull-request! Our [contributing](CONTRIBUTION.md) doc has some details.
+We welcome your contribution! Fork the repo, make some changes, submit a pull-request! Our [contributing](CONTRIBUTING.md) doc has some details.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-tooltip",
-  "version": "6.0.0-beta.1179.rc.6",
+  "version": "6.0.0-beta.1179.rc.7",
   "description": "react tooltip component",
   "scripts": {
     "dev-rollup": "node ./prebuild.js --env=development && node --max_old_space_size=2048 ./node_modules/rollup/dist/bin/rollup -c rollup.config.dev.mjs --watch",

package/benchmarks/aggregate-benchmarks.mjs

@@ -1,258 +0,0 @@
-import { readdir, readFile, writeFile } from 'fs/promises'
-import path from 'path'
-import { fileURLToPath } from 'url'
-import minimist from 'minimist'
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const resultsDir = path.join(__dirname, 'results')
-
-const args = minimist(process.argv.slice(2))
-const latest = Number(args.latest ?? 3)
-const useAll = Boolean(args.all)
-const generationArg = args.generation
-const useAllGenerations = Boolean(args['all-generations'])
-const explicitFiles = args._.map((inputPath) => path.resolve(inputPath))
-
-function aggregateNumbers(values) {
-  const sorted = values
-    .filter((value) => typeof value === 'number' && Number.isFinite(value))
-    .sort((left, right) => left - right)
-
-  if (sorted.length === 0) {
-    return {
-      median: null,
-      p95: null,
-      min: null,
-      max: null,
-      mean: null,
-      standardDeviation: null,
-      spreadPercent: null,
-      sampleCount: 0,
-    }
-  }
-
-  const middle = Math.floor(sorted.length / 2)
-  const median =
-    sorted.length % 2 === 0
-      ? (sorted[middle - 1] + sorted[middle]) / 2
-      : sorted[middle]
-  const mean = sorted.reduce((total, value) => total + value, 0) / sorted.length
-  const variance =
-    sorted.reduce((total, value) => total + (value - mean) ** 2, 0) / sorted.length
-  const standardDeviation = Math.sqrt(variance)
-  const p95 = sorted[Math.min(sorted.length - 1, Math.ceil(sorted.length * 0.95) - 1)]
-
-  return {
-    median,
-    p95,
-    min: sorted[0],
-    max: sorted[sorted.length - 1],
-    mean,
-    standardDeviation,
-    spreadPercent: median === 0 ? null : ((p95 - median) / Math.abs(median)) * 100,
-    sampleCount: sorted.length,
-  }
-}
-
-function formatMs(value) {
-  return typeof value === 'number' ? `${value.toFixed(2)} ms` : '—'
-}
-
-function formatBytes(value) {
-  return typeof value === 'number' ? `${(value / 1024).toFixed(1)} KiB` : '—'
-}
-
-function formatPercent(value) {
-  return typeof value === 'number' ? `${value.toFixed(1)}%` : '—'
-}
-
-function timestampId() {
-  return new Date().toISOString().replace(/[:.]/g, '-')
-}
-
-function getRunGeneration(run) {
-  return Number.isInteger(run?.benchmarkVersion) ? run.benchmarkVersion : 0
-}
-
-async function resolveInputFiles() {
-  if (explicitFiles.length > 0) {
-    return explicitFiles
-  }
-
-  const entries = await readdir(resultsDir)
-  const scalingEntries = entries
-    .filter((entry) => entry.endsWith('.json'))
-    .filter((entry) => entry.startsWith('scaling-'))
-    .map((entry) => path.join(resultsDir, entry))
-    .sort()
-
-  if (useAll) {
-    return scalingEntries
-  }
-
-  return scalingEntries.slice(-latest)
-}
-
-function resolveGenerationSelection(runs) {
-  if (useAllGenerations) {
-    return {
-      selectedRuns: runs,
-      generationLabel: 'all benchmark generations',
-    }
-  }
-
-  if (generationArg !== undefined) {
-    const requestedGeneration =
-      generationArg === 'latest' ? Math.max(...runs.map(getRunGeneration)) : Number(generationArg)
-
-    if (!Number.isInteger(requestedGeneration)) {
-      throw new Error(`Invalid --generation value: ${generationArg}`)
-    }
-
-    return {
-      selectedRuns: runs.filter((run) => getRunGeneration(run) === requestedGeneration),
-      generationLabel:
-        generationArg === 'latest'
-          ? `latest benchmark generation (${requestedGeneration})`
-          : `benchmark generation ${requestedGeneration}`,
-    }
-  }
-
-  return {
-    selectedRuns: runs,
-    generationLabel: 'all benchmark generations',
-  }
-}
-
-function buildMarkdownReport(result) {
-  const lines = [
-    '# Aggregated React Tooltip Scaling Benchmark',
-    '',
-    `- Timestamp: ${result.timestamp}`,
-    `- Input files: ${result.inputFiles.length}`,
-    `- Selection: ${result.selection}`,
-    `- Generation filter: ${result.generationFilter}`,
-    `- Counts: ${result.counts.join(', ')}`,
-    '',
-    '| Count | V5 mount | V6 mount | Mount delta | Mount spread | V5 unmount | V6 unmount | Unmount delta | Unmount spread | V5 mount mem | V6 mount mem | Mount mem delta | Mount mem spread | V5 unmount mem | V6 unmount mem | Unmount mem delta | Unmount mem spread | Samples | V5 timeouts | V6 timeouts |',
-    '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |',
-  ]
-
-  result.summary.forEach((row) => {
-    lines.push(
-      `| ${row.count} | ${formatMs(row.v5.mount.median)} | ${formatMs(row.v6.mount.median)} | ${formatMs(row.mountDeltaMs)} | ${formatPercent(row.mountDeltaSpreadPercent)} | ${formatMs(row.v5.unmount.median)} | ${formatMs(row.v6.unmount.median)} | ${formatMs(row.unmountDeltaMs)} | ${formatPercent(row.unmountDeltaSpreadPercent)} | ${formatBytes(row.v5.mountMemory.median)} | ${formatBytes(row.v6.mountMemory.median)} | ${formatBytes(row.mountMemoryDeltaBytes)} | ${formatPercent(row.mountMemoryDeltaSpreadPercent)} | ${formatBytes(row.v5.unmountMemory.median)} | ${formatBytes(row.v6.unmountMemory.median)} | ${formatBytes(row.unmountMemoryDeltaBytes)} | ${formatPercent(row.unmountMemoryDeltaSpreadPercent)} | ${row.sampleCount} | ${row.v5.timeoutCount} | ${row.v6.timeoutCount} |`,
-    )
-  })
-
-  return `${lines.join('\n')}\n`
-}
-
-async function main() {
-  const inputFiles = await resolveInputFiles()
-
-  if (inputFiles.length === 0) {
-    throw new Error('No benchmark result files were found to aggregate.')
-  }
-
-  const allRuns = await Promise.all(
-    inputFiles.map(async (inputFile) => JSON.parse(await readFile(inputFile, 'utf8'))),
-  )
-  const { selectedRuns: runs, generationLabel } = resolveGenerationSelection(allRuns)
-
-  if (runs.length === 0) {
-    throw new Error('No benchmark result files matched the requested generation filter.')
-  }
-
-  const counts = Array.from(
-    new Set(runs.flatMap((run) => run.counts ?? [])),
-  ).sort((left, right) => left - right)
-
-  const summary = counts.map((count) => {
-    const rows = runs
-      .map((run) => run.summary?.find((entry) => entry.count === count))
-      .filter(Boolean)
-
-    const aggregateVersion = (version) => ({
-      mount: aggregateNumbers(rows.map((row) => row[version]?.mount?.median)),
-      unmount: aggregateNumbers(rows.map((row) => row[version]?.unmount?.median)),
-      mountMemory: aggregateNumbers(rows.map((row) => row[version]?.mountMemory?.median)),
-      unmountMemory: aggregateNumbers(rows.map((row) => row[version]?.unmountMemory?.median)),
-      timeoutCount: rows.reduce(
-        (total, row) => total + (row[version]?.timeoutCount ?? 0),
-        0,
-      ),
-    })
-
-    const v5 = aggregateVersion('v5')
-    const v6 = aggregateVersion('v6')
-    const sampleCount = Math.max(v5.mount.sampleCount, v6.mount.sampleCount)
-
-    const mountDeltaMs =
-      typeof v5.mount.median === 'number' && typeof v6.mount.median === 'number'
-        ? v6.mount.median - v5.mount.median
-        : null
-    const unmountDeltaMs =
-      typeof v5.unmount.median === 'number' && typeof v6.unmount.median === 'number'
-        ? v6.unmount.median - v5.unmount.median
-        : null
-    const mountMemoryDeltaBytes =
-      typeof v5.mountMemory.median === 'number' && typeof v6.mountMemory.median === 'number'
-        ? v6.mountMemory.median - v5.mountMemory.median
-        : null
-    const unmountMemoryDeltaBytes =
-      typeof v5.unmountMemory.median === 'number' && typeof v6.unmountMemory.median === 'number'
-        ? v6.unmountMemory.median - v5.unmountMemory.median
-        : null
-
-    return {
-      count,
-      sampleCount,
-      v5,
-      v6,
-      mountDeltaMs,
-      unmountDeltaMs,
-      mountMemoryDeltaBytes,
-      unmountMemoryDeltaBytes,
-      mountDeltaSpreadPercent:
-        typeof v5.mount.spreadPercent === 'number' && typeof v6.mount.spreadPercent === 'number'
-          ? Math.max(v5.mount.spreadPercent, v6.mount.spreadPercent)
-          : null,
-      unmountDeltaSpreadPercent:
-        typeof v5.unmount.spreadPercent === 'number' && typeof v6.unmount.spreadPercent === 'number'
-          ? Math.max(v5.unmount.spreadPercent, v6.unmount.spreadPercent)
-          : null,
-      mountMemoryDeltaSpreadPercent:
-        typeof v5.mountMemory.spreadPercent === 'number' && typeof v6.mountMemory.spreadPercent === 'number'
-          ? Math.max(v5.mountMemory.spreadPercent, v6.mountMemory.spreadPercent)
-          : null,
-      unmountMemoryDeltaSpreadPercent:
-        typeof v5.unmountMemory.spreadPercent === 'number' && typeof v6.unmountMemory.spreadPercent === 'number'
-          ? Math.max(v5.unmountMemory.spreadPercent, v6.unmountMemory.spreadPercent)
-          : null,
-    }
-  })
-
-  const result = {
-    id: `aggregate-scaling-${timestampId()}`,
-    timestamp: new Date().toISOString(),
-    selection: useAll ? 'all scaling runs' : `latest ${latest} scaling run(s)`,
-    generationFilter: generationLabel,
-    inputFiles: runs.map((run, index) => inputFiles[allRuns.indexOf(run)] ?? inputFiles[index]),
-    counts,
-    summary,
-  }
-
-  const jsonPath = path.join(resultsDir, `${result.id}.json`)
-  const markdownPath = path.join(resultsDir, `${result.id}.md`)
-
-  await writeFile(jsonPath, `${JSON.stringify(result, null, 2)}\n`, 'utf8')
-  await writeFile(markdownPath, buildMarkdownReport(result), 'utf8')
-
-  console.log(`Saved aggregate benchmark results to ${jsonPath}`)
-  console.log(`Saved aggregate benchmark report to ${markdownPath}`)
-}
-
-main().catch((error) => {
-  console.error(error)
-  process.exitCode = 1
-})

package/benchmarks/fixture/app.tsx

@@ -1,278 +0,0 @@
-import React, { useEffect, useMemo, useState } from 'react'
-import { flushSync } from 'react-dom'
-import { createRoot } from 'react-dom/client'
-import { Tooltip as TooltipV5 } from '../../docs/node_modules/react-tooltip/dist/react-tooltip.mjs'
-import { Tooltip as TooltipV6 } from '../../dist/react-tooltip.esm.js'
-
-type BenchmarkVersion = 'v5' | 'v6'
-
-type RenderMode = 'shared'
-
-type FixtureState = {
-  version: BenchmarkVersion
-  count: number
-  renderMode: RenderMode
-}
-
-type ScenarioSample = {
-  count: number
-  mountDurationMs: number | null
-  unmountDurationMs: number | null
-  mountMemoryDeltaBytes: number | null
-  unmountMemoryDeltaBytes: number | null
-  timedOut: boolean
-}
-
-type ScenarioResult = {
-  version: BenchmarkVersion
-  renderMode: RenderMode
-  samplesByCount: ScenarioSample[]
-}
-
-type BenchmarkHarness = {
-  runScalingBenchmark: (args: {
-    version: BenchmarkVersion
-    counts: number[]
-    timeoutMs: number
-    repeats: number
-    warmups: number
-    renderMode: RenderMode
-    onProgress?: (message: string) => void
-  }) => Promise<ScenarioResult>
-}
-
-declare global {
-  interface Window {
-    __reactTooltipBenchmark?: BenchmarkHarness
-    __REACT_DEVTOOLS_GLOBAL_HOOK__?: {
-      isDisabled?: boolean
-    }
-    gc?: () => void
-  }
-}
-
-window.__REACT_DEVTOOLS_GLOBAL_HOOK__ = {
-  isDisabled: true,
-}
-
-function readUsedHeapBytes() {
-  const performanceWithMemory = window.performance as Performance & {
-    memory?: {
-      usedJSHeapSize: number
-    }
-  }
-
-  return performanceWithMemory.memory?.usedJSHeapSize ?? null
-}
-
-function nextFrame() {
-  return new Promise<void>((resolve) => {
-    window.requestAnimationFrame(() => resolve())
-  })
-}
-
-async function collectGarbage() {
-  if (typeof window.gc === 'function') {
-    window.gc()
-    await nextFrame()
-    window.gc()
-    await nextFrame()
-  }
-}
-
-async function readStableHeapBytes() {
-  await collectGarbage()
-  return readUsedHeapBytes()
-}
-
-async function waitUntil(predicate: () => boolean, timeoutMs: number) {
-  const startedAt = window.performance.now()
-
-  while (window.performance.now() - startedAt < timeoutMs) {
-    if (predicate()) {
-      return true
-    }
-    await nextFrame()
-  }
-
-  return false
-}
-
-function BenchmarkFixture({ version, count }: FixtureState) {
-  const TooltipComponent = version === 'v5' ? TooltipV5 : TooltipV6
-  const tooltipId = `benchmark-tooltip-${version}`
-
-  const anchorIds = useMemo(
-    () => Array.from({ length: count }, (_, index) => `anchor-${version}-${index}`),
-    [count, version],
-  )
-
-  useEffect(() => {
-    document.body.setAttribute('data-benchmark-count', String(count))
-    document.body.setAttribute('data-benchmark-version', version)
-  }, [count, version])
-
-  return (
-    <div className="benchmark-surface" aria-hidden="true">
-      <div className="anchor-grid">
-        {anchorIds.map((id, index) => (
-          <button
-            key={id}
-            id={id}
-            className="anchor"
-            data-tooltip-id={tooltipId}
-            data-tooltip-content={`Anchor ${index}`}
-            type="button"
-          >
-            {index}
-          </button>
-        ))}
-      </div>
-      <TooltipComponent id={tooltipId} />
-    </div>
-  )
-}
-
-const rootNode = document.getElementById('root')
-
-if (!rootNode) {
-  throw new Error('Benchmark root element was not found.')
-}
-
-const benchmarkRoot = createRoot(rootNode)
-
-function renderFixture(nextState: FixtureState) {
-  return new Promise<void>((resolve) => {
-    flushSync(() => {
-      benchmarkRoot.render(<BenchmarkFixture {...nextState} />)
-    })
-    resolve()
-  })
-}
-
-function unmountFixture() {
-  return new Promise<void>((resolve) => {
-    flushSync(() => {
-      benchmarkRoot.render(<></>)
-    })
-    resolve()
-  })
-}
-
-async function runScalingBenchmark({
-  version,
-  counts,
-  timeoutMs,
-  repeats,
-  warmups,
-  renderMode,
-  onProgress,
-}: {
-  version: BenchmarkVersion
-  counts: number[]
-  timeoutMs: number
-  repeats: number
-  warmups: number
-  renderMode: RenderMode
-  onProgress?: (message: string) => void
-}): Promise<ScenarioResult> {
-  const samplesByCount: ScenarioSample[] = []
-
-  for (const count of counts) {
-    for (let warmupIndex = 0; warmupIndex < warmups; warmupIndex += 1) {
-      onProgress?.(`count=${count} warmup ${warmupIndex + 1}/${warmups}`)
-      await renderFixture({
-        version,
-        count: 0,
-        renderMode,
-      })
-      await nextFrame()
-      await renderFixture({
-        version,
-        count,
-        renderMode,
-      })
-      await waitUntil(
-        () => document.querySelectorAll('[data-tooltip-id]').length === count,
-        timeoutMs,
-      )
-      await nextFrame()
-      await unmountFixture()
-      await nextFrame()
-    }
-
-    for (let repeatIndex = 0; repeatIndex < repeats; repeatIndex += 1) {
-      onProgress?.(`count=${count} repeat ${repeatIndex + 1}/${repeats}`)
-      await renderFixture({
-        version,
-        count: 0,
-        renderMode,
-      })
-      await nextFrame()
-
-      const mountMemoryBefore = await readStableHeapBytes()
-      const mountStartedAt = window.performance.now()
-
-      await renderFixture({
-        version,
-        count,
-        renderMode,
-      })
-
-      const mountReady = await waitUntil(() => {
-        return document.querySelectorAll('[data-tooltip-id]').length === count
-      }, timeoutMs)
-
-      await nextFrame()
-
-      const mountEndedAt = window.performance.now()
-
-      const mountMemoryAfter = await readStableHeapBytes()
-      const unmountMemoryBefore = mountMemoryAfter
-      const unmountStartedAt = window.performance.now()
-
-      await unmountFixture()
-
-      const unmountReady = await waitUntil(() => {
-        return document.querySelectorAll('[data-tooltip-id]').length === 0
-      }, timeoutMs)
-
-      await nextFrame()
-
-      const unmountEndedAt = window.performance.now()
-
-      const unmountMemoryAfter = await readStableHeapBytes()
-
-      samplesByCount.push({
-        count,
-        mountDurationMs: mountReady ? mountEndedAt - mountStartedAt : null,
-        unmountDurationMs: unmountReady ? unmountEndedAt - unmountStartedAt : null,
-        mountMemoryDeltaBytes:
-          mountReady && mountMemoryBefore !== null && mountMemoryAfter !== null
-            ? mountMemoryAfter - mountMemoryBefore
-            : null,
-        unmountMemoryDeltaBytes:
-          unmountReady && unmountMemoryBefore !== null && unmountMemoryAfter !== null
-            ? unmountMemoryAfter - unmountMemoryBefore
-            : null,
-        timedOut: !mountReady || !unmountReady,
-      })
-    }
-  }
-
-  return {
-    version,
-    renderMode,
-    samplesByCount,
-  }
-}
-
-window.__reactTooltipBenchmark = {
-  runScalingBenchmark,
-}
-
-renderFixture({
-  version: 'v6',
-  count: 0,
-  renderMode: 'shared',
-})

package/benchmarks/fixture/index.html

@@ -1,54 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>React Tooltip Benchmark</title>
-    <style>
-      html,
-      body {
-        margin: 0;
-        padding: 0;
-      }
-
-      body {
-        font-family: sans-serif;
-      }
-
-      #root {
-        min-height: 100vh;
-      }
-
-      .benchmark-surface {
-        left: 24px;
-        opacity: 0.02;
-        pointer-events: none;
-        position: fixed;
-        top: 24px;
-        width: 1200px;
-        z-index: -1;
-      }
-
-      .anchor-grid {
-        display: grid;
-        gap: 8px;
-        grid-template-columns: repeat(10, minmax(0, 1fr));
-      }
-
-      .anchor {
-        align-items: center;
-        background: #111827;
-        border: 0;
-        border-radius: 6px;
-        color: #fff;
-        display: inline-flex;
-        height: 28px;
-        justify-content: center;
-      }
-    </style>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/app.js"></script>
-  </body>
-</html>

package/benchmarks/run-benchmark.mjs

@@ -1,324 +0,0 @@
-import { mkdir, readFile, rm, writeFile } from 'fs/promises'
-import path from 'path'
-import { fileURLToPath, pathToFileURL } from 'url'
-import * as esbuild from 'esbuild'
-import minimist from 'minimist'
-import { chromium } from 'playwright'
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const rootDir = path.resolve(__dirname, '..')
-const cacheDir = path.join(__dirname, '.cache')
-const resultsDir = path.join(__dirname, 'results')
-const fixtureHtmlPath = path.join(__dirname, 'fixture', 'index.html')
-const fixtureEntryPath = path.join(__dirname, 'fixture', 'app.tsx')
-const cacheHtmlPath = path.join(cacheDir, 'index.html')
-const fixtureBundlePath = path.join(cacheDir, 'app.js')
-const rootReactPath = path.join(rootDir, 'node_modules', 'react', 'index.js')
-const rootReactDomPath = path.join(rootDir, 'node_modules', 'react-dom', 'index.js')
-const benchmarkVersion = 3
-const benchmarkLabel = 'precise-memory-gc-separated'
-
-const args = minimist(process.argv.slice(2))
-const counts = `${args.counts ?? '50,100,500,2000,5000,10000,25000'}`
-  .split(',')
-  .map((value) => Number(value.trim()))
-  .filter((value) => Number.isFinite(value) && value > 0)
-const timeoutMs = Number(args.timeoutMs ?? 1200)
-const repeats = Number(args.repeats ?? 5)
-const warmups = Number(args.warmups ?? 1)
-const executablePath = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
-
-function aggregateNumbers(values) {
-  const sorted = [...values].sort((left, right) => left - right)
-  if (sorted.length === 0) {
-    return {
-      median: null,
-      p95: null,
-      min: null,
-      max: null,
-      mean: null,
-      standardDeviation: null,
-      spreadPercent: null,
-    }
-  }
-
-  const middle = Math.floor(sorted.length / 2)
-  const median =
-    sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle]
-  const mean = sorted.reduce((total, value) => total + value, 0) / sorted.length
-  const variance = sorted.reduce((total, value) => total + (value - mean) ** 2, 0) / sorted.length
-  const standardDeviation = Math.sqrt(variance)
-  const p95 = sorted[Math.min(sorted.length - 1, Math.ceil(sorted.length * 0.95) - 1)]
-
-  return {
-    median,
-    p95,
-    min: sorted[0],
-    max: sorted[sorted.length - 1],
-    mean,
-    standardDeviation,
-    spreadPercent: median === 0 ? null : ((p95 - median) / Math.abs(median)) * 100,
-  }
-}
-
-function formatMs(value) {
-  return typeof value === 'number' ? `${value.toFixed(2)} ms` : 'timeout'
-}
-
-function formatBytes(value) {
-  return typeof value === 'number' ? `${(value / 1024).toFixed(1)} KiB` : '—'
-}
-
-function buildMarkdownReport(result) {
-  const lines = [
-    '# React Tooltip Scaling Benchmark',
-    '',
-    `- Timestamp: ${result.timestamp}`,
-    `- Browser: ${result.browser}`,
-    `- Counts: ${result.counts.join(', ')}`,
-    `- Warmups: ${result.warmups}`,
-    `- Repeats: ${result.repeats}`,
-    `- Timeout: ${result.timeoutMs} ms`,
-    '',
-    '| Count | V5 mount | V6 mount | Mount delta | V5 unmount | V6 unmount | Unmount delta | V5 mount mem | V6 mount mem | V5 issues | V6 issues |',
-    '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |',
-  ]
-
-  result.summary.forEach((row) => {
-    lines.push(
-      `| ${row.count} | ${formatMs(row.v5.mount.median)} | ${formatMs(row.v6.mount.median)} | ${formatMs(row.mountDeltaMs)} | ${formatMs(row.v5.unmount.median)} | ${formatMs(row.v6.unmount.median)} | ${formatMs(row.unmountDeltaMs)} | ${formatBytes(row.v5.mountMemory.median)} | ${formatBytes(row.v6.mountMemory.median)} | ${row.v5.timeoutCount} | ${row.v6.timeoutCount} |`,
-    )
-  })
-
-  return `${lines.join('\n')}\n`
-}
-
-function logProgress(message) {
-  const timestamp = new Date().toLocaleTimeString()
-  console.log(`[benchmark ${timestamp}] ${message}`)
-}
-
-function timestampId() {
-  return new Date().toISOString().replace(/[:.]/g, '-')
-}
-
-async function ensureFixtureBundle() {
-  await mkdir(cacheDir, { recursive: true })
-
-  await esbuild.build({
-    entryPoints: [fixtureEntryPath],
-    outfile: fixtureBundlePath,
-    bundle: true,
-    format: 'iife',
-    sourcemap: false,
-    platform: 'browser',
-    alias: {
-      react: rootReactPath,
-      'react-dom': rootReactDomPath,
-    },
-    jsx: 'transform',
-    jsxFactory: 'React.createElement',
-    jsxFragment: 'React.Fragment',
-    loader: {
-      '.js': 'jsx',
-      '.ts': 'ts',
-      '.tsx': 'tsx',
-    },
-  })
-
-  const html = await readFile(fixtureHtmlPath, 'utf8')
-  await writeFile(
-    cacheHtmlPath,
-    html.replace('<script type="module" src="/app.js"></script>', ''),
-    'utf8',
-  )
-}
-
-async function main() {
-  logProgress('Preparing benchmark bundle')
-  await rm(cacheDir, { recursive: true, force: true })
-  await mkdir(resultsDir, { recursive: true })
-  await ensureFixtureBundle()
-  logProgress('Launching headless Chrome')
-
-  const browser = await chromium.launch({
-    executablePath,
-    headless: true,
-    args: ['--enable-precise-memory-info', '--js-flags=--expose-gc'],
-  })
-
-  try {
-    const page = await browser.newPage()
-    page.on('console', (message) => {
-      const text = message.text()
-      if (text.includes('Download the React DevTools')) {
-        return
-      }
-      console.log(`[page:${message.type()}] ${text}`)
-    })
-    page.on('pageerror', (error) => {
-      console.error(`[pageerror] ${error.message}`)
-    })
-
-    logProgress('Loading benchmark fixture')
-    await page.goto(pathToFileURL(cacheHtmlPath).toString(), {
-      waitUntil: 'networkidle',
-    })
-    await page.addScriptTag({
-      content: await readFile(fixtureBundlePath, 'utf8'),
-    })
-    await page.waitForFunction(() => Boolean(window.__reactTooltipBenchmark), null, {
-      timeout: timeoutMs,
-    })
-    logProgress(`Running scaling benchmark for counts: ${counts.join(', ')}`)
-
-    const runVersion = async (version) => {
-      logProgress(`Starting ${version.toUpperCase()} run`)
-      return page.evaluate(
-        async ({ nextVersion, nextCounts, nextTimeoutMs, nextRepeats, nextWarmups }) => {
-          const harness = window.__reactTooltipBenchmark
-          if (!harness) {
-            throw new Error('Benchmark harness was not initialized.')
-          }
-
-          const progressPrefix = `[${nextVersion.toUpperCase()}]`
-
-          return harness.runScalingBenchmark({
-            version: nextVersion,
-            counts: nextCounts,
-            timeoutMs: nextTimeoutMs,
-            repeats: nextRepeats,
-            warmups: nextWarmups,
-            renderMode: 'shared',
-            onProgress: (message) => {
-              console.log(`${progressPrefix} ${message}`)
-            },
-          })
-        },
-        {
-          nextVersion: version,
-          nextCounts: counts,
-          nextTimeoutMs: timeoutMs,
-          nextRepeats: repeats,
-          nextWarmups: warmups,
-        },
-      )
-    }
-
-    const v5 = await runVersion('v5')
-    logProgress('Completed V5 run')
-    const v6 = await runVersion('v6')
-    logProgress('Completed V6 run')
-
-    const summary = counts.map((count) => {
-      const v5Samples = v5.samplesByCount.filter((sample) => sample.count === count)
-      const v6Samples = v6.samplesByCount.filter((sample) => sample.count === count)
-
-      const aggregateVersion = (samples) => {
-        const successful = samples.filter((sample) => !sample.timedOut)
-        return {
-          mount: aggregateNumbers(
-            successful
-              .map((sample) => sample.mountDurationMs)
-              .filter((value) => typeof value === 'number'),
-          ),
-          unmount: aggregateNumbers(
-            successful
-              .map((sample) => sample.unmountDurationMs)
-              .filter((value) => typeof value === 'number'),
-          ),
-          mountMemory: aggregateNumbers(
-            successful
-              .map((sample) => sample.mountMemoryDeltaBytes)
-              .filter((value) => typeof value === 'number'),
-          ),
-          unmountMemory: aggregateNumbers(
-            successful
-              .map((sample) => sample.unmountMemoryDeltaBytes)
-              .filter((value) => typeof value === 'number'),
-          ),
-          timeoutCount: samples.filter((sample) => sample.timedOut).length,
-          sampleCount: samples.length,
-        }
-      }
-
-      const v5Aggregate = aggregateVersion(v5Samples)
-      const v6Aggregate = aggregateVersion(v6Samples)
-
-      return {
-        count,
-        v5: v5Aggregate,
-        v6: v6Aggregate,
-        mountDeltaMs:
-          typeof v5Aggregate.mount.median === 'number' &&
-          typeof v6Aggregate.mount.median === 'number'
-            ? v6Aggregate.mount.median - v5Aggregate.mount.median
-            : null,
-        unmountDeltaMs:
-          typeof v5Aggregate.unmount.median === 'number' &&
-          typeof v6Aggregate.unmount.median === 'number'
-            ? v6Aggregate.unmount.median - v5Aggregate.unmount.median
-            : null,
-        mountMemoryDeltaBytes:
-          typeof v5Aggregate.mountMemory.median === 'number' &&
-          typeof v6Aggregate.mountMemory.median === 'number'
-            ? v6Aggregate.mountMemory.median - v5Aggregate.mountMemory.median
-            : null,
-      }
-    })
-
-    const result = {
-      id: `scaling-${timestampId()}`,
-      timestamp: new Date().toISOString(),
-      benchmarkVersion,
-      benchmarkLabel,
-      benchmarkFeatures: {
-        preciseMemory: true,
-        exposedGc: true,
-        gcSeparatedFromTiming: true,
-      },
-      browser: await page.evaluate(() => window.navigator.userAgent),
-      counts,
-      warmups,
-      repeats,
-      timeoutMs,
-      summary,
-      aggregates: {
-        v5MountDurationsMs: aggregateNumbers(
-          summary.map((item) => item.v5.mount.median).filter((value) => typeof value === 'number'),
-        ),
-        v6MountDurationsMs: aggregateNumbers(
-          summary.map((item) => item.v6.mount.median).filter((value) => typeof value === 'number'),
-        ),
-        v5UnmountDurationsMs: aggregateNumbers(
-          summary
-            .map((item) => item.v5.unmount.median)
-            .filter((value) => typeof value === 'number'),
-        ),
-        v6UnmountDurationsMs: aggregateNumbers(
-          summary
-            .map((item) => item.v6.unmount.median)
-            .filter((value) => typeof value === 'number'),
-        ),
-      },
-      raw: {
-        v5,
-        v6,
-      },
-    }
-
-    const outputPath = path.join(resultsDir, `${result.id}.json`)
-    const reportPath = path.join(resultsDir, `${result.id}.md`)
-    await writeFile(outputPath, `${JSON.stringify(result, null, 2)}\n`, 'utf8')
-    await writeFile(reportPath, buildMarkdownReport(result), 'utf8')
-    logProgress(`Saved benchmark results to ${outputPath}`)
-    logProgress(`Saved benchmark report to ${reportPath}`)
-  } finally {
-    await browser.close()
-  }
-}
-
-main().catch((error) => {
-  console.error(error)
-  process.exitCode = 1
-})

package/benchmarks/run-scaling-series.mjs

@@ -1,77 +0,0 @@
-import { spawn } from 'child_process'
-import minimist from 'minimist'
-
-const args = minimist(process.argv.slice(2), {
-  alias: {
-    r: 'runs',
-  },
-  default: {
-    runs: 3,
-  },
-})
-
-const runCount = Number(args.runs)
-
-if (!Number.isInteger(runCount) || runCount <= 0) {
-  throw new Error(`Expected --runs/-r to be a positive integer, received: ${args.runs}`)
-}
-
-const passthroughArgs = process.argv.slice(2).filter((arg, index, allArgs) => {
-  if (arg === '-r' || arg === '--runs') {
-    return false
-  }
-
-  const previousArg = allArgs[index - 1]
-  if (previousArg === '-r' || previousArg === '--runs') {
-    return false
-  }
-
-  return true
-})
-
-function formatStep(step, total, label) {
-  return `[series ${step}/${total}] ${label}`
-}
-
-function runCommand(command, commandArgs) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, commandArgs, {
-      stdio: 'inherit',
-      shell: false,
-    })
-
-    child.on('error', reject)
-    child.on('exit', (code, signal) => {
-      if (code === 0) {
-        resolve()
-        return
-      }
-
-      reject(
-        new Error(
-          signal
-            ? `${command} ${commandArgs.join(' ')} exited with signal ${signal}`
-            : `${command} ${commandArgs.join(' ')} exited with code ${code}`,
-        ),
-      )
-    })
-  })
-}
-
-async function main() {
-  console.log(formatStep(1, runCount + 2, 'Building benchmark bundle'))
-  await runCommand('yarn', ['build-esbuild'])
-
-  for (let index = 0; index < runCount; index += 1) {
-    console.log(formatStep(index + 2, runCount + 2, `Running benchmark pass ${index + 1}/${runCount}`))
-    await runCommand('node', ['./benchmarks/run-benchmark.mjs', ...passthroughArgs])
-  }
-
-  console.log(formatStep(runCount + 2, runCount + 2, `Aggregating latest ${runCount} run(s)`))
-  await runCommand('node', ['./benchmarks/aggregate-benchmarks.mjs', '--latest', String(runCount)])
-}
-
-main().catch((error) => {
-  console.error(error)
-  process.exitCode = 1
-})

package/global.d.ts

@@ -1,7 +0,0 @@
-declare module '*.module.css' {
-  const classes: Record<string, string>
-
-  export default classes
-}
-
-declare module '*.css'

package/rollup.config.dev.mjs

@@ -1,87 +0,0 @@
-// import analyze from 'rollup-plugin-analyzer'
-import commonjs from '@rollup/plugin-commonjs'
-import filesize from 'rollup-plugin-filesize'
-import postcss from 'rollup-plugin-postcss'
-import progress from 'rollup-plugin-progress'
-import browsersync from 'rollup-plugin-browsersync'
-import html from 'rollup-plugin-html-scaffold'
-import replace from '@rollup/plugin-replace'
-import copy from 'rollup-plugin-copy'
-import { nodeResolve } from '@rollup/plugin-node-resolve'
-import ts from '@rollup/plugin-typescript'
-import typescript from 'typescript'
-
-const input = ['src/index-dev.tsx']
-
-const name = 'ReactTooltip'
-
-const globals = {
-  react: 'React',
-  'react-dom': 'ReactDOM',
-  clsx: 'clsx',
-}
-
-const plugins = [
-  progress(),
-  html({
-    input: './public/index-rollup.html',
-    output: './build/index.html',
-    template: { appBundle: 'index.js' },
-  }),
-  replace({
-    preventAssignment: true,
-    values: {
-      'process.env.NODE_ENV': JSON.stringify('development'),
-    },
-  }),
-  postcss({
-    extract: true,
-    autoModules: true,
-    include: '**/*.css',
-    extensions: ['.css'],
-    plugins: [],
-  }),
-  nodeResolve(),
-  ts({
-    typescript,
-    tsconfig: './tsconfig.json',
-    noEmitOnError: false,
-    // declaration: true,
-    // declarationDir: './build',
-  }),
-  commonjs({
-    include: 'node_modules/**',
-  }),
-  // analyze(), // to check diff of file size when bundle
-  filesize(),
-  copy({
-    // targets: [
-    //   { src: 'src/assets', dest: 'build/' },
-    //   { src: 'public/manifest.json', dest: 'build/' },
-    //   { src: 'public/offline.html', dest: 'build/' },
-    // ],
-    targets: [{ src: 'dist/', dest: 'build/' }],
-    verbose: true,
-  }),
-  browsersync({
-    server: 'build',
-    watch: true,
-    ui: false,
-    open: false,
-    // port: 3000,
-    // ui: {
-    //   port: 3001,
-    // },
-  }),
-]
-
-export default {
-  input,
-  output: {
-    file: 'build/index.js',
-    format: 'umd',
-    name,
-    globals,
-  },
-  plugins,
-}

package/rollup.config.prod.mjs

@@ -1,136 +0,0 @@
-import commonjs from '@rollup/plugin-commonjs'
-import postcss from 'rollup-plugin-postcss'
-import progress from 'rollup-plugin-progress'
-import replace from '@rollup/plugin-replace'
-import { nodeResolve } from '@rollup/plugin-node-resolve'
-import ts from '@rollup/plugin-typescript'
-import { terser } from 'rollup-plugin-terser'
-import typescript from 'typescript'
-import { readFileSync } from 'fs'
-import { fileURLToPath } from 'url'
-import { dirname, resolve } from 'path'
-import replaceBeforeSaveFile from './rollup-plugins/replace-before-save-file.js'
-
-const filename = fileURLToPath(import.meta.url)
-const dirName = dirname(filename)
-
-// Read package.json
-const pkg = JSON.parse(readFileSync(resolve(dirName, './package.json'), 'utf8'))
-
-const input = ['src/index.tsx']
-
-const name = 'ReactTooltip'
-
-const banner = `
-/*
-* React Tooltip
-* {@link https://github.com/ReactTooltip/react-tooltip}
-* @copyright ReactTooltip Team
-* @license MIT
-*/`
-
-const external = [
-  ...Object.keys(pkg.peerDependencies ?? {}),
-  ...Object.keys(pkg.dependencies ?? {}),
-]
-
-const buildFormats = [
-  {
-    file: 'dist/react-tooltip.mjs',
-    format: 'es',
-  },
-  {
-    file: 'dist/react-tooltip.umd.js',
-    format: 'umd',
-    globals: {
-      '@floating-ui/dom': 'FloatingUIDOM',
-      react: 'React',
-      'react-dom': 'ReactDOM',
-      clsx: 'clsx',
-    },
-  },
-  {
-    file: 'dist/react-tooltip.cjs',
-    format: 'cjs',
-  },
-  {
-    file: 'dist/react-tooltip.mjs',
-    format: 'es',
-  },
-]
-
-const sharedPlugins = [
-  progress(),
-  replace({
-    preventAssignment: true,
-    values: {
-      'process.env.NODE_ENV': JSON.stringify('production'),
-    },
-  }),
-  nodeResolve(),
-  ts({
-    typescript,
-    tsconfig: './tsconfig.json',
-    noEmitOnError: false,
-  }),
-  commonjs({
-    include: 'node_modules/**',
-  }),
-]
-// this step is just to build the minified javascript files
-const minifiedBuildFormats = buildFormats.map(({ file, ...rest }) => ({
-  file: file.replace(/(\.[cm]?js)$/, '.min$1'),
-  ...rest,
-  minify: true,
-  plugins: [terser({ compress: { directives: false } })],
-}))
-
-const allBuildFormats = [...buildFormats, ...minifiedBuildFormats]
-
-const config = allBuildFormats.map(
-  ({ file, format, globals, plugins: specificPlugins, minify }) => {
-    const plugins = [
-      ...sharedPlugins,
-      postcss({
-        extract: minify ? 'react-tooltip.min.css' : 'react-tooltip.css', // this will generate a specific file and override on multiples build, but the css will be the same
-        autoModules: true,
-        include: '**/*.css',
-        extensions: ['.css'],
-        plugins: [],
-        minimize: Boolean(minify),
-      }),
-      replaceBeforeSaveFile({
-        // this only works for the react-tooltip.css because it's the first file
-        // writen in our build process before the javascript files.
-        "'react-tooltip-css-placeholder'": 'file:react-tooltip.css',
-        '"react-tooltip-css-placeholder"': 'file:react-tooltip.css',
-        "'react-tooltip-core-css-placeholder'": 'file:react-tooltip.css',
-        '"react-tooltip-core-css-placeholder"': 'file:react-tooltip.css',
-      }),
-    ]
-
-    if (specificPlugins && specificPlugins.length) {
-      plugins.push(...specificPlugins)
-    }
-
-    return {
-      input,
-      output: {
-        file,
-        format,
-        name,
-        globals,
-        sourcemap: true,
-        // Exclude the actual source content from the source map.
-        // This means that the source maps will contain references
-        // to positions in the original code, but not the source code itself.
-        sourcemapExcludeSources: true,
-        banner,
-      },
-      external,
-      plugins,
-    }
-  },
-)
-
-export default config

package/rollup.config.types.mjs

@@ -1,17 +0,0 @@
-import dts from 'rollup-plugin-dts'
-import postcss from 'rollup-plugin-postcss'
-
-export default {
-  input: './src/index.tsx',
-  output: [{ file: 'dist/react-tooltip.d.ts', format: 'es' }],
-  plugins: [
-    postcss({
-      extract: 'react-tooltip-tokens.css', // this will generate a specific file not being used, but we need this part of code
-      autoModules: true,
-      include: '**/*.css',
-      extensions: ['.css'],
-      plugins: [],
-    }),
-    dts(),
-  ],
-}

package/scripts/configure-react-version.mjs

@@ -1,52 +0,0 @@
-import { execSync } from 'node:child_process'
-
-const reactVersion = process.argv[2]
-
-const configs = {
-  '16.14': {
-    react: '16.14.0',
-    reactDom: '16.14.0',
-    typesReact: '^16.14.0',
-    typesReactDom: '^16.9.0',
-    testingLibraryReact: '12.1.5',
-  },
-  '17': {
-    react: '17.0.2',
-    reactDom: '17.0.2',
-    typesReact: '^17.0.0',
-    typesReactDom: '^17.0.0',
-    testingLibraryReact: '12.1.5',
-  },
-  '18': {
-    react: '18.2.0',
-    reactDom: '18.2.0',
-    typesReact: '^18.0.0',
-    typesReactDom: '^18.0.0',
-    testingLibraryReact: '14.3.1',
-  },
-  '19': {
-    react: '19.0.0',
-    reactDom: '19.0.0',
-    typesReact: '^19.0.0',
-    typesReactDom: '^19.0.0',
-    testingLibraryReact: '16.3.0',
-  },
-}
-
-const selected = configs[reactVersion]
-
-if (!selected) {
-  throw new Error(`Unsupported React version "${reactVersion}".`)
-}
-
-const packages = [
-  `react@${selected.react}`,
-  `react-dom@${selected.reactDom}`,
-  `@types/react@${selected.typesReact}`,
-  `@types/react-dom@${selected.typesReactDom}`,
-  `@testing-library/react@${selected.testingLibraryReact}`,
-]
-
-execSync(`yarn add --dev --ignore-scripts --no-lockfile ${packages.join(' ')}`, {
-  stdio: 'inherit',
-})

package/tsconfig.jest.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": [
-    "./global.d.ts",
-    "./src/**/*.ts",
-    "./src/**/*.tsx",
-    "./src/**/*.js",
-    "./src/**/*.jsx"
-  ],
-  "compilerOptions": {
-    "rootDir": ".",
-    "ignoreDeprecations": "6.0"
-  }
-}