org.scalajs.dom.Event Scala Examples

package io.udash.bindings.inputs

import io.udash._
import org.scalajs.dom.html.{Div, Input => JSInput}
import org.scalajs.dom.{Event, Node}
import scalatags.JsDom.all._

import scala.util.Random

private[inputs] class GroupedButtonsBinding[T](
  options: ReadableSeqProperty[T], decorator: Seq[(JSInput, T)] => Seq[Node], inputModifiers: Modifier*
)(
  inputTpe: String,
  checkedIf: T => ReadableProperty[Boolean],
  refreshSelection: Seq[T] => Unit,
  onChange: (JSInput, T) => Event => Unit
) extends InputBinding[Div] {
  private val groupIdPrefix: Long = Random.nextLong

  private val buttons = div(
    produce(options) { opts =>
      kill()
      refreshSelection(opts)

      decorator(
        opts.zipWithIndex.map { case (opt, idx) =>
          val in = input(
            id := s"$groupIdPrefix-$idx", // default id, can be replaced by `inputModifiers`
            inputModifiers, tpe := inputTpe, value := idx.toString
          ).render

          val selected = checkedIf(opt)
          propertyListeners += selected.listen(in.checked = _, initUpdate = true)
          in.onchange = onChange(in, opt)

          (in, opt)
        }
      )
    }
  ).render

  override def render: Div = buttons
} 

package akkaviz.frontend.components

import org.scalajs.dom.{Element, Event}
import rx.Var

import scalatags.JsDom.all._

class UnconnectedOnOff(status: Var[Boolean]) extends OnOffWithLabel with Component {
  lbl.innerHTML = "Show actors without any connections on graph"
  inp.onchange = { e: Event =>
    status() = inp.checked
  }

  override def attach(parent: Element): Unit = {
    val elem = Seq[Frag](
      div(`class` := "panel-body", stateBtn)
    ).render
    parent.appendChild(elem)
  }
} 

package akkaviz.frontend.components

import org.scalajs.dom.{Event, _}
import rx.{Ctx, Var}

import scalatags.JsDom.all._

class MonitoringOnOff(status: Var[MonitoringStatus]) extends Component with OnOffWithLabel {

  inp.onchange = (d: Event) => {
    status() = Awaiting(Synced(inp.checked))
  }

  val statusTrigger = status.foreach {
    case UnknownYet =>
      lbl.innerHTML = "Awaiting server status"
      inp.disabled = true

    case Awaiting(s) =>
      lbl.innerHTML = s"Awaiting server confirmation for $s"
      inp.disabled = true
      inp.checked = s.asBoolean

    case synced: Synced =>
      inp.checked = synced.asBoolean
      inp.disabled = false
      lbl.innerHTML = s"Monitoring is <b>$synced</b>"

  }

  override def attach(parent: Element): Unit = {
    val elem = Seq[Frag](
      div(`class` := "panel-body", stateBtn)
    ).render

    parent.appendChild(elem)
  }
}

sealed trait MonitoringStatus

sealed trait Synced extends MonitoringStatus {
  def asBoolean: Boolean
}

object Synced {
  def apply(b: Boolean) = if (b) On else Off
}

case object On extends Synced {
  val asBoolean = true
}

case class Awaiting(target: Synced) extends MonitoringStatus

case object Off extends Synced {
  val asBoolean = false
}

case object UnknownYet extends MonitoringStatus 

package io.udash.demos.jquery.views.functions

import io.udash.demos.jquery.views.FunctionView
import io.udash.wrappers.jquery._
import org.scalajs.dom.html.Div
import org.scalajs.dom.{Element, Event}


object OnOneOffView extends FunctionView {

  import scalatags.JsDom.all._

  val onCallback = (_: Element, _: JQueryEvent) =>
    jQ("ul", content).append(li("This will be added on every click").render)
  val oneCallback = (_: Element, _: JQueryEvent) =>
    jQ("ul", content).append(li("This will be added only once").render)

  override protected val content: Div = div(
    h3(".on() & .one() & .off()"),
    button(id := "click", disabled := "disabled")("Click me"),
    ul(),
    button(
      id := "off",
      disabled := "disabled",
      onclick := ((_: Event) => {
        jQ("#click", content)
          .off(EventName.click, onCallback)
          .off(EventName.click, oneCallback)
        false
      })
    )("Off")
  ).render

  override protected def script = () => {
    jQ("#click", content)
      .on(EventName.click, onCallback)
      .one(EventName.click, oneCallback)

    jQ("button", content)
      .prop("disabled", "")
  }
} 

package io.udash.demos.jquery.views.functions

import io.udash.demos.jquery.views.FunctionView
import io.udash.wrappers.jquery._
import org.scalajs.dom.html.Div
import org.scalajs.dom.{Element, Event}


object AttrView extends FunctionView {

  import scalatags.JsDom.all._

