@adia-ai/web-components 0.2.2 → 0.2.4

package/traits/long-press.js

@@ -0,0 +1,212 @@
+import { defineTrait } from './define.js';
+
+export const longPress = defineTrait({
+  name: 'long-press',
+  category: 'input-interaction',
+  description: 'Press-and-hold trigger: fires after configurable duration with progress events',
+  attributes: [
+    'data-long-press-active',
+    'data-long-press-progress',
+    'data-long-press-fired',
+  ],
+  events: ['long-press', 'long-press-cancelled', 'long-press-progress'],
+  config: [
+    'data-long-press-duration',
+    'data-long-press-tolerance',
+    'data-long-press-progress-interval',
+  ],
+  setup({ host }) {
+    let active = false;
+    let fired = false;
+    let startX = 0;
+    let startY = 0;
+    let startedAt = 0;
+    let timerId = null;
+    let intervalId = null;
+    let suppressClick = false;
+
+    function readDuration() {
+      const v = parseInt(host.getAttribute('data-long-press-duration'), 10);
+      return Number.isFinite(v) && v > 0 ? v : 600;
+    }
+
+    function readTolerance() {
+      const v = parseInt(host.getAttribute('data-long-press-tolerance'), 10);
+      return Number.isFinite(v) && v >= 0 ? v : 8;
+    }
+
+    function readProgressInterval() {
+      const v = parseInt(host.getAttribute('data-long-press-progress-interval'), 10);
+      return Number.isFinite(v) && v > 0 ? v : 50;
+    }
+
+    function isDisabled() {
+      return host.hasAttribute('disabled');
+    }
+
+    function clearTimers() {
+      if (timerId !== null) {
+        clearTimeout(timerId);
+        timerId = null;
+      }
+      if (intervalId !== null) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+    }
+
+    function reset() {
+      active = false;
+      clearTimers();
+      host.removeAttribute('data-long-press-active');
+      host.removeAttribute('data-long-press-progress');
+      host.removeAttribute('data-long-press-fired');
+    }
+
+    function cancel(reason) {
+      if (!active) return;
+      const wasFired = fired;
+      reset();
+      fired = false;
+      // Only the truly-cancelled press emits the cancelled event. A press
+      // that already committed (long-press fired) is a successful close,
+      // not a cancellation, even though the pointerup handler tears down
+      // the same state.
+      if (!wasFired) {
+        host.dispatchEvent(new CustomEvent('long-press-cancelled', {
+          bubbles: true,
+          detail: { reason },
+        }));
+      }
+    }
+
+    function commit() {
+      if (!active || fired) return;
+      fired = true;
+      // Final progress = 1 so consumers reading the attribute see the
+      // completed state before the fired flag flips.
+      host.setAttribute('data-long-press-progress', '1');
+      host.setAttribute('data-long-press-fired', '');
+      // Suppress the next click so consumers don't double-fire on the
+      // pointerup that completes the press.
+      suppressClick = true;
+      host.dispatchEvent(new CustomEvent('long-press', {
+        bubbles: true,
+        detail: { duration: performance.now() - startedAt },
+      }));
+      // Clear interval — duration timer already fired itself.
+      if (intervalId !== null) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+    }
+
+    function onPointerDown(e) {
+      if (isDisabled()) return;
+      if (active) return;
+      active = true;
+      fired = false;
+      startX = e.clientX ?? 0;
+      startY = e.clientY ?? 0;
+      startedAt = performance.now();
+      const duration = readDuration();
+      const interval = readProgressInterval();
+
+      host.setAttribute('data-long-press-active', '');
+      host.setAttribute('data-long-press-progress', '0');
+
+      timerId = setTimeout(commit, duration);
+      intervalId = setInterval(() => {
+        if (!active || fired) return;
+        const elapsed = performance.now() - startedAt;
+        const progress = Math.min(elapsed / duration, 1);
+        host.setAttribute('data-long-press-progress', String(progress));
+        host.dispatchEvent(new CustomEvent('long-press-progress', {
+          bubbles: true,
+          detail: { progress },
+        }));
+      }, interval);
+    }
+
+    function onPointerUp() {
+      if (!active) return;
+      if (fired) {
+        // Successful long-press just completed — reset state silently
+        // without firing cancelled.
+        reset();
+        fired = false;
+        return;
+      }
+      cancel('release');
+    }
+
+    function onPointerLeave() {
+      if (!active) return;
+      if (fired) {
+        // Already committed; pointerleave during the post-fire frame is
+        // benign — clean up without dispatching cancelled.
+        reset();
+        fired = false;
+        return;
+      }
+      cancel('leave');
+    }
+
+    function onPointerMove(e) {
+      if (!active || fired) return;
+      const tolerance = readTolerance();
+      const dx = (e.clientX ?? 0) - startX;
+      const dy = (e.clientY ?? 0) - startY;
+      if (Math.hypot(dx, dy) > tolerance) {
+        cancel('move');
+      }
+    }
+
+    function onPointerCancel() {
+      if (!active) return;
+      cancel('pointer-cancel');
+    }
+
+    function onClick(e) {
+      // The click that follows a successful long-press is suppressed so
+      // consumers wired to both `long-press` and `click` don't double-fire.
+      if (suppressClick) {
+        suppressClick = false;
+        e.stopImmediatePropagation();
+        e.preventDefault();
+      }
+    }
+
+    function onContextMenu(e) {
+      // While a long-press is in flight (typical on touch), suppress the
+      // browser's native context menu so the trait's commit lands cleanly.
+      if (active) {
+        e.preventDefault();
+      }
+    }
+
+    host.addEventListener('pointerdown', onPointerDown);
+    host.addEventListener('pointerup', onPointerUp);
+    host.addEventListener('pointerleave', onPointerLeave);
+    host.addEventListener('pointermove', onPointerMove);
+    host.addEventListener('pointercancel', onPointerCancel);
+    // `click` runs in capture so we beat any consumer-attached click
+    // listener and stop the event before it propagates.
+    host.addEventListener('click', onClick, true);
+    host.addEventListener('contextmenu', onContextMenu);
+
+    return () => {
+      host.removeEventListener('pointerdown', onPointerDown);
+      host.removeEventListener('pointerup', onPointerUp);
+      host.removeEventListener('pointerleave', onPointerLeave);
+      host.removeEventListener('pointermove', onPointerMove);
+      host.removeEventListener('pointercancel', onPointerCancel);
+      host.removeEventListener('click', onClick, true);
+      host.removeEventListener('contextmenu', onContextMenu);
+      clearTimers();
+      host.removeAttribute('data-long-press-active');
+      host.removeAttribute('data-long-press-progress');
+      host.removeAttribute('data-long-press-fired');
+    };
+  },
+});

