temp: apply formatter output

Author: PeterDaveHello

tests/unit/components/floating-toolbar-subscriptions.test.mjs

@@ -16,47 +16,30 @@ let dom
 let FloatingToolbar
 const originalDescriptors = new Map()
 const globalNames = ['window', 'document', 'Node', 'HTMLElement']
+const resizeListeners = new Set()
+const selectionListeners = new Set()
 const toolbarContainers = new Set()
 
-const getCapture = (options) =>
-  typeof options === 'boolean' ? options : Boolean(options?.capture)
-
-const createListenerTracker = () => {
-  const registrations = []
-  const matches = (registration, listener, options) =>
-    registration.listener === listener && registration.capture === getCapture(options)
-
-  return {
-    add(listener, options) {
-      if (registrations.some((registration) => matches(registration, listener, options))) return
-      registrations.push({ listener, capture: getCapture(options) })
-    },
-    remove(listener, options) {
-      const index = registrations.findIndex((registration) =>
-        matches(registration, listener, options),
-      )
-      if (index !== -1) registrations.splice(index, 1)
-    },
-    snapshot() {
-      return registrations.map((registration) => ({ ...registration }))
-    },
-    has(target) {
-      return registrations.some(
-        (registration) =>
-          registration.listener === target.listener && registration.capture === target.capture,
-      )
-    },
-    clear() {
-      registrations.length = 0
-    },
-    get size() {
-      return registrations.length
-    },
-  }
+const getCapture = (options) => (typeof options === 'boolean' ? options : Boolean(options?.capture))
+const registrationKey = (listener, capture) => ({ listener, capture })
+const sameRegistration = (registration, listener, capture) =>
+  registration.listener === listener && registration.capture === capture
+const addRegistration = (registrations, listener, options) => {
+  const capture = getCapture(options)
+  if (![...registrations].some((registration) => sameRegistration(registration, listener, capture)))
+    registrations.add(registrationKey(listener, capture))
 }
-
-const resizeListeners = createListenerTracker()
-const selectionListeners = createListenerTracker()
+const removeRegistration = (registrations, listener, options) => {
+  const capture = getCapture(options)
+  const registration = [...registrations].find((entry) =>
+    sameRegistration(entry, listener, capture),
+  )
+  if (registration) registrations.delete(registration)
+}
+const hasRegistration = (registrations, registration) =>
+  [...registrations].some((entry) =>
+    sameRegistration(entry, registration.listener, registration.capture),
+  )
 
 const waitFor = async (predicate, message) => {
   for (let attempt = 0; attempt < 50; ++attempt) {
@@ -66,32 +49,18 @@ const waitFor = async (predicate, message) => {
   assert.fail(message)
 }
 
-const sameListenerRegistration = (left, right) =>
-  left.listener === right.listener && left.capture === right.capture
-
-const getNewListener = (listeners, previousListeners, label) => {
-  const addedListeners = listeners
-    .snapshot()
-    .filter(
-      (listener) =>
-        !previousListeners.some((previousListener) =>
-          sameListenerRegistration(listener, previousListener),
-        ),
-    )
-  assert.equal(addedListeners.length, 1, `expected one new ${label} listener`)
-  return addedListeners[0]
-}
-
-const getNewSetEntry = (entries, previousEntries, label) => {
-  const addedEntries = [...entries].filter((entry) => !previousEntries.has(entry))
-  assert.equal(addedEntries.length, 1, `expected one new ${label} listener`)
-  return addedEntries[0]
+const getNewRegistration = (registrations, previousRegistrations, label) => {
+  const addedRegistrations = [...registrations].filter(
+    (registration) => !hasRegistration(previousRegistrations, registration),
+  )
+  assert.equal(addedRegistrations.length, 1, `expected one new ${label} listener`)
+  return addedRegistrations[0]
 }
 
 const createToolbar = async (id) => {
   const state = globalThis.__FLOATING_SUBSCRIPTION_TEST__
-  const previousResizeListeners = resizeListeners.snapshot()
-  const previousSelectionListeners = selectionListeners.snapshot()
+  const previousResizeListeners = new Set(resizeListeners)
+  const previousSelectionListeners = new Set(selectionListeners)
   const previousStorageListeners = new Set(state.storageListeners)
   const container = document.createElement('div')
   document.body.append(container)
@@ -124,9 +93,9 @@ const createToolbar = async (id) => {
   return {
     container,
     listeners: {
-      resize: getNewListener(resizeListeners, previousResizeListeners, 'resize'),
-      selection: getNewListener(selectionListeners, previousSelectionListeners, 'selection'),
-      storage: getNewSetEntry(state.storageListeners, previousStorageListeners, 'storage'),
+      resize: getNewRegistration(resizeListeners, previousResizeListeners, 'resize'),
+      selection: getNewRegistration(selectionListeners, previousSelectionListeners, 'selection'),
+      storage: getNewRegistration(state.storageListeners, previousStorageListeners, 'storage'),
     },
     close: () => {
       onClose()
@@ -148,22 +117,22 @@ before(async () => {
   const originalWindowAddEventListener = window.addEventListener.bind(window)
   const originalWindowRemoveEventListener = window.removeEventListener.bind(window)
   window.addEventListener = (type, listener, options) => {
-    if (type === 'resize') resizeListeners.add(listener, options)
+    if (type === 'resize') addRegistration(resizeListeners, listener, options)
     return originalWindowAddEventListener(type, listener, options)
   }
   window.removeEventListener = (type, listener, options) => {
-    if (type === 'resize') resizeListeners.remove(listener, options)
+    if (type === 'resize') removeRegistration(resizeListeners, listener, options)
     return originalWindowRemoveEventListener(type, listener, options)
   }
 
   const originalDocumentAddEventListener = document.addEventListener.bind(document)
   const originalDocumentRemoveEventListener = document.removeEventListener.bind(document)
   document.addEventListener = (type, listener, options) => {
-    if (type === 'selectionchange') selectionListeners.add(listener, options)
+    if (type === 'selectionchange') addRegistration(selectionListeners, listener, options)
     return originalDocumentAddEventListener(type, listener, options)
   }
   document.removeEventListener = (type, listener, options) => {
-    if (type === 'selectionchange') selectionListeners.remove(listener, options)
+    if (type === 'selectionchange') removeRegistration(selectionListeners, listener, options)
     return originalDocumentRemoveEventListener(type, listener, options)
   }
 
@@ -199,14 +168,15 @@ after(() => {
   }
 })
 
-test('listener tracking keeps registrations when capture does not match', () => {
+test('listener bookkeeping requires matching capture mode for removal', () => {
   const listener = () => {}
-  window.addEventListener('resize', listener, { capture: true })
-  window.removeEventListener('resize', listener, { capture: false })
+  addRegistration(resizeListeners, listener, { capture: true })
+  removeRegistration(resizeListeners, listener, { capture: false })
 
   assert.equal(resizeListeners.size, 1)
+  assert.equal(hasRegistration(resizeListeners, registrationKey(listener, true)), true)
 
-  window.removeEventListener('resize', listener, { capture: true })
+  removeRegistration(resizeListeners, listener, true)
   assert.equal(resizeListeners.size, 0)
 })
 
@@ -217,8 +187,6 @@ test('closing a floating toolbar removes its real hook subscriptions', async ()
   assert.equal(resizeListeners.size, 1)
   assert.equal(selectionListeners.size, 1)
   assert.equal(state.storageListeners.size, 1)
-  assert.equal(toolbar.listeners.resize.capture, false)
-  assert.equal(toolbar.listeners.selection.capture, false)
 
   act(() => toolbar.close())
 
@@ -241,11 +209,11 @@ test('closing one toolbar leaves another toolbar subscriptions active', async ()
 
   assert.equal(first.container.isConnected, false)
   assert.equal(second.container.isConnected, true)
-  assert.equal(resizeListeners.has(first.listeners.resize), false)
-  assert.equal(selectionListeners.has(first.listeners.selection), false)
+  assert.equal(hasRegistration(resizeListeners, first.listeners.resize), false)
+  assert.equal(hasRegistration(selectionListeners, first.listeners.selection), false)
   assert.equal(state.storageListeners.has(first.listeners.storage), false)
-  assert.equal(resizeListeners.has(second.listeners.resize), true)
-  assert.equal(selectionListeners.has(second.listeners.selection), true)
+  assert.equal(hasRegistration(resizeListeners, second.listeners.resize), true)
+  assert.equal(hasRegistration(selectionListeners, second.listeners.selection), true)
   assert.equal(state.storageListeners.has(second.listeners.storage), true)
 
   act(() => second.close())