  override protected val content: Div = div(
    h3(".attr() & .prop()"),
    input(id := "check1", tpe := "checkbox", checked := "checked"),
    label(`for` := "check1")("Check me"),
    p(),
    button(onclick := ((_: Event) => {
      jQ("input", content).attr("data-checked", "checked").trigger("change")
      false
    }))(".attr(\"data-checked\", \"checked\")"),
    button(onclick := ((_: Event) => {
      jQ("input", content).attr("data-checked", "").trigger("change")
      false
    }))(".attr(\"data-checked\", \"\")"),
    button(onclick := ((_: Event) => {
      jQ("input", content).attr("data-checked", null).trigger("change")
      false
    }))(".attr(\"data-checked\", null)"), br(),
    button(onclick := ((_: Event) => {
      jQ("input", content).prop("checked", true).trigger("change")
      false
    }))(".prop(\"checked\", true)"),
    button(onclick := ((_: Event) => {
      jQ("input", content).prop("checked", false).trigger("change")
      false
    }))(".prop(\"checked\", false)")
  ).render

  override protected def script = () => {
    jQ("input", content).on(EventName.change, (input: Element, _: JQueryEvent) => {
      jQ("p", content).html(
        s""".attr('data-checked'): ${jQ(input).attr("data-checked")}<br/>
           |.prop('checked'): ${jQ(input).prop("checked")}<br/>
           |.is(':checked'): ${jQ(input).is(":checked")}""".stripMargin
      )
    }).trigger("change")
  }
} 

package io.udash.demos.jquery.views.functions

import io.udash.demos.jquery.views.FunctionView
import io.udash.wrappers.jquery._
import org.scalajs.dom.Event

import scala.scalajs.js


object DeferredView extends FunctionView {

  import scalatags.JsDom.all._

  var deferred: JQueryDeferred[js.Function1[Int, js.Any], Int] = null

  override protected val content = div(
    h3("Deferred"),
    div(
      div(id := "deferred")("???"),
      button(
        id := "resolve",
        disabled := "disabled",
        onclick := ((ev: Event) => {
          deferred.resolve(5)
        })
      )("Resolve(5)"),
      button(
        id := "reject",
        disabled := "disabled",
        onclick := ((ev: Event) => {
          deferred.reject(-5)
        })
      )("Reject(-5)"),
      button(
        id := "notify",
        disabled := "disabled",
        onclick := ((ev: Event) => {
          deferred.notify(1)
        })
      )("Notify(1)")
    )
  ).render

  override protected def script = () => {
    jQ("button", content).prop("disabled", "")
    deferred = jQ.deferred[js.Function1[Int, js.Any], Int]()
    jQ("#deferred", content).text(s"Waiting...")
    deferred.done((i: Int) => jQ("#deferred", content).text(s"Done: $i"))
    deferred.fail((i: Int) => jQ("#deferred", content).text(s"Fail: $i"))
    deferred.progress((i: Int) => jQ("#deferred", content).text(s"Progress: $i"))
  }
} 

package io.udash.demos.jquery.views

import org.scalajs.dom.{Element, Event}

abstract class FunctionView {

  import scalatags.JsDom.all._

  protected val content: Element

  protected def script: () => Any

  final def getTemplate: Modifier =
    div(
      content,
      h3(button(
        marginTop := 10.px,
        onclick := ((_: Event) => {
          script()
          false
        })
      )("Run script"))
    )
} 

package org.denigma.threejs.extensions

import org.denigma.threejs.extensions.controls.{ HoverControls, CameraControls }
import org.denigma.threejs.extras.HtmlRenderer
import org.denigma.threejs.{ Scene, WebGLRendererParameters, WebGLRenderer }
import org.scalajs.dom.{ MouseEvent, Event }

import scala.scalajs.js.{ Array, Dynamic }

trait Container3D extends SceneContainer {

  container.style.width = width.toString
  container.style.height = height.toString
  container.style.position = "relative"

  override type RendererType = WebGLRenderer

  val absolute = "absolute"
  val positionZero = "0"

  protected def initRenderer() = {
    val params = Dynamic.literal(
      antialias = true,
      alpha = true // canvas = container
      ).asInstanceOf[WebGLRendererParameters]
    val vr = new WebGLRenderer(params)

    vr.domElement.style.position = absolute
    vr.domElement.style.top = positionZero
    vr.domElement.style.margin = positionZero
    vr.domElement.style.padding = positionZero
    vr.setSize(width, height)
    vr
  }
  val cssScene = new Scene()

  val cssRenderer: HtmlRenderer = this.initCSSRenderer

  protected def initCSSRenderer = {
    val rendererCSS = new HtmlRenderer()
    rendererCSS.setSize(width, height)
    rendererCSS.domElement.style.position = absolute
    rendererCSS.domElement.style.top = positionZero
    rendererCSS.domElement.style.margin = positionZero
    rendererCSS.domElement.style.padding = positionZero
    rendererCSS
  }

  val controls: CameraControls = new HoverControls(camera, this.container)

  container.appendChild(renderer.domElement)
  container.appendChild(cssRenderer.domElement)
  // cssRenderer.domElement.appendChild( renderer.domElement )

  override def onEnterFrame(): Unit = {
    controls.update()
    renderer.render(scene, camera)
    cssRenderer.render(cssScene, camera)
  }

} 

package co.ledger.manager.web.core.idb

import org.scalajs.dom.{ErrorEvent, Event, idb}
import org.scalajs.dom.raw.IDBVersionChangeEvent