package/traits/long-press.test.js

@@ -0,0 +1,244 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { longPress } from './long-press.js';
+import { mountHost, connectTrait, spyEvent, resetDOM, wait } from './test-helpers.js';
+
+function pointerDown(host, x = 0, y = 0) {
+  host.dispatchEvent(new PointerEvent('pointerdown', { clientX: x, clientY: y, bubbles: true }));
+}
+function pointerUp(host, x = 0, y = 0) {
+  host.dispatchEvent(new PointerEvent('pointerup', { clientX: x, clientY: y, bubbles: true }));
+}
+function pointerMove(host, x, y) {
+  host.dispatchEvent(new PointerEvent('pointermove', { clientX: x, clientY: y, bubbles: true }));
+}
+function pointerLeave(host) {
+  host.dispatchEvent(new PointerEvent('pointerleave', { bubbles: true }));
+}
+
+describe('long-press', () => {
+  beforeEach(() => {
+    resetDOM();
+    vi.useFakeTimers();
+  });
+
+  it('sets data-long-press-active on pointerdown', () => {
+    const host = mountHost('button', {
+      'data-long-press-duration': '100',
+      'data-long-press-progress-interval': '20',
+    });
+    connectTrait(longPress, host);
+    pointerDown(host);
+    expect(host.hasAttribute('data-long-press-active')).toBe(true);
+    expect(host.getAttribute('data-long-press-progress')).toBe('0');
+  });
+
+  it('fires "long-press" after the configured duration elapses', () => {
+    const host = mountHost('button', {
+      'data-long-press-duration': '100',
+      'data-long-press-progress-interval': '20',
+    });
+    connectTrait(longPress, host);
+    const spy = spyEvent(host, 'long-press');
+    pointerDown(host);
+    vi.advanceTimersByTime(100);
+    expect(spy.count).toBe(1);
+    expect(host.hasAttribute('data-long-press-fired')).toBe(true);
+  });
+
+  it('emits "long-press-progress" at intervals while held', () => {
+    const host = mountHost('button', {
+      'data-long-press-duration': '100',
+      'data-long-press-progress-interval': '20',
+    });
+    connectTrait(longPress, host);
+    const spy = spyEvent(host, 'long-press-progress');
+    pointerDown(host);
+    vi.advanceTimersByTime(60); // 3 ticks at 20ms
+    expect(spy.count).toBeGreaterThanOrEqual(2);
+    // Each tick should report progress in [0, 1].
+    for (const detail of spy.captures) {
+      expect(detail.progress).toBeGreaterThanOrEqual(0);
+      expect(detail.progress).toBeLessThanOrEqual(1);
+    }
+  });
+
+  it('fires "long-press-cancelled" when pointerup arrives early', () => {
+    const host = mountHost('button', {
+      'data-long-press-duration': '200',
+      'data-long-press-progress-interval': '50',
+    });
+    connectTrait(longPress, host);
+    const fireSpy = spyEvent(host, 'long-press');
+    const cancelSpy = spyEvent(host, 'long-press-cancelled');
+    pointerDown(host);
+    vi.advanceTimersByTime(80); // well short of 200
+    pointerUp(host);
+    expect(fireSpy.count).toBe(0);
+    expect(cancelSpy.count).toBe(1);
+    expect(cancelSpy.last.reason).toBe('release');
+  });
+
+  it('fires "long-press-cancelled" on pointerleave', () => {
+    const host = mountHost('button', {
+      'data-long-press-duration': '200',
+    });
+    connectTrait(longPress, host);
+    const cancelSpy = spyEvent(host, 'long-press-cancelled');
+    pointerDown(host);
+    vi.advanceTimersByTime(40);
+    pointerLeave(host);
+    expect(cancelSpy.count).toBe(1);
+    expect(cancelSpy.last.reason).toBe('leave');
+    expect(host.hasAttribute('data-long-press-active')).toBe(false);
+  });
+
+  it('cancels when pointermove exceeds the tolerance', () => {
+    const host = mountHost('button', {
+      'data-long-press-duration': '300',
+      'data-long-press-tolerance': '8',
+    });
+    connectTrait(longPress, host);
+    const cancelSpy = spyEvent(host, 'long-press-cancelled');
+    pointerDown(host, 0, 0);
+    pointerMove(host, 20, 0); // > 8px
+    expect(cancelSpy.count).toBe(1);
+    expect(cancelSpy.last.reason).toBe('move');
+  });
+
+  it('does NOT cancel when pointermove stays within tolerance', () => {
+    const host = mountHost('button', {
+      'data-long-press-duration': '100',
+      'data-long-press-tolerance': '8',
+    });
+    connectTrait(longPress, host);
+    const cancelSpy = spyEvent(host, 'long-press-cancelled');
+    const fireSpy = spyEvent(host, 'long-press');
+    pointerDown(host, 0, 0);
+    pointerMove(host, 5, 5); // hypot ~7.07, under 8
+    vi.advanceTimersByTime(100);
+    expect(cancelSpy.count).toBe(0);
+    expect(fireSpy.count).toBe(1);
+  });
+
+  it('respects [disabled] — no listeners fire, no attributes set', () => {
+    const host = mountHost('button', {
+      disabled: '',
+      'data-long-press-duration': '50',
+    });
+    connectTrait(longPress, host);
+    const fireSpy = spyEvent(host, 'long-press');
+    pointerDown(host);
+    expect(host.hasAttribute('data-long-press-active')).toBe(false);
+    vi.advanceTimersByTime(100);
+    expect(fireSpy.count).toBe(0);
+  });
+
+  it('suppresses the synthetic click that follows a committed long-press', () => {
+    const host = mountHost('button', {
+      'data-long-press-duration': '100',
+    });
+    connectTrait(longPress, host);
+    let clickHits = 0;
+    host.addEventListener('click', () => clickHits++);
+    pointerDown(host);
+    vi.advanceTimersByTime(100);
+    pointerUp(host);
+    host.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+    expect(clickHits).toBe(0);
+  });
+
+  it('does NOT suppress click after a cancelled press', () => {
+    const host = mountHost('button', {
+      'data-long-press-duration': '300',
+    });
+    connectTrait(longPress, host);
+    let clickHits = 0;
+    host.addEventListener('click', () => clickHits++);
+    pointerDown(host);
+    vi.advanceTimersByTime(60);
+    pointerUp(host); // early release → cancelled
+    host.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+    expect(clickHits).toBe(1);
+  });
+
+  it('uses default duration (600ms) when attribute missing', () => {
+    const host = mountHost('button');
+    connectTrait(longPress, host);
+    const spy = spyEvent(host, 'long-press');
+    pointerDown(host);
+    vi.advanceTimersByTime(599);
+    expect(spy.count).toBe(0);
+    vi.advanceTimersByTime(2);
+    expect(spy.count).toBe(1);
+  });
+
+  it('uses default tolerance (8px) when attribute missing', () => {
+    const host = mountHost('button', { 'data-long-press-duration': '300' });
+    connectTrait(longPress, host);
+    const cancelSpy = spyEvent(host, 'long-press-cancelled');
+    pointerDown(host, 0, 0);
+    pointerMove(host, 7, 0); // under default 8
+    expect(cancelSpy.count).toBe(0);
+    pointerMove(host, 9, 0); // over default 8
+    expect(cancelSpy.count).toBe(1);
+  });
+
+  it('disconnect clears active timers + attributes mid-press', () => {
+    const host = mountHost('button', {
+      'data-long-press-duration': '200',
+      'data-long-press-progress-interval': '50',
+    });
+    const inst = connectTrait(longPress, host);
+    pointerDown(host);
+    expect(host.hasAttribute('data-long-press-active')).toBe(true);
+    inst.disconnect(host);
+    expect(host.hasAttribute('data-long-press-active')).toBe(false);
+    expect(host.hasAttribute('data-long-press-progress')).toBe(false);
+    // After disconnect, advancing time must not fire long-press.
+    const fireSpy = spyEvent(host, 'long-press');
+    vi.advanceTimersByTime(500);
+    expect(fireSpy.count).toBe(0);
+  });
+
+  it('reconnect after disconnect picks up fresh state', () => {
+    const host = mountHost('button', {
+      'data-long-press-duration': '100',
+    });
+    const inst = connectTrait(longPress, host);
+    pointerDown(host);
+    inst.disconnect(host);
+
+    connectTrait(longPress, host);
+    const spy = spyEvent(host, 'long-press');
+    pointerDown(host);
+    vi.advanceTimersByTime(100);
+    expect(spy.count).toBe(1);
+  });
+
+  it('schema declares the input-interaction category and full attr/event/config sets', () => {
+    expect(longPress.schema.name).toBe('long-press');
+    expect(longPress.schema.category).toBe('input-interaction');
+    expect(longPress.schema.attributes).toContain('data-long-press-active');
+    expect(longPress.schema.attributes).toContain('data-long-press-progress');
+    expect(longPress.schema.attributes).toContain('data-long-press-fired');
+    expect(longPress.schema.events).toEqual(
+      expect.arrayContaining(['long-press', 'long-press-cancelled', 'long-press-progress']),
+    );
+    expect(longPress.schema.config).toEqual(
+      expect.arrayContaining([
+        'data-long-press-duration',
+        'data-long-press-tolerance',
+        'data-long-press-progress-interval',
+      ]),
+    );
+  });
+
+  it('contextmenu is suppressed while a press is in flight', () => {
+    const host = mountHost('button', { 'data-long-press-duration': '200' });
+    connectTrait(longPress, host);
+    pointerDown(host);
+    const ev = new Event('contextmenu', { bubbles: true, cancelable: true });
+    host.dispatchEvent(ev);
+    expect(ev.defaultPrevented).toBe(true);
+  });
+});

