@adia-ai/web-components 0.8.19 → 0.8.20

package/traits/dirty-state/dirty-state.test.js

@@ -1,45 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { dirtyState } from './dirty-state.js';
-import { mountHost, connectTrait, resetDOM } from '../test-helpers.js';
-
-describe('dirty-state', () => {
-  beforeEach(resetDOM);
-
-  it('starts in pristine state', () => {
-    const host = mountHost('input', { value: 'initial' });
-    connectTrait(dirtyState, host);
-    expect(host.hasAttribute('data-dirty-state-pristine')).toBe(true);
-    expect(host.hasAttribute('data-dirty-state-dirty')).toBe(false);
-  });
-
-  it('input event with changed value flips to dirty', () => {
-    const host = mountHost('input', { value: 'initial' });
-    connectTrait(dirtyState, host);
-    host.value = 'modified';
-    host.dispatchEvent(new Event('input'));
-    expect(host.hasAttribute('data-dirty-state-dirty')).toBe(true);
-    expect(host.hasAttribute('data-dirty-state-pristine')).toBe(false);
-  });
-
-  it('reverting to initial value flips back to pristine', () => {
-    const host = mountHost('input', { value: 'initial' });
-    connectTrait(dirtyState, host);
-    host.value = 'modified';
-    host.dispatchEvent(new Event('input'));
-    expect(host.hasAttribute('data-dirty-state-dirty')).toBe(true);
-    host.value = 'initial';
-    host.dispatchEvent(new Event('input'));
-    expect(host.hasAttribute('data-dirty-state-pristine')).toBe(true);
-    expect(host.hasAttribute('data-dirty-state-dirty')).toBe(false);
-  });
-
-  it('disconnect clears both state attributes', () => {
-    const host = mountHost('input', { value: 'x' });
-    const inst = connectTrait(dirtyState, host);
-    host.value = 'changed';
-    host.dispatchEvent(new Event('input'));
-    inst.disconnect(host);
-    expect(host.hasAttribute('data-dirty-state-dirty')).toBe(false);
-    expect(host.hasAttribute('data-dirty-state-pristine')).toBe(false);
-  });
-});

package/traits/drag-ghost/drag-ghost.test.js

@@ -1,19 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { dragGhost } from './drag-ghost.js';
-import { mountHost, connectTrait, resetDOM } from '../test-helpers.js';
-
-describe('drag-ghost', () => {
-  beforeEach(resetDOM);
-
-  it('connect attaches without throwing', () => {
-    const host = mountHost();
-    expect(() => connectTrait(dragGhost, host)).not.toThrow();
-  });
-
-  it('disconnect clears the active attribute', () => {
-    const host = mountHost();
-    const inst = connectTrait(dragGhost, host);
-    inst.disconnect(host);
-    expect(host.hasAttribute('data-drag-ghost-active')).toBe(false);
-  });
-});

package/traits/draggable/draggable.test.js

@@ -1,60 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { draggable } from './draggable.js';
-import { mountHost, connectTrait, spyEvent, resetDOM } from '../test-helpers.js';
-
-function pointer(host, type, x, y) {
-  const ev = new PointerEvent(type, { clientX: x, clientY: y, pointerId: 1, bubbles: true });
-  host.dispatchEvent(ev);
-}
-
-describe('draggable', () => {
-  beforeEach(resetDOM);
-
-  it('pointerdown sets data-draggable-dragging', () => {
-    const host = mountHost();
-    connectTrait(draggable, host);
-    pointer(host, 'pointerdown', 10, 10);
-    expect(host.hasAttribute('data-draggable-dragging')).toBe(true);
-  });
-
-  it('pointermove during drag updates translate', () => {
-    const host = mountHost();
-    connectTrait(draggable, host);
-    pointer(host, 'pointerdown', 10, 10);
-    pointer(host, 'pointermove', 30, 50);
-    expect(host.style.translate).toContain('20px');
-    expect(host.style.translate).toContain('40px');
-  });
-
-  it('pointerup fires drag-end with x,y in detail and clears dragging', () => {
-    const host = mountHost();
-    connectTrait(draggable, host);
-    const spy = spyEvent(host, 'drag-end');
-    pointer(host, 'pointerdown', 0, 0);
-    pointer(host, 'pointermove', 25, 75);
-    pointer(host, 'pointerup', 25, 75);
-    expect(host.hasAttribute('data-draggable-dragging')).toBe(false);
-    expect(spy.count).toBe(1);
-    expect(spy.last.x).toBe(25);
-    expect(spy.last.y).toBe(75);
-  });
-
-  it('respects [disabled] — no drag, no event', () => {
-    const host = mountHost('div', { disabled: '' });
-    connectTrait(draggable, host);
-    const spy = spyEvent(host, 'drag-end');
-    pointer(host, 'pointerdown', 0, 0);
-    pointer(host, 'pointermove', 50, 50);
-    pointer(host, 'pointerup', 50, 50);
-    expect(host.hasAttribute('data-draggable-dragging')).toBe(false);
-    expect(spy.count).toBe(0);
-  });
-
-  it('disconnect removes listeners + dragging attribute', () => {
-    const host = mountHost();
-    const inst = connectTrait(draggable, host);
-    pointer(host, 'pointerdown', 0, 0);
-    inst.disconnect(host);
-    expect(host.hasAttribute('data-draggable-dragging')).toBe(false);
-  });
-});