import scala.concurrent.{Future, Promise}
import scala.scalajs.js


object IndexedDb {

  def open(databaseName: String, version: Option[Int] = Some(1))(upgradeHandler: (idb.Database, idb.Transaction) => Unit): Future[idb.Database] = {
    val promise = Promise[idb.Database]()
    val request = version match {
      case Some(v) => factory.open(databaseName, v)
      case None => factory.open(databaseName)
    }
    request.onupgradeneeded = {(event: IDBVersionChangeEvent) =>
      val db = event.target.asInstanceOf[js.Dynamic].result.asInstanceOf[idb.Database]
      val transaction = event.currentTarget.asInstanceOf[js.Dynamic].transaction.asInstanceOf[idb.Transaction]
      upgradeHandler(db, transaction)
    }
    request.onblocked = {(event: Event) =>

    }
    request.onsuccess = {(event: Event) =>
      val db = event.target.asInstanceOf[js.Dynamic].result.asInstanceOf[idb.Database]
      promise.success(db)
    }
    request.onerror = {(event: ErrorEvent) =>
      promise.failure(new Exception(event.message))
    }
    promise.future
  }

  def delete(databaseName: String) = {
    factory.deleteDatabase(databaseName)
  }

  private def factory = js.Dynamic.global.indexedDB.asInstanceOf[idb.Factory]

} 

package io.udash.bindings.inputs

import io.udash._
import org.scalajs.dom.Event
import org.scalajs.dom.html.Select
import scalatags.JsDom.all._

private[inputs] class SelectBinding[T](
  options: ReadableSeqProperty[T], label: T => Modifier, selectModifiers: Modifier*
)(
  checkedIf: T => ReadableProperty[Boolean],
  refreshSelection: Seq[T] => Unit,
  onChange: Select => Event => Unit
) extends InputBinding[Select] {
  private val selector = select(selectModifiers)(
    produce(options) { opts =>
      kill()
      refreshSelection(opts)

      opts.zipWithIndex.map { case (opt, idx) =>
        val el = option(value := idx.toString, label(opt)).render

        val selected = checkedIf(opt)
        propertyListeners += selected.listen(el.selected = _, initUpdate = true)
        el
      }
    }
  ).render

  selector.onchange = onChange(selector)

  override def render: Select = selector
} 

package io.udash.bindings.inputs

import io.udash._
import org.scalajs.dom.html.TextArea
import org.scalajs.dom.{Element, Event, KeyboardEvent}
import scalatags.JsDom.all._

import scala.concurrent.duration.{Duration, DurationInt}


  def apply(value: Property[String], debounce: Duration = 20 millis)(textareaModifiers: Modifier*): InputBinding[TextArea] =
    new InputBinding[TextArea] {
      private val element = textarea(
        textareaModifiers, nestedInterceptor(new TextAreaModifier(value, Some(debounce)))
      ).render

      override def render: TextArea = element
    }

  private class TextAreaModifier(property: Property[String], debounce: Option[Duration])
    extends TextInputsModifier(property, debounce)  {

    override def elementValue(t: Element): String =
      t.asInstanceOf[TextArea].value

    override def setElementValue(t: Element, v: String): Unit =
      t.asInstanceOf[TextArea].value = v

    override def setElementKeyUp(t: Element, callback: KeyboardEvent => Unit): Unit =
      t.asInstanceOf[TextArea].onkeyup = callback

    override def setElementOnChange(t: Element, callback: Event => Unit): Unit =
      t.asInstanceOf[TextArea].onchange = callback

    override def setElementOnInput(t: Element, callback: Event => Unit): Unit =
      t.asInstanceOf[TextArea].oninput = callback

    override def setElementOnPaste(t: Element, callback: Event => Unit): Unit =
      t.asInstanceOf[TextArea].onpaste = callback
  }
} 

package io.udash.bindings.inputs

import io.udash._
import org.scalajs.dom.Event
import org.scalajs.dom.html.{Input => JSInput}
import scalatags.JsDom.all._


  def apply(
    property: Property[Double],
    minValue: ReadableProperty[Double] = 0d.toProperty,
    maxValue: ReadableProperty[Double] = 100d.toProperty,
    valueStep: ReadableProperty[Double] = 1d.toProperty
  )(inputModifiers: Modifier*): InputBinding[JSInput] =
    new InputBinding[JSInput] {
      private val element = input(inputModifiers, tpe := "range").render

      element.onchange = (_: Event) => property.set(element.valueAsNumber)
      propertyListeners += property.listen(element.valueAsNumber = _, initUpdate = true)
      propertyListeners += minValue.listen({ v =>
        (min := v).applyTo(element)
        property.set(element.valueAsNumber)
      }, initUpdate = true)
      propertyListeners += maxValue.listen({ v =>
        (max := v).applyTo(element)
        property.set(element.valueAsNumber)
      }, initUpdate = true)
      propertyListeners += valueStep.listen({ v =>
        (step := v).applyTo(element)
        property.set(element.valueAsNumber)
      }, initUpdate = true)

      override def render: JSInput = element
    }
} 

package io.udash.bindings.inputs

import io.udash._
import org.scalajs.dom.html.{Input => JSInput}
import org.scalajs.dom.{Event, File}
import scalatags.JsDom.Modifier
import scalatags.JsDom.all._