package/traits/magnetic-hover.js

@@ -1,5 +1,5 @@
 import { defineTrait } from './define.js';
-import { prefersReducedMotion } from './_motion.js';
+import { prefersReducedMotion } from './motion.js';
 
 export const magneticHover = defineTrait({
   name: 'magnetic-hover',

package/traits/magnetic-hover.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { magneticHover } from './magnetic-hover.js';
-import { mountHost, connectTrait, resetDOM } from './_test-helpers.js';
+import { mountHost, connectTrait, resetDOM } from './test-helpers.js';
 
 describe('magnetic-hover', () => {
   beforeEach(resetDOM);

package/traits/noise-texture.js

@@ -6,9 +6,14 @@ export const noiseTexture = defineTrait({
   description: 'Procedural grain overlay',
   attributes: ['data-noise-texture-active'],
   events: [],
-  config: [],
+  config: ['data-noise-strength'],
   setup({ host }) {
-    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200"><filter id="n"><feTurbulence type="fractalNoise" baseFrequency="0.65" numOctaves="3" stitchTiles="stitch"/></filter><rect width="100%" height="100%" filter="url(#n)" opacity="0.08"/></svg>`;
+    // Strength governs the SVG rect's opacity (0..1). Default 0.15 — visibly
+    // textured without dominating the underlying surface. Earlier defaults
+    // multiplied the rect opacity (0.08) by the overlay's CSS opacity (0.5)
+    // for an effective 0.04, which read as no-grain.
+    const strength = Math.max(0, Math.min(1, parseFloat(host.getAttribute('data-noise-strength')) || 0.15));
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200"><filter id="n"><feTurbulence type="fractalNoise" baseFrequency="0.65" numOctaves="3" stitchTiles="stitch"/></filter><rect width="100%" height="100%" filter="url(#n)" opacity="${strength}"/></svg>`;
     const encoded = `url("data:image/svg+xml,${encodeURIComponent(svg)}")`;
 
     const overlay = document.createElement('div');
@@ -17,7 +22,6 @@ export const noiseTexture = defineTrait({
       background-image: ${encoded};
       background-repeat: repeat;
       border-radius: inherit;
-      opacity: 0.5;
     `;
 
     host.style.position = host.style.position || 'relative';

package/traits/noise-texture.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { noiseTexture } from './noise-texture.js';
-import { mountHost, connectTrait, resetDOM } from './_test-helpers.js';
+import { mountHost, connectTrait, resetDOM } from './test-helpers.js';
 
 describe('noise-texture', () => {
   beforeEach(resetDOM);

package/traits/parallax.js

@@ -1,5 +1,5 @@
 import { defineTrait } from './define.js';
-import { prefersReducedMotion } from './_motion.js';
+import { prefersReducedMotion } from './motion.js';
 
 export const parallax = defineTrait({
   name: 'parallax',

package/traits/parallax.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { parallax } from './parallax.js';
-import { mountHost, connectTrait, resetDOM } from './_test-helpers.js';
+import { mountHost, connectTrait, resetDOM } from './test-helpers.js';
 
 describe('parallax', () => {
   beforeEach(resetDOM);

package/traits/portal.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { portal } from './portal.js';
-import { mountHost, connectTrait, resetDOM } from './_test-helpers.js';
+import { mountHost, connectTrait, resetDOM } from './test-helpers.js';
 
 describe('portal', () => {
   beforeEach(resetDOM);

package/traits/pressable.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { pressable } from './pressable.js';
-import { mountHost, connectTrait, spyEvent, resetDOM } from './_test-helpers.js';
+import { mountHost, connectTrait, spyEvent, resetDOM } from './test-helpers.js';
 
 describe('pressable', () => {
   beforeEach(resetDOM);

package/traits/resettable.js

@@ -17,12 +17,38 @@ export const resettable = defineTrait({
   events: ['reset-applied'],
   config: [],
   setup({ host }) {
-    const initialValue = host.value ?? host.getAttribute('value') ?? '';
+    // Boolean controls (switch-ui, check-ui, radio-ui) carry their state on
+    // a `checked` reactive prop, not `value`. Detect at connect time so the
+    // captured initial + reset write target the right field.
+    //
+    // Native HTMLInputElement always exposes a `checked` getter regardless
+    // of type, so we can't bareword-check `'checked' in host`. Discriminate
+    // by tag name + native-input type. Custom AdiaUI elements only declare
+    // `checked` when it's their primary state — switch-ui, check-ui,
+    // radio-ui — so the bareword check is safe there.
+    const tag  = host.tagName?.toLowerCase?.() || '';
+    const type = host.getAttribute?.('type') || '';
+    const isNativeInput = tag === 'input';
+    const isNativeCheckable = isNativeInput && (type === 'checkbox' || type === 'radio');
+    const isCustomCheckable = !isNativeInput
+      && 'checked' in host
+      && typeof host.checked === 'boolean';
+    const isCheckable = isNativeCheckable || isCustomCheckable;
+
+    const initialValue = isCheckable
+      ? host.checked
+      : (host.value ?? host.getAttribute('value') ?? '');
+
     const form = host.closest?.('form');
 
     function onReset() {
-      if ('value' in host) host.value = initialValue;
-      else host.setAttribute('value', initialValue);
+      if (isCheckable) {
+        host.checked = initialValue;
+      } else if ('value' in host) {
+        host.value = initialValue;
+      } else {
+        host.setAttribute('value', initialValue);
+      }
       host.dispatchEvent(new CustomEvent('reset-applied', {
         bubbles: true,
         detail: { initialValue },

package/traits/resettable.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { resettable } from './resettable.js';
-import { mountHost, connectTrait, spyEvent, resetDOM } from './_test-helpers.js';
+import { mountHost, connectTrait, spyEvent, resetDOM } from './test-helpers.js';
 
 function mountInForm(initialValue = 'initial') {
   const form = document.createElement('form');
@@ -64,4 +64,37 @@ describe('resettable', () => {
     expect(a.value).toBe('A');
     expect(b.value).toBe('B');
   });
+
+  it('boolean controls (host.checked) restore their initial checked state', () => {
+    // Synthesize a switch-like host: the only state is a boolean `checked`
+    // reactive property — no `value`. Mirrors switch-ui's API.
+    const form = document.createElement('form');
+    document.body.appendChild(form);
+    const host = document.createElement('div');
+    host.checked = true;
+    form.appendChild(host);
+
+    connectTrait(resettable, host);
+    const spy = spyEvent(host, 'reset-applied');
+
+    host.checked = false; // user toggles it off
+    form.dispatchEvent(new Event('reset', { bubbles: true }));
+
+    expect(host.checked).toBe(true);
+    expect(spy.count).toBe(1);
+    expect(spy.last.initialValue).toBe(true);
+  });
+
+  it('boolean controls starting unchecked stay unchecked after reset', () => {
+    const form = document.createElement('form');
+    document.body.appendChild(form);
+    const host = document.createElement('div');
+    host.checked = false;
+    form.appendChild(host);
+
+    connectTrait(resettable, host);
+    host.checked = true;
+    form.dispatchEvent(new Event('reset', { bubbles: true }));
+    expect(host.checked).toBe(false);
+  });
 });

package/traits/resizable.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { resizable } from './resizable.js';
-import { mountHost, connectTrait, resetDOM } from './_test-helpers.js';
+import { mountHost, connectTrait, resetDOM } from './test-helpers.js';
 
 describe('resizable', () => {
   beforeEach(resetDOM);

package/traits/resize-observer.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import { resizeObserver } from './resize-observer.js';
-import { mountHost, connectTrait, resetDOM } from './_test-helpers.js';
+import { mountHost, connectTrait, resetDOM } from './test-helpers.js';
 
 describe('resize-observer', () => {
   let originalRO;

package/traits/ripple.js

@@ -1,5 +1,5 @@
 import { defineTrait } from './define.js';
-import { prefersReducedMotion } from './_motion.js';
+import { prefersReducedMotion } from './motion.js';
 
 export const ripple = defineTrait({
   name: 'ripple',

package/traits/ripple.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { ripple } from './ripple.js';
-import { mountHost, connectTrait, resetDOM } from './_test-helpers.js';
+import { mountHost, connectTrait, resetDOM } from './test-helpers.js';
 
 describe('ripple', () => {
   beforeEach(resetDOM);

package/traits/roving-tabindex.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { rovingTabindex } from './roving-tabindex.js';
-import { mountHost, connectTrait, resetDOM } from './_test-helpers.js';
+import { mountHost, connectTrait, resetDOM } from './test-helpers.js';
 
 function tabbableChild(host) {
   const btn = document.createElement('button');