Store

implicit abstract def F: ErrorHandler[F]

abstract def _innerHTML: String

abstract def _outerHTML: String

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

abstract def checked: F[Boolean]

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

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

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

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

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

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

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

abstract def classes: Set[String]

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

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

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

abstract def describe: String

abstract def dom: Dom

abstract def enrichErr(msg: String): String

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

abstract def htmlScrub: HtmlScrub

abstract def innerText: String

abstract def isCapable(c: Capability): Boolean

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

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

abstract def parent: F[Self[F, A]]

abstract def peek: Peek[A]

abstract def pos: Pos

abstract def scrubHtml(f: HtmlScrub): Self[F, 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 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): 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]]

def clone(): AnyRef

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]

final def ensureConsistency[B](f: (Store.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

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 def prepare[B](f: (Self[F, A]) ⇒ B): () ⇒ B

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

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