object FileInput {

  
  def apply(
    selectedFiles: SeqProperty[File], acceptMultipleFiles: ReadableProperty[Boolean]
  )(inputName: String, inputModifiers: Modifier*): InputBinding[JSInput] = {
    new InputBinding[JSInput] {
      private val in = input(
        inputModifiers, `type` := "file", name := inputName,
        nestedInterceptor((multiple := "multiple").attrIf(acceptMultipleFiles))
      ).render

      in.onchange = (ev: Event) => {
        ev.preventDefault()
        selectedFiles.replace(0, selectedFiles.size, (0 until in.files.length).map { idx => in.files(idx) }: _*)
      }

      override def render: JSInput = in
    }
  }
} 

package io.udash.bindings.inputs

import io.udash._
import io.udash.properties.seq.SeqProperty
import org.scalajs.dom.Event
import org.scalajs.dom.html.Select
import org.scalajs.dom.raw.HTMLOptionElement
import scalatags.JsDom.all._


  def apply[T, ElemType <: Property[T]](
    selectedItems: SeqProperty[T, ElemType], options: ReadableSeqProperty[T]
  )(label: T => Modifier, selectModifiers: Modifier*): InputBinding[Select] = {
    new SelectBinding(options, label, selectModifiers :+ (multiple := true))(
      opt => selectedItems.transform(_.contains(opt)),
      opts => selectedItems.set(selectedItems.get.filter(opts.contains)),
      selector => (_: Event) => {
        val opts = options.get
        val selectedNodes = selector.querySelectorAll("option:checked")
        val selection = (0 until selectedNodes.length).map { idx =>
          opts(selectedNodes(idx).asInstanceOf[HTMLOptionElement].value.toInt)
        }
        selectedItems.set(selection)
      }
    )
  }
} 

package jbok.network.http

import java.nio.ByteBuffer

import cats.effect.{Async, IO}
import org.scalajs.dom.{Blob, Event, FileReader, UIEvent}

import scala.concurrent.Promise
import scala.scalajs.js.typedarray.TypedArrayBufferOps._
import scala.scalajs.js.typedarray._
import scala.scalajs.js.|

trait JsMessageBuilder[F[_], P] {
  import JsMessageBuilder._

  def responseType: String

  def pack(payload: P): Message

  def unpack(msg: Message): F[Option[P]]
}

object JsMessageBuilder {
  type Message = String | ArrayBuffer | Blob

  implicit def JsMessageBuilderString[F[_]](implicit F: Async[F]): JsMessageBuilder[F, String] = new JsMessageBuilder[F, String] {
    val responseType = ""

    def pack(payload: String): Message = payload

    def unpack(msg: Message): F[Option[String]] = (msg: Any) match {
      case s: String => F.pure(Some(s))
      case b: Blob   => readBlob[F, String, String](_.readAsText(b))(identity)
      case _         => F.pure(None)
    }
  }

  implicit def JsMessageBuilderByteBuffer[F[_]](implicit F: Async[F]): JsMessageBuilder[F, ByteBuffer] = new JsMessageBuilder[F, ByteBuffer] {
    val responseType = "arraybuffer"

    def pack(payload: ByteBuffer): Message = payload.arrayBuffer.slice(payload.position, payload.limit)

    def unpack(msg: Message): F[Option[ByteBuffer]] = (msg: Any) match {
      case a: ArrayBuffer => F.pure(Option(TypedArrayBuffer.wrap(a)))
      case b: Blob        => readBlob[F, ArrayBuffer, ByteBuffer](_.readAsArrayBuffer(b))(TypedArrayBuffer.wrap(_))
      case _              => F.pure(None)
    }
  }

  private def readBlob[F[_], R, W](doRead: FileReader => Unit)(conv: R => W)(implicit F: Async[F]): F[Option[W]] = {
    val promise = Promise[Option[W]]()
    val reader  = new FileReader
    reader.onload = (_: UIEvent) => {
      val s = reader.result.asInstanceOf[R]
      promise.success(Option(conv(s)))
    }
    reader.onerror = (_: Event) => {
      promise.success(None)
    }
    doRead(reader)
    F.liftIO(IO.fromFuture(IO(promise.future)))
  }
} 

package io.udash.bindings.inputs

import io.udash._
import io.udash.properties.seq.SeqProperty
import org.scalajs.dom.html.{Div, Input => JSInput}
import org.scalajs.dom.{Event, Node}
import scalatags.JsDom.all._


  def apply[T](
    selectedItems: SeqProperty[T, _ <: ReadableProperty[T]], options: ReadableSeqProperty[T]
  )(decorator: Seq[(JSInput, T)] => Seq[Node], inputModifiers: Modifier*): InputBinding[Div] = {
    new GroupedButtonsBinding(options, decorator, inputModifiers)(
      "checkbox",
      opt => selectedItems.transform(_.contains(opt)),
      opts => selectedItems.set(selectedItems.get.filter(opts.contains)),
      (in: JSInput, opt: T) => (_: Event) => {
        if (in.checked && !selectedItems.get.contains(opt)) selectedItems.append(opt)
        else selectedItems.remove(opt)
      }
    )
  }
} 

