utils

export type EventOptions = {
  readonly event: string
  readonly selector?: string
  readonly eventInit?: EventInit
}

export type HappyDOMOptions = ConstructorParameters<typeof import("happy-dom").Window>[0]

export interface TestHydrate<E, Elements> extends TestRender<E> {
  readonly elements: Elements
}

export interface TestRender<E> {
  readonly window: Window & GlobalThis
  readonly document: Document
  readonly elementRef: ElementRef.ElementRef
  readonly errors: RefSubject.Computed<ReadonlyArray<E>>
  readonly lastError: RefSubject.Filtered<E>
  readonly interrupt: Effect.Effect<void>
  readonly makeEvent: (type: string, eventInitDict?: EventInit) => Event
  readonly makeCustomEvent: <A>(type: string, eventInitDict?: CustomEventInit<A>) => CustomEvent<A>
  readonly dispatchEvent: (options: EventOptions) => Effect.Effect<void, Cause.NoSuchElementException>
  readonly click: (options?: Omit<EventOptions, "event">) => Effect.Effect<void, Cause.NoSuchElementException>
}

export declare function click<E>(
  rendered: Pick<TestRender<E>, "elementRef" | "makeEvent">,
  options?: Omit<EventOptions, "event">
)

export declare function dispatchEvent<E>(
  { elementRef, makeEvent }: Pick<TestRender<E>, "elementRef" | "makeEvent">,
  options: EventOptions
)

export declare function getOrMakeWindow(
  options?: HappyDOMOptions
): Effect.Effect<Window & GlobalThis, never, Scope.Scope>

export declare function isTemplateEndComment(comment: Comment)

export declare function isTemplateStartComment(comment: Comment)

export declare function stripTypedTemplateComments(html: string)

export declare function testHtmlChunks<E, R>(
  fx: Fx.Fx<RenderEvent, E, R>
): Effect.Effect<
  ReadonlyArray<string>,
  E,
  Scope.Scope | Exclude<R, RenderContext.RenderContext | RenderQueue.RenderQueue | RenderTemplate | CurrentEnvironment>
>

export declare function testHtmlString<E, R>(
  fx: Fx.Fx<RenderEvent, E, R>
): Effect.Effect<
  string,
  E,
  Scope.Scope | Exclude<R, RenderContext.RenderContext | RenderQueue.RenderQueue | RenderTemplate | CurrentEnvironment>
>

export declare function testHydrate<R, E, Elements>(
  fx: Fx.Fx<RenderEvent, E, R>,
  f: (rendered: Rendered, window: Window & GlobalThis) => Elements,
  options?: HappyDOMOptions & {
    readonly [K in keyof DomServicesElementParams]?: (document: Document) => DomServicesElementParams[K]
  }
): Effect.Effect<
  TestHydrate<E, Elements>,
  E,
  | Scope.Scope
  | Exclude<
      R,
      RenderContext.RenderContext | RenderQueue.RenderQueue | RenderTemplate | CurrentEnvironment | DomServices
    >
  | Exclude<R, RenderContext.RenderContext | RenderTemplate | CurrentEnvironment | DomServices>
>

export declare function testRender<E, R>(
  fx: Fx.Fx<RenderEvent, E, R>,
  options?: HappyDOMOptions & {
    readonly [K in keyof DomServicesElementParams]?: (document: Document) => DomServicesElementParams[K]
  } & { renderTimeout?: DurationInput }
): Effect.Effect<
  TestRender<E>,
  never,
  Scope.Scope | Exclude<R, RenderTemplate | RenderContext.RenderContext | CurrentEnvironment | DomServices>
>