@remix-run/ui 0.7.0 → 0.9.0

package/src/runtime/import-map-manager.ts

@@ -0,0 +1,369 @@
+type ImportMap = {
+  imports?: ImportMapImports
+  scopes?: Record<string, ImportMapImports>
+  integrity?: Record<string, string>
+}
+
+type ImportMapAddress = string | null
+type ImportMapImports = Record<string, ImportMapAddress>
+type InstalledImportMapEntry = { href: ImportMapAddress; normalizedHref: ImportMapAddress }
+
+type InstalledImportMap = {
+  imports: Map<string, InstalledImportMapEntry>
+  scopes: Map<string, Map<string, InstalledImportMapEntry>>
+  integrity: Map<string, string>
+}
+
+interface ImportMapManager {
+  consumeImportMaps(source: ParentNode): 'ready' | 'conflict' | 'blocked'
+  disconnect(): void
+  shouldPreserveHeadNode(node: Node): boolean
+}
+
+const MANAGED_IMPORT_MAP_SELECTOR = 'script[data-rmx-import-map][type="importmap"]'
+const IMPORT_MAP_SELECTOR = 'script[type="importmap"]'
+const importMapManagers = new WeakMap<Document, ImportMapManager>()
+
+class ImportMapConflictError extends Error {}
+
+export function getDocumentImportMapManager(doc: Document): ImportMapManager {
+  let manager = importMapManagers.get(doc)
+  if (!manager) {
+    manager = createImportMapManager(doc)
+    importMapManagers.set(doc, manager)
+  }
+  return manager
+}
+
+export function resetDocumentImportMapManager(doc: Document): void {
+  importMapManagers.get(doc)?.disconnect()
+  importMapManagers.delete(doc)
+}
+
+function createImportMapManager(doc: Document): ImportMapManager {
+  let nonce = doc.head.querySelector<HTMLScriptElement>(MANAGED_IMPORT_MAP_SELECTOR)?.nonce
+  let installedImportMap = createInstalledImportMap()
+  let processedScripts = new WeakSet<HTMLScriptElement>()
+  let conflicted = false
+
+  function processImportMap(script: HTMLScriptElement): void {
+    if (processedScripts.has(script)) return
+    processedScripts.add(script)
+
+    let importMap = parseImportMap(script.textContent ?? '')
+    if (importMap) mergeInstalledImportMap(installedImportMap, importMap, script.baseURI)
+  }
+
+  function processImportMaps(): void {
+    for (let script of doc.querySelectorAll<HTMLScriptElement>(IMPORT_MAP_SELECTOR)) {
+      processImportMap(script)
+    }
+  }
+
+  function processMutations(mutations: MutationRecord[]): void {
+    for (let mutation of mutations) {
+      if (mutation.type !== 'childList') continue
+      for (let node of mutation.addedNodes) {
+        if (node instanceof HTMLScriptElement && node.matches(IMPORT_MAP_SELECTOR)) {
+          processImportMap(node)
+        }
+      }
+    }
+  }
+
+  let observer = new MutationObserver(processMutations)
+  observer.observe(doc, { childList: true })
+  observer.observe(doc.head, { childList: true })
+  processImportMaps()
+
+  return {
+    consumeImportMaps(source) {
+      if (conflicted) return 'blocked'
+      processMutations(observer.takeRecords())
+      processImportMaps()
+      let scripts = Array.from(
+        source.querySelectorAll<HTMLScriptElement>(MANAGED_IMPORT_MAP_SELECTOR),
+      )
+      if (scripts.length === 0) return 'ready'
+
+      let pendingImportMap: InstalledImportMap = {
+        imports: new Map(installedImportMap.imports),
+        scopes: new Map(
+          Array.from(installedImportMap.scopes, ([scope, imports]) => [scope, new Map(imports)]),
+        ),
+        integrity: new Map(installedImportMap.integrity),
+      }
+      let deltas: ImportMap[] = []
+      let baseUrl = doc.baseURI
+      try {
+        for (let script of scripts) {
+          let importMap = parseImportMap(script.textContent ?? '')
+          if (!importMap) continue
+          let delta = getImportMapDelta(pendingImportMap, importMap, baseUrl)
+          if (delta) {
+            deltas.push(delta)
+            mergeInstalledImportMap(pendingImportMap, delta, baseUrl)
+          }
+        }
+      } catch (error) {
+        if (!(error instanceof ImportMapConflictError)) throw error
+        console.warn(error.message)
+        conflicted = true
+        return 'conflict'
+      }
+
+      for (let delta of deltas) {
+        let installedScript = appendImportMapScript(doc, delta, nonce)
+        processedScripts.add(installedScript)
+      }
+      installedImportMap = pendingImportMap
+      for (let script of scripts) script.remove()
+      return 'ready'
+    },
+    disconnect() {
+      observer.disconnect()
+    },
+    shouldPreserveHeadNode(node) {
+      return (
+        node.isConnected &&
+        node instanceof HTMLScriptElement &&
+        node.matches(MANAGED_IMPORT_MAP_SELECTOR)
+      )
+    },
+  }
+}
+
+function createInstalledImportMap(): InstalledImportMap {
+  return {
+    imports: new Map(),
+    scopes: new Map(),
+    integrity: new Map(),
+  }
+}
+
+function getImportMapDelta(
+  installedImportMap: InstalledImportMap,
+  importMap: ImportMap,
+  baseUrl: string,
+): ImportMap | undefined {
+  let imports = getImportMapImportsDelta(installedImportMap.imports, importMap.imports, baseUrl)
+  let scopes = getImportMapScopesDelta(installedImportMap, importMap.scopes, baseUrl)
+  let integrity = getImportMapIntegrityDelta(
+    installedImportMap.integrity,
+    importMap.integrity,
+    baseUrl,
+  )
+  if (!imports && !scopes && !integrity) return undefined
+  return {
+    ...(imports ? { imports } : null),
+    ...(scopes ? { scopes } : null),
+    ...(integrity ? { integrity } : null),
+  }
+}
+
+function getImportMapImportsDelta(
+  installedImports: Map<string, InstalledImportMapEntry>,
+  imports: ImportMapImports | undefined,
+  baseUrl: string,
+  scope?: string,
+): ImportMapImports | undefined {
+  if (!imports) return undefined
+
+  let delta: ImportMapImports = {}
+  for (let [specifier, href] of Object.entries(imports)) {
+    let normalizedSpecifier = normalizeImportMapSpecifier(specifier, baseUrl)
+    if (normalizedSpecifier === null) continue
+    let normalizedHref = normalizeImportMapAddress(href, baseUrl)
+    let installedEntry = installedImports.get(normalizedSpecifier)
+    if (installedEntry?.normalizedHref === normalizedHref) continue
+    if (installedEntry) {
+      let scopeDescription = scope ? ` in scope "${scope}"` : ''
+      throw new ImportMapConflictError(
+        `[remix] Reloading page after import map conflict for "${specifier}"${scopeDescription}: ` +
+          `${formatImportMapAddress(installedEntry.href)} is already installed, but the new map points to ${formatImportMapAddress(href)}`,
+      )
+    }
+    delta[specifier] = href
+  }
+
+  return Object.keys(delta).length > 0 ? delta : undefined
+}
+
+function getImportMapScopesDelta(
+  installedImportMap: InstalledImportMap,
+  scopes: Record<string, ImportMapImports> | undefined,
+  baseUrl: string,
+): Record<string, ImportMapImports> | undefined {
+  if (!scopes) return undefined
+
+  let delta: Record<string, ImportMapImports> = {}
+  for (let [scope, imports] of Object.entries(scopes)) {
+    let normalizedScope = normalizeImportMapUrl(scope, baseUrl)
+    if (normalizedScope === null) continue
+    let installedScopeImports = installedImportMap.scopes.get(normalizedScope) ?? new Map()
+    let importsDelta = getImportMapImportsDelta(installedScopeImports, imports, baseUrl, scope)
+    if (importsDelta) delta[scope] = importsDelta
+  }
+
+  return Object.keys(delta).length > 0 ? delta : undefined
+}
+
+function getImportMapIntegrityDelta(
+  installedIntegrity: Map<string, string>,
+  integrity: Record<string, string> | undefined,
+  baseUrl: string,
+): Record<string, string> | undefined {
+  if (!integrity) return undefined
+
+  let delta: Record<string, string> = {}
+  for (let [url, metadata] of Object.entries(integrity)) {
+    let normalizedUrl = normalizeImportMapUrl(url, baseUrl)
+    if (normalizedUrl === null) continue
+    let installedMetadata = installedIntegrity.get(normalizedUrl)
+    if (installedMetadata === metadata) continue
+    if (installedMetadata !== undefined) {
+      throw new ImportMapConflictError(
+        `[remix] Reloading page after import map integrity conflict for "${url}": ` +
+          `"${installedMetadata}" is already installed, but the new map points to "${metadata}"`,
+      )
+    }
+    delta[url] = metadata
+  }
+
+  return Object.keys(delta).length > 0 ? delta : undefined
+}
+
+function mergeInstalledImportMap(
+  installedImportMap: InstalledImportMap,
+  importMap: ImportMap,
+  baseUrl: string,
+): void {
+  mergeInstalledImports(installedImportMap.imports, importMap.imports, baseUrl)
+
+  if (importMap.scopes) {
+    for (let [scope, imports] of Object.entries(importMap.scopes)) {
+      let normalizedScope = normalizeImportMapUrl(scope, baseUrl)
+      if (normalizedScope === null) continue
+      let installedScopeImports = installedImportMap.scopes.get(normalizedScope)
+      if (!installedScopeImports) {
+        installedScopeImports = new Map()
+        installedImportMap.scopes.set(normalizedScope, installedScopeImports)
+      }
+
+      mergeInstalledImports(installedScopeImports, imports, baseUrl)
+    }
+  }
+
+  if (importMap.integrity) {
+    for (let [url, metadata] of Object.entries(importMap.integrity)) {
+      let normalizedUrl = normalizeImportMapUrl(url, baseUrl)
+      if (normalizedUrl === null || installedImportMap.integrity.has(normalizedUrl)) continue
+      installedImportMap.integrity.set(normalizedUrl, metadata)
+    }
+  }
+}
+
+function mergeInstalledImports(
+  installed: Map<string, InstalledImportMapEntry>,
+  imports: ImportMapImports | undefined,
+  baseUrl: string,
+): void {
+  for (let [specifier, href] of Object.entries(imports ?? {})) {
+    let normalizedSpecifier = normalizeImportMapSpecifier(specifier, baseUrl)
+    if (normalizedSpecifier === null || installed.has(normalizedSpecifier)) continue
+    installed.set(normalizedSpecifier, {
+      href,
+      normalizedHref: normalizeImportMapAddress(href, baseUrl),
+    })
+  }
+}
+
+function appendImportMapScript(
+  doc: Document,
+  importMap: ImportMap,
+  nonce: string | undefined,
+): HTMLScriptElement {
+  let script = doc.createElement('script')
+  script.setAttribute('data-rmx-import-map', '')
+  script.type = 'importmap'
+  if (nonce) script.nonce = nonce
+  script.textContent = JSON.stringify(importMap)
+  doc.head.appendChild(script)
+  return script
+}
+
+function parseImportMap(json: string): ImportMap | null {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(json)
+  } catch {
+    return null
+  }
+
+  if (!parsed || typeof parsed !== 'object') return null
+  let importMap: ImportMap = {}
+
+  if ('imports' in parsed) {
+    let imports = parsed.imports
+    if (!isImportMapImports(imports)) return null
+    importMap.imports = imports
+  }
+
+  if ('scopes' in parsed) {
+    let scopes = parsed.scopes
+    if (!isScopedImportMapRecord(scopes)) return null
+    importMap.scopes = scopes
+  }
+
+  if ('integrity' in parsed) {
+    let integrity = parsed.integrity
+    if (!isImportMapIntegrity(integrity)) return null
+    importMap.integrity = integrity
+  }
+
+  return importMap
+}
+
+function isImportMapImports(value: unknown): value is ImportMapImports {
+  if (!value || typeof value !== 'object') return false
+  return Object.values(value).every((entry) => entry === null || typeof entry === 'string')
+}
+
+function isScopedImportMapRecord(value: unknown): value is Record<string, ImportMapImports> {
+  if (!value || typeof value !== 'object') return false
+  return Object.values(value).every(isImportMapImports)
+}
+
+function isImportMapIntegrity(value: unknown): value is Record<string, string> {
+  if (!value || typeof value !== 'object') return false
+  return Object.values(value).every((entry) => typeof entry === 'string')
+}
+
+function normalizeImportMapSpecifier(specifier: string, baseUrl: string): string | null {
+  if (
+    specifier.startsWith('/') ||
+    specifier.startsWith('./') ||
+    specifier.startsWith('../') ||
+    URL.canParse(specifier)
+  ) {
+    return normalizeImportMapUrl(specifier, baseUrl)
+  }
+  return specifier
+}
+
+function normalizeImportMapAddress(address: ImportMapAddress, baseUrl: string): ImportMapAddress {
+  if (address === null) return null
+  return normalizeImportMapUrl(address, baseUrl)
+}
+
+function normalizeImportMapUrl(value: string, baseUrl: string): string | null {
+  try {
+    return new URL(value, baseUrl).href
+  } catch {
+    return null
+  }
+}
+
+function formatImportMapAddress(address: ImportMapAddress | undefined): string {
+  return address === null ? 'null' : `"${address}"`
+}