package/traits/draggable-list-item/draggable-list-item.test.js

@@ -1,51 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { draggableListItem } from './draggable-list-item.js';
-import { mountHost, connectTrait, resetDOM } from '../test-helpers.js';
-
-// Minimal smoke coverage. The draggable-list-item trait is the pointer
-// driver for the apps/tasks/ DnD model. The cases
-// below exercise only its own surface (schema, attribute lifecycle,
-// id assignment, idempotent disconnect). Full pointer-flow tests need a
-// laid-out DOM with sibling droppables and live elementFromPoint —
-// those belong with the playground integration suite, not the trait
-// gate.
-
-describe('draggable-list-item', () => {
-  beforeEach(resetDOM);
-
-  it('schema shape is defined', () => {
-    expect(draggableListItem.schema.name).toBe('draggable-list-item');
-    expect(draggableListItem.schema.category).toBe('motion-positioning');
-    expect(draggableListItem.schema.description.length).toBeGreaterThanOrEqual(11);
-    expect(draggableListItem.schema.events).toContain('dnd-lift');
-    expect(draggableListItem.schema.events).toContain('dnd-drop');
-  });
-
-  it('connect assigns an id + sets the host attribute', () => {
-    const host = mountHost('div');
-    connectTrait(draggableListItem, host);
-    expect(host.getAttribute('data-draggable-list-item-id')).toBeTruthy();
-  });
-
-  it('disconnect clears its attributes', () => {
-    const host = mountHost('div');
-    const inst = draggableListItem();
-    inst.connect(host);
-    host.setAttribute('data-draggable-list-item-lifting', '');
-    inst.disconnect(host);
-    expect(host.hasAttribute('data-draggable-list-item-lifting')).toBe(false);
-    expect(host.hasAttribute('data-draggable-list-item-id')).toBe(false);
-  });
-
-  it('reconnect with the same host does not throw', () => {
-    const host = mountHost('div');
-    const inst = draggableListItem();
-    inst.connect(host);
-    inst.disconnect(host);
-    expect(() => {
-      const inst2 = draggableListItem();
-      inst2.connect(host);
-      inst2.disconnect(host);
-    }).not.toThrow();
-  });
-});

package/traits/drop-target/drop-target.test.js