package io.udash.bindings.inputs

import io.udash._
import org.scalajs.dom.html.{Div, Input => JSInput}
import org.scalajs.dom.{Event, Node}
import scalatags.JsDom.all._


  def apply[T](
    selectedItem: Property[T], options: ReadableSeqProperty[T]
  )(decorator: Seq[(JSInput, T)] => Seq[Node], inputModifiers: Modifier*): InputBinding[Div] = {
    new GroupedButtonsBinding(options, decorator, inputModifiers)(
      "radio",
      opt => selectedItem.transform(_ == opt),
      opts => if (opts.nonEmpty && !opts.contains(selectedItem.get)) selectedItem.set(opts.head),
      (_: JSInput, opt: T) => (_: Event) => selectedItem.set(opt)
    )
  }
} 

package io.udash.web.guide.views.ext.demo.bootstrap

import io.udash.properties.HasModelPropertyCreator
import io.udash.web.guide.demos.AutoDemo
import io.udash.web.guide.styles.partials.GuideStyles
import scalatags.JsDom.all._

object NavbarDemo extends AutoDemo {

  trait NavbarPanel {
    def title: String

    def content: String
  }

  object NavbarPanel extends HasModelPropertyCreator[NavbarPanel]

  final case class DefaultNavbarPanel(override val title: String, override val content: String) extends NavbarPanel

  private val (rendered, source) = {
    import io.udash._
    import io.udash.bootstrap.nav.{UdashNav, UdashNavbar}
    import io.udash.bootstrap.utils.BootstrapStyles._
    import io.udash.css.CssView._
    import org.scalajs.dom.Event
    import scalatags.JsDom.all._

    

    val panels = SeqProperty[NavbarPanel](
      DefaultNavbarPanel("Title 1", "Content of panel 1..."),
      DefaultNavbarPanel("Title 2", "Content of panel 2..."),
      DefaultNavbarPanel("Title 3", "Content of panel 3..."),
      DefaultNavbarPanel("Title 4", "Content of panel 4...")
    )
    panels.append(
      DefaultNavbarPanel("Title 5", "Content of panel 5...")
    )

    div(
      UdashNavbar()(
        _ => UdashNav(panels)(
          elemFactory = (panel, nested) => a(
            Navigation.link,
            href := "",
            onclick :+= ((_: Event) => true)
          )(
            nested(bind(panel.asModel.subProp(_.title)))
          ).render,
          isActive = el => el.transform(_.title.endsWith("1")),
          isDisabled = el => el.transform(_.title.endsWith("5"))
        ),
        span("Udash"),
      )
    ).render
  }.withSourceCode

  override protected def demoWithSource(): (Modifier, Iterator[String]) = {
    import io.udash.css.CssView._
    (rendered.setup(_.applyTags(GuideStyles.frame)), source.linesIterator)
  }
} 

package io.udash.web.guide.views.ext.demo.bootstrap

import io.udash.properties.HasModelPropertyCreator
import io.udash.web.guide.demos.AutoDemo
import io.udash.web.guide.styles.partials.GuideStyles
import scalatags.JsDom.all._

object NavsDemo extends AutoDemo {

  trait NavPanel {
    def title: String

    def content: String
  }

  object NavPanel extends HasModelPropertyCreator[NavPanel]

  final case class DefaultNavPanel(override val title: String, override val content: String) extends NavPanel

  private val (rendered, source) = {
    import io.udash._
    import io.udash.bootstrap.nav.UdashNav
    import io.udash.bootstrap.utils.BootstrapStyles._
    import io.udash.css.CssView._
    import org.scalajs.dom.Event
    import scalatags.JsDom.all._

    

    val panels = SeqProperty[NavPanel](
      DefaultNavPanel("Title 1", "Content of panel 1..."),
      DefaultNavPanel("Title 2", "Content of panel 2..."),
      DefaultNavPanel("Title 3", "Content of panel 3..."),
      DefaultNavPanel("Title 4", "Content of panel 4...")
    )
    val selected = Property(panels.elemProperties.head.get)
    panels.append(DefaultNavPanel("Title 5", "Content of panel 5..."))

    div(
      UdashNav(panels, justified = true.toProperty, tabs = true.toProperty)(
        elemFactory = (panel, nested) => a(
          Navigation.link,
          href := "",
          onclick :+= ((_: Event) => selected.set(panel.get), true)
        )(nested(bind(panel.asModel.subProp(_.title)))).render,
        isActive = panel => panel.combine(selected)((panel, selected) =>
          panel.title == selected.title
        )
      ),
      div(Card.card, Card.body, Background.color(Color.Light))(
        bind(selected.asModel.subProp(_.content))
      )
    ).render
  }.withSourceCode

  override protected def demoWithSource(): (Modifier, Iterator[String]) = {
    import io.udash.css.CssView._
    (rendered.setup(_.applyTags(GuideStyles.frame)), source.linesIterator)
  }
} 

package io.udash.web.guide.views.ext.demo

import io.udash.properties.single.Property
import io.udash.web.guide.demos.AutoDemo
import io.udash.web.guide.styles.partials.GuideStyles
import scalatags.JsDom.all._

