utils

export declare function CssSelectors(selectors: ReadonlyArray<string>): CssSelectors

export interface CssSelectors {
  readonly _tag: "css"
  readonly selectors: ReadonlyArray<string>
}

export type DefaultEventMap<T> = T extends Window
  ? WindowEventMap
  : T extends Document
    ? DocumentEventMap
    : T extends HTMLVideoElement
      ? HTMLVideoElementEventMap
      : T extends HTMLMediaElement
        ? HTMLMediaElementEventMap
        : T extends HTMLElement
          ? HTMLElementEventMap
          : T extends SVGElement
            ? SVGElementEventMap
            : T extends Element
              ? ElementEventMap & Readonly<Record<string, Event>>
              : Readonly<Record<string, Event>>

export declare function ElementSelector(element: Element): ElementSelector

export interface ElementSelector {
  readonly _tag: "element"
  readonly element: Element
}

export declare function ElementSource<T extends Rendered, EventMap extends {} = DefaultEventMap<T>>(
  rootElement: RefSubject.Filtered<T>
): ElementSource<T, EventMap>

export interface ElementSource<
  T extends Rendered = Element,
  EventMap extends {} = DefaultEventMap<Rendered.Elements<T>[number]>
> extends Versioned.Versioned<
    never,
    never,
    Rendered.Elements<T>,
    never,
    Scope.Scope,
    Rendered.Elements<T>,
    NoSuchElementException,
    never
  > {
  readonly selector: Selector

  readonly query: {
    <S extends string, Ev extends {} = DefaultEventMap<ParseSelector<S, Element>>>(
      selector: S
    ): ElementSource<ParseSelector<S, Element>, Ev>

    <Target extends Rendered, EventMap extends {} = DefaultEventMap<Target>>(
      rendered: Target
    ): ElementSource<Target, EventMap>
  }

  readonly elements: RefSubject.Filtered<Rendered.Elements<T>>

  readonly events: <Type extends keyof EventMap>(
    type: Type,
    options?: AddEventListenerOptions
  ) => Fx.Fx<EventWithCurrentTarget<Rendered.Elements<T>[number], EventMap[Type]>, never, Scope.Scope>

  readonly dispatchEvent: (event: Event, wait?: DurationInput) => Effect.Effect<void, NoSuchElementException>
}

export type ParseSelector<T extends string, Fallback> = [T] extends [typeof ROOT_CSS_SELECTOR]
  ? Fallback
  : Fallback extends globalThis.Element
    ? Extract<TQS.ParseSelector<T, Fallback>, globalThis.Element>
    : Fallback

export declare const ROOT_CSS_SELECTOR: ":root"

export type Selector = CssSelectors | ElementSelector

export declare function fromElement<T extends Element, EventMap extends {} = DefaultEventMap<T>>(
  rootElement: T
): ElementSource<T, EventMap>

export declare function getElements<T extends Rendered>(element: T): ReadonlyArray<Element>