@@ -1,241 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { dropTarget } from './drop-target.js';
-import { mountHost, connectTrait, spyEvent, resetDOM } from '../test-helpers.js';
-
-/**
- * happy-dom's DragEvent constructor does NOT preserve the `dataTransfer`
- * field passed via the init dict (verified at authoring time:
- * `new DragEvent('dragover', { dataTransfer })` then `.dataTransfer`
- * comes back as null). We synthesize the event by creating an Event,
- * then defining `dataTransfer` as a non-enumerable read-only property —
- * the trait reads it the same way the browser would.
- */
-function fireDragEvent(host, type, dataTransfer = null) {
-  const ev = new Event(type, { bubbles: true, cancelable: true });
-  Object.defineProperty(ev, 'dataTransfer', {
-    value: dataTransfer,
-    writable: false,
-    configurable: true,
-  });
-  host.dispatchEvent(ev);
-  return ev;
-}
-
-function fakeDataTransfer({ types = [], items = [] } = {}) {
-  return {
-    types,
-    items,
-    files: items.filter((i) => i.kind === 'file').map((i) => i.file).filter(Boolean),
-    getData: () => '',
-    setData: () => {},
-  };
-}
-
-describe('drop-target', () => {
-  beforeEach(resetDOM);
-
-  it('sets data-drop-target-active on connect, removes on disconnect', () => {
-    const host = mountHost();
-    const inst = connectTrait(dropTarget, host);
-    expect(host.hasAttribute('data-drop-target-active')).toBe(true);
-    inst.disconnect(host);
-    expect(host.hasAttribute('data-drop-target-active')).toBe(false);
-  });
-
-  it('dragenter sets data-drop-target-over and dispatches drop-enter', () => {
-    const host = mountHost();
-    connectTrait(dropTarget, host);
-    const spy = spyEvent(host, 'drop-enter');
-    fireDragEvent(host, 'dragenter', fakeDataTransfer());
-    expect(host.hasAttribute('data-drop-target-over')).toBe(true);
-    expect(spy.count).toBe(1);
-  });
-
-  it('dragleave clears data-drop-target-over and dispatches drop-leave', () => {
-    const host = mountHost();
-    connectTrait(dropTarget, host);
-    const enterSpy = spyEvent(host, 'drop-enter');
-    const leaveSpy = spyEvent(host, 'drop-leave');
-    fireDragEvent(host, 'dragenter', fakeDataTransfer());
-    fireDragEvent(host, 'dragleave', fakeDataTransfer());
-    expect(host.hasAttribute('data-drop-target-over')).toBe(false);
-    expect(enterSpy.count).toBe(1);
-    expect(leaveSpy.count).toBe(1);
-  });
-
-  it('dragenter from descendant nesting only emits one drop-enter', () => {
-    const host = mountHost();
-    connectTrait(dropTarget, host);
-    const enterSpy = spyEvent(host, 'drop-enter');
-    const leaveSpy = spyEvent(host, 'drop-leave');
-    // Two enters (host then descendant) should produce ONE drop-enter
-    // and NOT clear the over-state when one matching leave fires.
-    fireDragEvent(host, 'dragenter', fakeDataTransfer());
-    fireDragEvent(host, 'dragenter', fakeDataTransfer());
-    fireDragEvent(host, 'dragleave', fakeDataTransfer());
-    expect(enterSpy.count).toBe(1);
-    expect(leaveSpy.count).toBe(0);
-    expect(host.hasAttribute('data-drop-target-over')).toBe(true);
-    // The matched leave finally clears.
-    fireDragEvent(host, 'dragleave', fakeDataTransfer());
-    expect(leaveSpy.count).toBe(1);
-    expect(host.hasAttribute('data-drop-target-over')).toBe(false);
-  });
-
-  it('dragover calls preventDefault when no accept filter is set', () => {
-    const host = mountHost();
-    connectTrait(dropTarget, host);
-    const ev = fireDragEvent(host, 'dragover', fakeDataTransfer({ types: ['text/plain'] }));
-    expect(ev.defaultPrevented).toBe(true);
-  });
-
-  it('dragover with empty accept attribute still accepts (preventDefault)', () => {
-    const host = mountHost('div', { 'data-drop-target-accepts': '' });
-    connectTrait(dropTarget, host);
-    const ev = fireDragEvent(host, 'dragover', fakeDataTransfer({ types: ['text/plain'] }));
-    expect(ev.defaultPrevented).toBe(true);
-  });
-
-  it('accepts="files" — accepts file drags, rejects non-file payloads', () => {
-    const host = mountHost('div', { 'data-drop-target-accepts': 'files' });
-    connectTrait(dropTarget, host);
-    const rejectedSpy = spyEvent(host, 'drop-rejected');
-
-    // File drag — Files token present → accepted
-    const fileEv = fireDragEvent(host, 'dragover', fakeDataTransfer({ types: ['Files'] }));
-    expect(fileEv.defaultPrevented).toBe(true);
-    expect(host.hasAttribute('data-drop-target-rejected')).toBe(false);
-
-    // Plain text drag — no Files → rejected, no preventDefault
-    const textEv = fireDragEvent(host, 'dragover', fakeDataTransfer({ types: ['text/plain'] }));
-    expect(textEv.defaultPrevented).toBe(false);
-    expect(host.getAttribute('data-drop-target-rejected')).toBe('files-only');
-    expect(rejectedSpy.count).toBe(1);
-    expect(rejectedSpy.last.reason).toBe('files-only');
-  });
-
-  it('accepts="image/png,image/jpeg" — rejects mismatched MIME types', () => {
-    const host = mountHost('div', { 'data-drop-target-accepts': 'image/png,image/jpeg' });
-    connectTrait(dropTarget, host);
-
-    // Direct text type → rejected
-    const textEv = fireDragEvent(host, 'dragover', fakeDataTransfer({ types: ['text/plain'] }));
-    expect(textEv.defaultPrevented).toBe(false);
-    expect(host.getAttribute('data-drop-target-rejected')).toBe('type');
-
-    // PNG file drag → accepted
-    const pngDt = fakeDataTransfer({
-      types: ['Files'],
-      items: [{ kind: 'file', type: 'image/png' }],
-    });
-    const pngEv = fireDragEvent(host, 'dragover', pngDt);
-    expect(pngEv.defaultPrevented).toBe(true);
-    expect(host.hasAttribute('data-drop-target-rejected')).toBe(false);
-
-    // PDF file drag → rejected
-    const pdfDt = fakeDataTransfer({
-      types: ['Files'],
-      items: [{ kind: 'file', type: 'application/pdf' }],
-    });
-    const pdfEv = fireDragEvent(host, 'dragover', pdfDt);
-    expect(pdfEv.defaultPrevented).toBe(false);
-    expect(host.getAttribute('data-drop-target-rejected')).toBe('type');
-  });
-
-  it('drop dispatches drop-receive with dataTransfer detail', () => {
-    const host = mountHost();
-    connectTrait(dropTarget, host);
-    const spy = spyEvent(host, 'drop-receive');
-    const dt = fakeDataTransfer({ types: ['text/plain'] });
-
-    fireDragEvent(host, 'dragenter', dt);
-    fireDragEvent(host, 'dragover', dt);
-    const dropEv = fireDragEvent(host, 'drop', dt);
-    expect(dropEv.defaultPrevented).toBe(true);
-    expect(spy.count).toBe(1);
-    expect(spy.last.dataTransfer).toBe(dt);
-  });
-
-  it('drop clears data-drop-target-over after firing drop-receive', () => {
-    const host = mountHost();
-    connectTrait(dropTarget, host);
-    const dt = fakeDataTransfer({ types: ['text/plain'] });
-    fireDragEvent(host, 'dragenter', dt);
-    expect(host.hasAttribute('data-drop-target-over')).toBe(true);
-    fireDragEvent(host, 'drop', dt);
-    expect(host.hasAttribute('data-drop-target-over')).toBe(false);
-  });
-
-  it('drop on rejected payload dispatches drop-rejected, not drop-receive', () => {
-    const host = mountHost('div', { 'data-drop-target-accepts': 'image/png' });
-    connectTrait(dropTarget, host);
-    const receiveSpy = spyEvent(host, 'drop-receive');
-    const rejectedSpy = spyEvent(host, 'drop-rejected');
-    const dt = fakeDataTransfer({ types: ['text/plain'] });
-
-    fireDragEvent(host, 'drop', dt);
-    expect(receiveSpy.count).toBe(0);
-    expect(rejectedSpy.count).toBe(1);
-    expect(rejectedSpy.last.reason).toBe('type');
-  });
-
-  it('respects [disabled] — no event, no over-state', () => {
-    const host = mountHost('div', { disabled: '' });
-    connectTrait(dropTarget, host);
-    const enterSpy = spyEvent(host, 'drop-enter');
-    const receiveSpy = spyEvent(host, 'drop-receive');
-
-    fireDragEvent(host, 'dragenter', fakeDataTransfer());
-    fireDragEvent(host, 'dragover', fakeDataTransfer());
-    fireDragEvent(host, 'drop', fakeDataTransfer());
-
-    expect(host.hasAttribute('data-drop-target-over')).toBe(false);
-    expect(enterSpy.count).toBe(0);
-    expect(receiveSpy.count).toBe(0);
-  });
-
-  it('disconnect removes listeners and clears managed attributes', () => {
-    const host = mountHost();
-    const inst = connectTrait(dropTarget, host);
-    fireDragEvent(host, 'dragenter', fakeDataTransfer());
-    expect(host.hasAttribute('data-drop-target-over')).toBe(true);
-    inst.disconnect(host);
-    expect(host.hasAttribute('data-drop-target-over')).toBe(false);
-    expect(host.hasAttribute('data-drop-target-active')).toBe(false);
-    expect(host.hasAttribute('data-drop-target-rejected')).toBe(false);
-
-    // Re-firing post-disconnect is a no-op.
-    const spy = spyEvent(host, 'drop-enter');
-    fireDragEvent(host, 'dragenter', fakeDataTransfer());
-    expect(spy.count).toBe(0);
-  });
-
-  it('clears data-drop-target-rejected when dragover later sees an accepted payload', () => {
-    const host = mountHost('div', { 'data-drop-target-accepts': 'image/png' });
-    connectTrait(dropTarget, host);
-
-    fireDragEvent(host, 'dragover', fakeDataTransfer({ types: ['text/plain'] }));
-    expect(host.getAttribute('data-drop-target-rejected')).toBe('type');
-
-    const pngDt = fakeDataTransfer({
-      types: ['Files'],
-      items: [{ kind: 'file', type: 'image/png' }],
-    });
-    fireDragEvent(host, 'dragover', pngDt);
-    expect(host.hasAttribute('data-drop-target-rejected')).toBe(false);
-  });
-
-  it('dispatches drop-rejected only once per rejection reason on consecutive dragover', () => {
-    const host = mountHost('div', { 'data-drop-target-accepts': 'image/png' });
-    connectTrait(dropTarget, host);
-    const rejectedSpy = spyEvent(host, 'drop-rejected');
-    const dt = fakeDataTransfer({ types: ['text/plain'] });
-
-    // Three consecutive dragover events with the same rejection reason
-    // should emit ONE drop-rejected, not three.
-    fireDragEvent(host, 'dragover', dt);
-    fireDragEvent(host, 'dragover', dt);
-    fireDragEvent(host, 'dragover', dt);
-    expect(rejectedSpy.count).toBe(1);
-  });
-});