object DynamicRemoteTranslationsDemo extends AutoDemo {

  private val (rendered, source) = {
    import io.udash.bootstrap.utils.BootstrapStyles._
    import io.udash.css.CssView._
    import io.udash.i18n._
    import io.udash.web.guide.Context.serverRpc
    import io.udash.web.guide.demos.i18n.Translations
    import org.scalajs.dom.Event
    import org.scalajs.dom.ext.LocalStorage
    import scalatags.JsDom.all._

    import scala.concurrent.duration.DurationInt

    implicit val translationProvider: RemoteTranslationProvider =
      new RemoteTranslationProvider(
        serverRpc.demos.translations,
        Some(LocalStorage),
        6.hours
      )

    implicit val lang: Property[Lang] = Property(Lang("en"))

    div(
      button(
        Button.btn,
        Button.color(Color.Primary)
      )(id := "enButton", onclick := ((_: Event) => lang.set(Lang("en"))))("EN"), " ",
      button(
        Button.btn,
        Button.color(Color.Primary)
      )(id := "plButton", onclick := ((_: Event) => lang.set(Lang("pl"))))("PL"),
      div(Card.card, Card.body, Background.color(Color.Light), Spacing.margin(
        side = Side.Top,
        size = SpacingSize.Normal
      ))(ul(
        li(
          "auth.loginLabel: ",
          Translations.auth.loginLabel.translatedDynamic()
        ),
        li(
          "auth.passwordLabel: ",
          Translations.auth.passwordLabel.translatedDynamic()
        ),
        li(
          "auth.login.buttonLabel: ",
          Translations.auth.login.buttonLabel.translatedDynamic()
        ),
        li(
          "auth.login.retriesLeft: ",
          Translations.auth.login.retriesLeft(3).translatedDynamic()
        ),
        li(
          "auth.login.retriesLeftOne: ",
          Translations.auth.login.retriesLeftOne.translatedDynamic()
        ),
        li(
          "auth.register.buttonLabel: ",
          Translations.auth.register.buttonLabel.translatedDynamic()
        )
      ))
    )
  }.withSourceCode

  override protected def demoWithSource(): (Modifier, Iterator[String]) = {
    import io.udash.css.CssView._
    (
      div(
        id := "dynamic-rpc-translations-demo",
        GuideStyles.frame,
        GuideStyles.useBootstrap
      )(rendered),
      source.linesIterator
    )
  }
} 

package outwatch.util

import cats.effect.IO
import outwatch.helpers._
import colibri._
import org.scalajs.dom.{Event, MessageEvent}

object WebSocket {
  implicit def toObserver(socket: WebSocket): IO[Observer[String]] = socket.observer
  implicit def toObservable(socket: WebSocket): Observable[MessageEvent] = socket.observable
}

final case class WebSocket private(url: String) {
  val ws = new org.scalajs.dom.WebSocket(url)

  lazy val observable:Observable[MessageEvent] = Observable.create[MessageEvent](observer => {
    ws.onmessage = (e: MessageEvent) => observer.onNext(e)
    ws.onerror = (e: Event) => observer.onError(new Exception(s"Error in WebSocket: $e"))
    Cancelable(() => ws.close())
  })

  lazy val observer:IO[Observer[String]] = {
    IO {
      new Observer[String] {
        override def onNext(elem: String): Unit = ws.send(elem)
        override def onError(ex: Throwable): Unit = OutwatchTracing.errorSubject.onNext(ex)
      }
    }
  }
} 

package com.acework.js.components.bootstrap

import com.acework.js.utils.{TransitionEvent, Mappable, Mergeable}
import japgolly.scalajs.react._
import japgolly.scalajs.react.vdom.prefix_<^._
import org.scalajs.dom.Event

import scala.scalajs.js
import scala.scalajs.js.{UndefOr, undefined}
import Utils._


object TabPane extends BootstrapComponent {
  override type P = TabPane
  override type S = State
  override type B = Backend
  override type N = TopNode

  override def defaultProps = TabPane()

  case class TabPane(active: Boolean = false,
                   animation: Boolean = true,
                   tab: UndefOr[String] = undefined,
                   eventKey: UndefOr[String] = undefined,
                   onAnimateOutEnd: UndefOr[() => Unit] = undefined,
                   bsStyle: UndefOr[Styles.Value] = Styles.default,
                   addClasses: String = "") extends MergeableProps[TabPane] {

    def merge(t: Map[String, Any]): TabPane = implicitly[Mergeable[TabPane]].merge(this, t)

    def asMap: Map[String, Any] = implicitly[Mappable[TabPane]].toMap(this)

    def apply(children: ReactNode*) = component(this, children)

    def apply() = component(this)

  }

  case class State(animateIn: Boolean, animateOut: Boolean)

  class Backend(scope: BackendScope[TabPane, State]) {

    def onComponentWillReceiveProps(nextProps: TabPane) = {
      if (scope.props.animation) {
        if (!scope.state.animateIn && nextProps.active && !scope.props.active)
          scope.modState(_.copy(animateIn = true))
        else if (!scope.state.animateIn && !nextProps.active && scope.props.active)
          scope.modState(_.copy(animateOut = true))
      }
    }