package/src/runtime/mixins/link-mixin.ts

@@ -34,10 +34,10 @@ export const link: MixinFactory<
         return renderMixinElement(handle.element, {
           ...(props ?? {}),
           href,
-          ...(options?.target == null ? {} : { 'rmx-target': options.target }),
-          ...(options?.src == null ? {} : { 'rmx-src': options.src }),
-          ...(options?.history == null ? {} : { 'rmx-history': options.history }),
-          ...(options?.resetScroll === false ? { 'rmx-reset-scroll': 'false' } : {}),
+          ...(options?.target == null ? {} : { 'data-rmx-target': options.target }),
+          ...(options?.src == null ? {} : { 'data-rmx-src': options.src }),
+          ...(options?.history == null ? {} : { 'data-rmx-history': options.history }),
+          ...(options?.resetScroll === false ? { 'data-rmx-reset-scroll': 'false' } : {}),
         })
       }
 

package/src/runtime/mixins/mixin.ts

@@ -6,6 +6,7 @@ import type { SchedulerPhaseEvent } from '../scheduler.ts'
 import { jsx } from '../jsx.ts'
 import { TypedEventTarget } from '../typed-event-target.ts'
 import { invariant } from '../invariant.ts'
+import { composeMixedProps, isMixinElementFunction } from '../core/mix.ts'
 
 type RebindNode<value, baseNode, boundNode> = value extends (
   ...args: infer fnArgs
@@ -107,6 +108,15 @@ type MixinRuntimeType<
   type: string,
 ) => ((...args: [...args, currentProps: props]) => MixinReturn<node, props>) | void
 