package/traits/droppable/droppable.test.js

@@ -1,54 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { droppable } from './droppable.js';
-import { mountHost, connectTrait, resetDOM } from '../test-helpers.js';
-
-// Minimal smoke coverage. The droppable trait is authored against the
-// apps/tasks/ DnD coordinator and assumes a sibling
-// `draggable-list-item` trait dispatches `dnd:drop-target-change` /
-// `dnd:drop` on the document. The cases below only exercise the trait's
-// own surface (schema, attribute lifecycle, registry entry, cleanup) so
-// the verify:traits gate stays green; the higher-fidelity DnD-flow tests
-// belong with the Tasks UI initiative that owns the coordinator.
-
-describe('droppable', () => {
-  beforeEach(resetDOM);
-
-  it('schema shape is defined', () => {
-    expect(droppable.schema.name).toBe('droppable');
-    expect(droppable.schema.category).toBe('input-interaction');
-    expect(droppable.schema.description.length).toBeGreaterThanOrEqual(11);
-    expect(droppable.schema.events).toContain('dnd-drop-enter');
-    // Source-side `dnd-drop` (on document, from the lifter) and target-side
-    // `dnd-drop-receive` (on host) MUST be distinct names — sharing the name
-    // recurses infinitely when the host event bubbles back to the document.
-    expect(droppable.schema.events).toContain('dnd-drop-receive');
-    expect(droppable.schema.events).not.toContain('dnd-drop');
-  });
-
-  it('connect assigns an id + sets the host attribute', () => {
-    const host = mountHost('div');
-    connectTrait(droppable, host);
-    expect(host.getAttribute('data-droppable-id')).toBeTruthy();
-  });
-
-  it('disconnect removes the over attribute if set', () => {
-    const host = mountHost('div');
-    const inst = droppable();
-    inst.connect(host);
-    host.setAttribute('data-droppable-over', '');
-    inst.disconnect(host);
-    expect(host.hasAttribute('data-droppable-over')).toBe(false);
-  });
-
-  it('reconnect with the same host does not throw', () => {
-    const host = mountHost('div');
-    const inst = droppable();
-    inst.connect(host);
-    inst.disconnect(host);
-    expect(() => {
-      const inst2 = droppable();
-      inst2.connect(host);
-      inst2.disconnect(host);
-    }).not.toThrow();
-  });
-});

