WithStore

implicit abstract val $: CssSelEngine[Dom, Dom]

implicit abstract def F: ErrorHandler[F]

abstract def _innerHTML: String

abstract def _outerHTML: String

abstract def _parent: F[Dom]

abstract def checked: F[Boolean]

abstract def classes: Set[String]

abstract def collect[C[_]](sel: String, C: Container[F, C]): DomCollection[Self, F, C, Dom, A]

abstract def collectChildren[C[_]](desc: String, sel: String, C: Container[F, C]): DomCollection[Self, F, C, Dom, A]

abstract def collectChildren[C[_]](desc: String, C: Container[F, C]): DomCollection[Self, F, C, Dom, A]

abstract def copySelf[G[_]](h: HtmlScrub, g: ErrorHandler[G]): Self[G, A]

abstract def getAttribute(name: String): Option[String]

abstract def htmlScrub: HtmlScrub

abstract def innerText: String

abstract def isCapable(c: Capability): Boolean

abstract val layers: Layers[Dom]

oldest to newest; furthest to closest.

abstract def matches(css: String): F[Boolean]

abstract def newStore[B](pos: Pos, peek: Peek[B]): Self[F, B]

abstract def peek: Peek[A]

abstract def self: Self[F, A]

abstract def tagName: String

abstract def unmap: Self[F, Dom]

abstract def value: F[String]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def addLayer(n: Layer[Dom]): Self[F, A]

final def apply(name: String, sel: String, which: MofN): F[Self[F, A]]

final def apply(name: String, sel: String): F[Self[F, A]]

final def apply(sel: String, which: MofN): F[Self[F, A]]

final def apply(sel: String): F[Self[F, A]]

final def asInstanceOf[T0]: T0

final def child(name: String, sel: String, which: MofN): F[Self[F, A]]

final def child(name: String, sel: String): F[Self[F, A]]

final def child(sel: String, which: MofN): F[Self[F, A]]

final def child(which: MofN = MofN.Sole): F[Self[F, A]]

final def child(sel: String): F[Self[F, A]]

final def children01(sel: String): DomCollection[Self, F, Option, Dom, A]

final def children01: DomCollection[Self, F, Option, Dom, A]

final def children0n(sel: String): DomCollection[Self, F, Vector, Dom, A]

final def children0n: DomCollection[Self, F, Vector, Dom, A]

final def children1n(sel: String): DomCollection[Self, F, Vector, Dom, A]

final def children1n: DomCollection[Self, F, Vector, Dom, A]

def clone(): AnyRef

final def collect01(sel: String): DomCollection[Self, F, Option, Dom, A]

final def collect0n(sel: String): DomCollection[Self, F, Vector, Dom, A]

final def collect1n(sel: String): DomCollection[Self, F, Vector, Dom, A]

final def describe: String

final def dom: Dom

final def duplicate: Self[F, Self[F, A]]

final def editables01: DomCollection[Self, F, Option, Dom, A]

final def editables0n: DomCollection[Self, F, Vector, Dom, A]

final def editables1n: DomCollection[Self, F, Vector, Dom, A]

def enrichErr(msg: String): String

final def ensureConsistency[B](f: (WithStore.this.type) ⇒ B): F[B]

To ensure that DOM doesn't change in the middle of an observation, replace code like...

new Obs($)

$.ensureConsistency(new Obs(_))

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(sel: String, suchThat: (Self[F, A]) ⇒ Boolean): Boolean

def exists(sel: String): Boolean

final def extend[B](f: (Self[F, A]) ⇒ B): Self[F, B]

final def extract: A

final def failBy[G[_]](g: ErrorHandler[G]): Self[G, A]

final def failToEither: Self[[β$0$]Either[String, β$0$], A]

final def failToOption: Self[Option, A]

def finalize(): Unit

def findSelfOrChildWithAttribute(attr: String): F[Option[Self[F, A]]]

final def getClass(): Class[_]

def hashCode(): Int

final def innerHTML: String

final def isInstanceOf[T0]: Boolean

final def map[B](f: (A) ⇒ B): Self[F, B]

final def ne(arg0: AnyRef): Boolean

final def needAttribute(name: String): F[String]

final def newStore[B](peek: Peek[B]): Self[F, B]

final def notify(): Unit

final def notifyAll(): Unit

final def outerHTML: String

final lazy val parent: F[Self[F, A]]

final def pos: Layers[Dom]

final def prepare[B](f: (Self[F, A]) ⇒ B): () ⇒ B

final def runCssQuery(sel: String): CssSelResult[Dom]

final def scrubHtml(f: HtmlScrub): Self[F, A]

final def scrubHtml(f: (String) ⇒ String): Self[F, A]

def selectedOption: F[DomCollection[Self, F, Option, Dom, A]]

The currently selected option in a <select> dropdown.

def selectedOptionText: F[Option[String]]

The text value of the currently selected option in a <select> dropdown.

def startConsistencyCheck(): () ⇒ F[Unit]

To ensure that DOM doesn't change in the middle of an observation, use this pattern:

class Obs($: DomZipper) {

  // Before making any observations...
  private val checkConsistency = $.startConsistencyCheck()

  // ... obs here ...

  // After making all observations...
  checkConsistency()
}

final def synchronized[T0](arg0: ⇒ T0): T0

final def throwErrors: Self[Id, A]

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def describeLoc: String