+type MixinDescriptorType<
+  args extends unknown[] = [],
+  node extends EventTarget = Element,
+  props extends ElementProps = ElementProps,
+> = <boundNode extends node>(
+  handle: MixinHandle<boundNode, props>,
+  type: string,
+) => ((...args: [...args, currentProps: props]) => MixinReturn<boundNode, props>) | void
+
 /**
  * Public mixin setup function signature.
  */
@@ -127,7 +137,7 @@ export type MixinDescriptor<
   args extends unknown[] = [],
   props extends ElementProps = ElementProps,
 > = {
-  type: MixinRuntimeType<args, node, props>
+  type: MixinDescriptorType<args, node, props>
   args: args
   readonly __node?: (node: node) => void
 }
@@ -149,13 +159,22 @@ type NestedMixValue<descriptor, depth extends number = 4> = depth extends 0
       | NullableMixValue<descriptor>
       | ReadonlyArray<NestedMixValue<descriptor, PreviousMixDepth[depth]>>
 
+type MixinInputDescriptor<
+  in node extends EventTarget = Element,
+  props extends ElementProps = ElementProps,
+> = {
+  type: (handle: MixinHandle<node, props>, type: string) => unknown
+  args: readonly unknown[]
+  readonly __node?: (node: node) => void
+}
+
 /**
  * Accepted authoring shape for the `mix` prop on host elements.
  */
 export type MixInput<
   node extends EventTarget = Element,
   props extends ElementProps = ElementProps,