    def onComponentDidUpdate() = {
      if (scope.state.animateIn)
        js.timers.setTimeout(0)(startAnimateIn())
      if (scope.state.animateOut)
        TransitionEvent.addEndEventListener(
          scope.getDOMNode(), (_: Event) => stopAnimateOut()
        )
    }

    def startAnimateIn() = {
      if (scope.isMounted())
        scope.modState(_.copy(animateIn = false))
    }

    def stopAnimateOut() = {
      if (scope.isMounted())
        scope.modState(_.copy(animateOut = false))

      if (scope.props.onAnimateOutEnd.isDefined)
        scope.props.onAnimateOutEnd.get()
    }
  }

  override val component = ReactComponentB[TabPane]("TabPane")
    .initialState(State(animateIn = false, animateOut = false))
    .backend(new Backend(_))
    .render((P, C, S, B) => {
    val classes = Map(
      "active" -> (P.active || S.animateOut),
      "in" -> (P.active && !S.animateIn)
    )
    // FIXME spread props
    <.div(^.classSet1M("tab-pane fade", classes), C)
  })
    .componentWillReceiveProps((scope, nextProps) => {
    scope.backend.onComponentWillReceiveProps(nextProps)
  })
    .componentDidUpdate((scope, prevProps, prevState) => scope.backend.onComponentDidUpdate())
    .build

} 

package jbok.app.components

import com.thoughtworks.binding
import com.thoughtworks.binding.Binding
import org.scalajs.dom.{Element, Event, Node}

object Notification {
  @binding.dom
  def renderInfo(content: Binding[Node], onClick: Event => Unit = (_: Event) => ()): Binding[Element] =
    <div class="notification info">
      <span class="close" onclick={onClick}>&times;</span>
      <strong>Info:</strong>
      <div class="content">{content.bind}</div>
    </div>

  @binding.dom
  def renderSuccess(content: Binding[Element], onClick: Event => Unit = (_: Event) => ()): Binding[Element] =
    <div class="notification success">
      <span class="close" onclick={onClick}>&times;</span>
      <strong>Success:</strong>
      <div class="content">{content.bind}</div>
    </div>

  @binding.dom
  def renderError(content: Binding[Element], onClick: Event => Unit = (_: Event) => ()): Binding[Element] =
    <div class="notification error">
      <span class="close" onclick={onClick}>&times;</span>
      <strong>Error:</strong>
      <div class="content">{content.bind}</div>
    </div>

  @binding.dom
  def renderWarning(content: Binding[Node], onClick: Event => Unit = (_: Event) => ()): Binding[Element] =
    <div class="notification warning">
      <span class="close" onclick={onClick}>&times;</span>
      <strong>Warning:</strong>
      <div class="content">{content.bind}</div>
    </div>
} 

package jbok.app.views

import cats.implicits._
import com.thoughtworks.binding
import com.thoughtworks.binding.Binding
import com.thoughtworks.binding.Binding.Var
import fastparse.Parsed.Failure
import jbok.app.{AppState, Contract}
import jbok.app.components.{Input, Notification}
import jbok.app.helper.InputValidator
import jbok.core.models.Address
import jbok.evm.solidity.SolidityParser
import org.scalajs.dom.{Element, Event}
import scodec.bits.ByteVector

final case class RegisterView(state: AppState) {
  val currentId = state.activeNode.value

  val contractAddress = Input("Address", "address", validator = InputValidator.isValidAddress)
  val contractCode = Input(
    "Code",
    """pragma solidity ^0.4.0;
      |
      |contract SimpleStorage {
      |    uint storedData;
      |
      |    function set(uint x) public {
      |        storedData = x;
      |    }
      |
      |    function get() public view returns (uint) {
      |        return storedData;
      |    }
      |}
    """.stripMargin,
    `type` = "textarea"
  )
  val statusMessage: Var[Option[String]] = Var(None)

  def checkAndGenerateInput() = {
    statusMessage.value = None
    for {
      address <- if (contractAddress.isValid) Right(contractAddress.value) else Left("not valid contract address.")
      code    <- if (contractCode.isValid) Right(contractCode.value) else Left("not valid contract code.")
    } yield _submit(address, code)
  }

  def _submit(address: String, code: String) = {
    val parseResult     = SolidityParser.parseSource(code)
    val contractAddress = Address(ByteVector.fromValidHex(address))
    parseResult.fold(
      (s, i, e) => {
        val msg = s match {
          case "" =>
            "Position " + e.input.prettyIndex(i) +
              ", found " + Failure.formatTrailing(e.input, i)
          case s => Failure.formatMsg(e.input, List(s -> i), i)
        }
        statusMessage.value = Some(s"parse error: ${msg}")
      },
      (r, i) =>
        currentId.foreach(id => {
          state.nodes.value.get(id).foreach(_.contractsABI.value += contractAddress -> Contract(contractAddress, r.ABI.last.methods))
          statusMessage.value = Some("register success.")
        })
    )
  }

  val registerOnClick = (_: Event) => checkAndGenerateInput().leftMap(error => statusMessage.value = Some(error))

  @binding.dom
  def render: Binding[Element] =
    <div>
      <div>
        <label for="address"><b>Address</b></label>
        {contractAddress.render.bind}
      </div>
      <div>
        <label for="code"><b>Address</b></label>
        {contractCode.render.bind}
      </div>

      {
        val onclose = (_: Event) => statusMessage.value = None
        @binding.dom def content(status: String):Binding[Element] =
          <div style="padding-left: 10px">{status}</div>
        statusMessage.bind match {
          case None => <div/>
          case Some(status) if status =="register success." =>
            Notification.renderSuccess(content(status), onclose).bind
          case Some(status) =>
            Notification.renderWarning(content(status), onclose).bind
        }
      }

      <div>
        <button id="register-contract" onclick={registerOnClick} style={"width: 100%"} >register</button>
      </div>
    </div>

} 