package/traits/droppable-collection/droppable-collection.test.js

@@ -1,99 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { droppableCollection } from './droppable-collection.js';
-import { mountHost, connectTrait, spyEvent, resetDOM } from '../test-helpers.js';
-
-// Minimal smoke coverage. The droppable-collection trait coordinates
-// child droppables of the apps/tasks/ DnD model;
-// the cases below verify only the trait's own surface (schema, attribute
-// lifecycle, child-drop re-emission) so the verify:traits gate stays
-// green. End-to-end multi-column behavior belongs in the playground tests.
-
-describe('droppable-collection', () => {
-  beforeEach(resetDOM);
-
-  it('schema shape is defined', () => {
-    expect(droppableCollection.schema.name).toBe('droppable-collection');
-    expect(droppableCollection.schema.category).toBe('input-interaction');
-    expect(droppableCollection.schema.description.length).toBeGreaterThanOrEqual(11);
-    expect(droppableCollection.schema.events).toContain('dnd-collection-drop');
-  });
-
-  it('connect sets data-droppable-collection-active', () => {
-    const host = mountHost('div');
-    connectTrait(droppableCollection, host);
-    expect(host.hasAttribute('data-droppable-collection-active')).toBe(true);
-  });
-
-  it('disconnect clears its attributes', () => {
-    const host = mountHost('div');
-    const inst = droppableCollection();
-    inst.connect(host);
-    host.setAttribute('data-droppable-collection-dragging', '');
-    inst.disconnect(host);
-    expect(host.hasAttribute('data-droppable-collection-active')).toBe(false);
-    expect(host.hasAttribute('data-droppable-collection-dragging')).toBe(false);
-  });
-
-  it('re-emits a child dnd-drop-receive as dnd-collection-drop on the host', () => {
-    // The collection listens for the TARGET-side `dnd-drop-receive` (emitted
-    // by the [droppable] trait on its host), NOT the source-side `dnd-drop`
-    // (emitted by the lifter on document). The two events are deliberately
-    // distinct names so that the target re-emit doesn't bubble back into
-    // the lifter's document-level listener and recurse.
-    const host = mountHost('div');
-    const child = document.createElement('div');
-    host.appendChild(child);
-    connectTrait(droppableCollection, host);
-
-    const spy = spyEvent(host, 'dnd-collection-drop');
-    child.dispatchEvent(new CustomEvent('dnd-drop-receive', {
-      bubbles: true,
-      composed: false,
-      detail: {
-        source_id: 't-1',
-        source_index: 0,
-        source_container_id: 'col-a',
-        target_container_id: 'col-b',
-        target_index: 2,
-      },
-    }));
-
-    expect(spy.count).toBe(1);
-    expect(spy.last).toMatchObject({
-      source_id: 't-1',
-      target_container_id: 'col-b',
-      target_index: 2,
-    });
-    spy.cleanup();
-  });
-
-  it('does NOT react to the source-side dnd-drop (would recurse)', () => {
-    // Regression guard: a source-side `dnd-drop` bubbling up from a child
-    // must NOT trigger `dnd-collection-drop`. Only the target-side
-    // `dnd-drop-receive` is the trigger.
-    const host = mountHost('div');
-    const child = document.createElement('div');
-    host.appendChild(child);
-    connectTrait(droppableCollection, host);
-
-    const spy = spyEvent(host, 'dnd-collection-drop');
-    child.dispatchEvent(new CustomEvent('dnd-drop', {
-      bubbles: true,
-      composed: false,
-      detail: { source_id: 't-1', target_container_id: 'col-b', target_index: 0 },
-    }));
-    expect(spy.count).toBe(0);
-    spy.cleanup();
-  });
-
-  it('reflects dragging state from dnd-lift / dnd-drop-cancel', () => {
-    const host = mountHost('div');
-    connectTrait(droppableCollection, host);
-
-    host.dispatchEvent(new CustomEvent('dnd-lift', { bubbles: true, detail: {} }));
-    expect(host.hasAttribute('data-droppable-collection-dragging')).toBe(true);
-
-    host.dispatchEvent(new CustomEvent('dnd-drop-cancel', { bubbles: true, detail: {} }));
-    expect(host.hasAttribute('data-droppable-collection-dragging')).toBe(false);
-  });
-});