-> = NestedMixValue<MixinDescriptor<node, any, props>>
+> = NestedMixValue<MixinInputDescriptor<node, props>>
 
 /**
  * Accepted value shape for the `mix` prop.
@@ -163,7 +182,7 @@ export type MixInput<
 export type MixValue<
   node extends EventTarget = Element,
   props extends ElementProps = ElementProps,
-> = MixinDescriptor<node, any, props> | ReadonlyArray<MixinDescriptor<node, any, props>>
+> = MixinInputDescriptor<node, props> | ReadonlyArray<MixinInputDescriptor<node, props>>
 
 type MixinReturn<node extends EventTarget = Element, props extends ElementProps = ElementProps> =
   | void
@@ -259,16 +278,20 @@ export function createMixin<
   return <boundNode extends node = node>(
     ...args: RebindTuple<args, node, boundNode>
   ): MixinDescriptor<boundNode, RebindTuple<args, node, boundNode>, props> => ({
-    type: type as unknown as MixinRuntimeType<RebindTuple<args, node, boundNode>, boundNode, props>,
+    type: type as unknown as MixinDescriptorType<
+      RebindTuple<args, node, boundNode>,
+      boundNode,
+      props
+    >,
     args: args as RebindTuple<args, node, boundNode>,
   })
 }
 
 export function resolveMixedProps(input: ResolveMixedPropsInput): ResolveMixedPropsOutput {
   let state = input.state ?? createMixinRuntimeState()
-  let handle = state.handle as ScopedAnyMixinHandle | undefined
-  if (!handle) {
-    handle = createMixinHandle({
+  let scopedHandle = state.handle as ScopedAnyMixinHandle | undefined
+  if (!scopedHandle) {
+    scopedHandle = createMixinHandle({
       id: state.id,
       hostType: input.hostType,
       frame: input.frame,
@@ -277,16 +300,14 @@ export function resolveMixedProps(input: ResolveMixedPropsInput): ResolveMixedPr
       getRuntimeSignal: () => getMixinRuntimeSignal(state),
       getBinding: () => state.binding,
     }) as ScopedAnyMixinHandle
-    state.handle = handle
+    state.handle = scopedHandle
   }
+  let handle = scopedHandle
   let hostType = input.hostType
-  let descriptors = resolveMixDescriptors(input.props)
-  let composedProps = withoutMix(input.props)
-  let mixinProps = withoutMixinTreeProps(composedProps)
-  let maxDescriptors = 1024
 
-  for (let index = 0; index < descriptors.length && index < maxDescriptors; index++) {
-    let descriptor = descriptors[index]
+  let runnerCount = 0
+  let props = composeMixedProps(hostType, input.props, (descriptor, index, mixinProps) => {
+    runnerCount = index + 1
     let entry = state.runners[index]
     if (!entry || entry.type !== descriptor.type) {
       if (entry) {
@@ -310,46 +331,15 @@ export function resolveMixedProps(input: ResolveMixedPropsInput): ResolveMixedPr
       }
     }
 
+    // Unlike the server renderer, mixin errors are not isolated here: a
+    // throwing mixin aborts the client render.
     handle.setActiveScope(entry.scope)
     let result = entry.runner(...descriptor.args, mixinProps)
     handle.setActiveScope(undefined)
-    if (!result) continue
-    if (isMixinElement(result)) continue
-
-    let returnedDescriptors = resolveReturnedMixDescriptors(result)
-    if (returnedDescriptors) {
-      for (let returned of returnedDescriptors) descriptors.push(returned)
-      continue
-    }
-
-    if (!isRemixElement(result)) {
-      console.error(new Error('mixins must return a remix element'))
-      continue
-    }
-
-    let resultType =
-      typeof result.type === 'string'
-        ? result.type
-        : isMixinElement(result.type)
-          ? result.type.__rmxMixinElementType
-          : null
-    if (resultType !== hostType) {
-      console.error(new Error('mixins must return an element with the same host type'))
-      continue
-    }
-
-    if (result.type !== resultType) {
-      result = { ...result, type: resultType }
-    }
-
-    let nextProps = sanitizeReturnedMixinProps(result.props)
-    let nestedDescriptors = resolveMixDescriptors(nextProps)
-    for (let nested of nestedDescriptors) descriptors.push(nested)
-    composedProps = composeMixinProps(composedProps, withoutMix(nextProps))
-    mixinProps = withoutMixinTreeProps(composedProps)
-  }
+    return result
+  })
 
-  for (let index = descriptors.length; index < state.runners.length; index++) {
+  for (let index = runnerCount; index < state.runners.length; index++) {
     let entry = state.runners[index]
     if (entry) {
       handle.dispatchScopedEvent(entry.scope, new Event('remove'))
@@ -357,18 +347,11 @@ export function resolveMixedProps(input: ResolveMixedPropsInput): ResolveMixedPr
     }
   }
 
-  if (state.runners.length > descriptors.length) {
-    state.runners.length = descriptors.length
+  if (state.runners.length > runnerCount) {
+    state.runners.length = runnerCount
   }
 
-  let nextMix = input.props.mix
-  return {
-    state,
-    props: {
-      ...composedProps,
-      ...(nextMix === undefined ? {} : { mix: nextMix }),
-    },
-  }
+  return { state, props }
 }
 
 export function teardownMixins(state?: MixinRuntimeState) {
@@ -825,96 +808,8 @@ function isBindingInUpdateScope(binding: MixinRuntimeBinding, parents: ParentNod
   return false
 }
 
-function resolveMixDescriptors(props: ElementProps): AnyMixinDescriptor[] {
-  let mix = props.mix
-  if (!mix) return []
-  if (Array.isArray(mix)) {
-    if (mix.length === 0) return []
-    return mix.filter(Boolean) as AnyMixinDescriptor[]
-  }
-  return [mix] as AnyMixinDescriptor[]
-}
-
-function withoutMix(props: ElementProps): ElementProps {
-  if (!('mix' in props)) return props
-  let output = { ...props }
-  delete output.mix
-  return output
-}
-
-function withoutMixinTreeProps(props: ElementProps): ElementProps {
-  if (!('children' in props) && !('innerHTML' in props)) return props
-  let output = { ...props }
-  delete output.children
-  delete output.innerHTML
-  return output
-}
-
-function sanitizeReturnedMixinProps(props: ElementProps): ElementProps {
-  if (!('children' in props) && !('innerHTML' in props)) return props
-  console.error(new Error('mixins must not return children or innerHTML'))
-  return withoutMixinTreeProps(props)
-}
-
-function composeMixinProps(previous: ElementProps, next: ElementProps): ElementProps {
-  return { ...previous, ...next }
-}
-
-function resolveReturnedMixDescriptors(value: unknown): AnyMixinDescriptor[] | null {
-  let descriptors: AnyMixinDescriptor[] = []
-  if (!collectReturnedMixDescriptors(value, descriptors)) {
-    return null
-  }
-
-  return descriptors
-}
-
-function collectReturnedMixDescriptors(
-  value: unknown,
-  output: AnyMixinDescriptor[],
-): value is MixInput<Element, ElementProps> {
-  if (!value) {
-    return true
-  }
-
-  if (Array.isArray(value)) {
-    for (let item of value) {
-      if (!collectReturnedMixDescriptors(item, output)) {
-        return false
-      }
-    }
-    return true
-  }
-
-  if (!isMixinDescriptor(value)) {
-    return false
-  }
-
-  output.push(value)
-  return true
-}
-
-function isRemixElement(value: unknown): value is RemixElement {
-  if (!value || typeof value !== 'object') return false
-  return (value as { $rmx?: unknown }).$rmx === true
-}
-
-export function isMixinDescriptor(value: unknown): value is AnyMixinDescriptor {
-  if (!value || typeof value !== 'object' || isRemixElement(value)) {
-    return false
-  }
-
-  let descriptor = value as { type?: unknown; args?: unknown }
-  return typeof descriptor.type === 'function' && Array.isArray(descriptor.args)
-}
-
-function isMixinElement(value: unknown): value is MixinElement<Element, ElementProps> {
-  if (typeof value !== 'function') return false
-  return '__rmxMixinElementType' in value
-}
-
 function normalizeMixinRunner(result: AnyMixinSetupResult, handle: AnyMixinHandle): AnyMixinRunner {
-  if (typeof result === 'function' && !isMixinElement(result)) {
+  if (typeof result === 'function' && !isMixinElementFunction(result)) {
     return result as AnyMixinRunner
   }
   if (result === undefined) {

package/src/runtime/mixins/on-mixin.ts

@@ -1,7 +1,7 @@
 import { createMixin, type MixinType } from './mixin.ts'
 import type { ElementProps } from '../jsx.ts'
 import type { MixinDescriptor } from './mixin.ts'
-import type { EnsureEvent, EventMap } from '../event-listeners.ts'
+import type { EnsureEvent, EventMap } from '../event-types.ts'
 
 type SignaledListener<event extends Event> = (
   event: event,