package jbok.app.views

import com.thoughtworks.binding
import com.thoughtworks.binding.Binding
import com.thoughtworks.binding.Binding.{Constants, Var}
import jbok.app.AppState
import jbok.app.helper.{ContractAddress, TableRenderHelper}
import jbok.core.api.HistoryTransaction
import jbok.core.models.{Address, UInt256}
import org.scalajs.dom.{Element, Event}

final case class StxsView(state: AppState, stxs: Var[List[HistoryTransaction]]) {
  val header: List[String] = List("Tx Hash", "From", "To", "Value")
  val tableRenderHelper    = TableRenderHelper(header)

  @binding.dom
  def renderTable(stxs: List[HistoryTransaction]): Binding[Element] =
    <table class="table-view">
      {tableRenderHelper.renderTableHeader.bind}
      <tbody>
      {
      for (tx <- Constants(stxs: _*)) yield {
        <tr>
            <td>
              <a onclick={(e: Event) => state.searchTxHash(tx.txHash.toHex)}>
                {tx.txHash.toHex}
              </a>
            </td>
            <td>
              {
          val senderAddress = tx.fromAddress.toString
          <a onclick={(e: Event) => state.searchAccount(senderAddress)}>
                {senderAddress}
              </a>
        }
            </td>
            <td>
            {
          if (tx.toAddress == Address.empty) {
            val contractAddress = ContractAddress.getContractAddress(tx.fromAddress, UInt256(tx.nonce)).toString
            <p>Create Contract: <a onclick={(e: Event) => state.searchAccount(contractAddress)}>{contractAddress}</a></p>
          } else {
            <a onclick={(e: Event) => state.searchAccount(tx.toAddress.toString)}>{tx.toAddress.toString}</a>
          }
        }
            </td>
            <td>
              {tx.value.toString}
            </td>
          </tr>
      }
    }
      </tbody>
    </table>

  @binding.dom
  def render: Binding[Element] =
    <div>
    {
      val history = stxs.bind
      if (history.nonEmpty) {
        renderTable(history).bind
      } else {
        tableRenderHelper.renderEmptyTable.bind
      }
    }
    </div>
} 

package jbok.app.views

import com.thoughtworks.binding
import com.thoughtworks.binding.Binding
import jbok.app.AppState
import org.scalajs.dom.{Event, _}
import org.scalajs.dom.ext.KeyCode
import org.scalajs.dom.raw.HTMLInputElement

final case class SearchBar(state: AppState, onPressEnter: Event => Unit) {
  val keyDownHandler = { event: KeyboardEvent =>
    (event.currentTarget, event.keyCode) match {
      case (input: HTMLInputElement, KeyCode.Enter) =>
        onPressEnter(event)
        input.value.trim match {
          case "" =>
          case text if text.startsWith("#") =>
            val blockNumber = text.substring(1)
            state.searchBlockNumber(blockNumber)
          case text if text.startsWith("0x") =>
            val input = text.substring(2)
            if (input.length <= 40) {
              state.searchAccount(input)
            } else {
              state.searchBlockHash(input)
            }
        }
      case _ =>
    }
  }

  @binding.dom
  def render: Binding[Element] =
    <input type="search" placeholder="Search.." class="searchbar-input" onkeydown={keyDownHandler}></input>
} 

package jbok.app.views

import com.thoughtworks.binding
import com.thoughtworks.binding.Binding
import jbok.app.AppState
import jbok.core.models.SignedTransaction
import org.scalajs.dom.{Element, Event}

object TxView {
  @binding.dom
  def render(state: AppState, tx: SignedTransaction): Binding[Element] =
    <div>
      <h3>{s"Transaction (${tx.hash.toHex})"}</h3>

      <table class="table-view">
        <tbody>
          <tr>
            <th>amount</th>
            <td>{tx.value.toString()}</td>
          </tr>

          <tr>
            <th>from</th>
            <td>
              {
                val senderAddress = tx.senderAddress.getOrElse("error address").toString
                <a onclick={(e: Event) => state.searchAccount(senderAddress)}>{senderAddress}</a>
              }
            </td>
          </tr>

          <tr>
            <th>to</th>
            <td><a onclick={(e: Event) => state.searchAccount(tx.receivingAddress.toString)}>{tx.receivingAddress.toString}</a></td>
          </tr>

          <tr>
            <th>send data</th>
            <td>{tx.payload.toHex}</td>
          </tr>
        </tbody>
      </table>
    </div>
}