scala.scalajs.concurrent.JSExecutionContext.Implicits.queue Scala Examples

package io.udash.benchmarks.i18n

import io.udash.i18n._
import japgolly.scalajs.benchmark._
import japgolly.scalajs.benchmark.gui._

import scala.concurrent.Future
import scalatags.JsDom.all._

object StaticTranslationBinding {

  val instantSuccessTranslations = Benchmark("instant success translation") {
    div(
      (1 to 50).map { _ =>
        span(
          translatedAttr(Future.successful(Translated("Test")), "data-test"),
          translated(Future.successful(Translated("Test")))
        ).render
      }
    ).render
  }

  val futureTranslations = Benchmark("future translation") {
    import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue
    div(
      (1 to 50).map { _ =>
        span(
          translatedAttr(Future(Translated("Test")), "data-test"),
          translated(Future(Translated("Test")))
        ).render
      }
    ).render
  }

  val suite = GuiSuite(
    Suite("StaticTranslations")(
      instantSuccessTranslations,
      futureTranslations
    )
  )
} 

package examplenode

import hammock._
import hammock.marshalling._
import hammock.circe.implicits._
import io.circe.generic.auto._
import cats.effect.IO
import scala.util.{Failure, Success}
import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue
import hammock.fetch.Interpreter._

object Main {
  implicit val cs = IO.contextShift(queue)

  def main(args: Array[String]): Unit = {

    val endpoint = uri"http://www.mocky.io/v2/5185415ba171ea3a00704eed"
    case class Req(name: String, number: Int)
    case class Resp(hello: String)
    val request = Hammock
      .request(Method.POST, endpoint, Map(), Some(Req("name", 4)))
      .as[Resp]
      .exec[IO]
    request.unsafeToFuture.onComplete {
      case Success(resp) => println("hello: " + resp)
      case Failure(ex)   => println(ex)
    }
  }
} 

package io.scalajs.nodejs
package dns

import io.scalajs.util.JSONHelper._
import org.scalatest.FunSpec

import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue
import scala.scalajs.js


class DNSTest extends FunSpec {
  private val domain = "yahoo.com"

  describe("DNS") {

    it("supports lookup") {
      DNS.lookup(domain, (err, ipAddress) => {
        Assert.equal(err, null, err.toJson)
        info(s"lookup - ipAddress: $ipAddress")
      })
    }

    it("supports lookupFuture") {
      DNS.lookupFuture(domain) map { ipAddress =>
        info(s"lookupFuture - ipAddress: $ipAddress")
      }
    }

    it("supports lookupService:SSH") {
      DNS.lookupService("127.0.0.1", 22, (err, hostname, service) => {
        Assert.equal(err, null, err.toJson)
        info(s"lookupService - hostname => $hostname, service => $service")
      })
    }

    it("supports lookupServiceFuture:SSH") {
      DNS.lookupServiceFuture("127.0.0.1", 22) map { case (hostname, service) =>
        info(s"lookupServiceFuture - hostname: $hostname, service => $service")
      }
    }

    it("supports resolve:NS") {
      DNS.resolve(domain, "NS", (err: DnsError, addresses: js.Array[String]) => {
        Assert.equal(err, null, err.toJson)
        info(s"resolve:NS - addresses: ${addresses.mkString(", ")}")
      })
    }

    it("supports resolveFuture:MX") {
      DNS.resolveFuture[js.Array[MX]](domain, RRTYPE_MX) map { response =>
        info(s"resolveFuture:MX - response: ${response.toJson}")
      }
    }

    it("supports resolveFuture:NS") {
      DNS.resolveFuture[js.Array[String]](domain, "NS") map { addresses =>
        info(s"resolveFuture - addresses: ${addresses.mkString(", ")}")
      }
    }

    it("supports resolveFuture:SOA") {
      DNS.resolveFuture[SOA](domain, RRTYPE_SOA) foreach { response =>
        info(s"resolveFuture:SOA: response: ${response.toJson}")
      }
    }

    it("supports reverseFuture") {
      DNS.reverseFuture("216.58.218.142") map { hostnames =>
        info(s"reverseFuture - hostname: ${hostnames.mkString(", ")}")
      }
    }

  }

} 

package spatutorial.client.services

import autowire._
import diode._
import diode.data._
import diode.util._
import diode.react.ReactConnector
import spatutorial.shared.{TodoItem, Api}
import boopickle.Default._
import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue

// Actions
case object RefreshTodos extends Action

case class UpdateAllTodos(todos: Seq[TodoItem]) extends Action

case class UpdateTodo(item: TodoItem) extends Action

case class DeleteTodo(item: TodoItem) extends Action

case class UpdateMotd(potResult: Pot[String] = Empty) extends PotAction[String, UpdateMotd] {
  override def next(value: Pot[String]) = UpdateMotd(value)
}

// The base model of our application
case class RootModel(todos: Pot[Todos], motd: Pot[String])

case class Todos(items: Seq[TodoItem]) {
  def updated(newItem: TodoItem) = {
    items.indexWhere(_.id == newItem.id) match {
      case -1 =>
        // add new
        Todos(items :+ newItem)
      case idx =>
        // replace old
        Todos(items.updated(idx, newItem))
    }
  }
  def remove(item: TodoItem) = Todos(items.filterNot(_ == item))
}


class MotdHandler[M](modelRW: ModelRW[M, Pot[String]]) extends ActionHandler(modelRW) {
  implicit val runner = new RunAfterJS

  override def handle = {
    case action: UpdateMotd =>
      val updateF = action.effect(AjaxClient[Api].welcomeMsg("User X").call())(identity _)
      action.handleWith(this, updateF)(PotAction.handler())
  }
}

// Application circuit
object SPACircuit extends Circuit[RootModel] with ReactConnector[RootModel] {
  // initial application model
  override protected def initialModel = RootModel(Empty, Empty)
  // combine all handlers into one
  override protected val actionHandler = composeHandlers(
    new TodoHandler(zoomRW(_.todos)((m, v) => m.copy(todos = v))),
    new MotdHandler(zoomRW(_.motd)((m, v) => m.copy(motd = v)))
  )
} 

package ch.epfl.scala.index.client
package rpc

import ch.epfl.scala.index.api.{AutocompletionResponse, SearchRequest}
import org.scalajs.dom.ext.Ajax
import play.api.libs.json.{Json, Reads}

import scala.concurrent.Future
import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue

object RPC {
  def autocomplete(
      request: SearchRequest
  ): Future[List[AutocompletionResponse]] = {
    val params = request.toHttpParams
      .map { case (key, value) => s"$key=$value" }
      .mkString("&")

    Ajax
      .get(s"/api/autocomplete?$params")
      .map(_.responseText)
      .map(read[List[AutocompletionResponse]](_))
  }

  private def read[T: Reads](p: String): T = Json.parse(p).as[T]
} 

package chrome.contextMenus

import chrome.ChromeAPI
import chrome.contextMenus.bindings.{CreateProperties, MenuInfo, UpdateProperties}
import chrome.events.EventSource
import chrome.events.EventSourceImplicits._
import chrome.permissions.Permission.API
import chrome.tabs.bindings.Tab

import scala.concurrent.{Future, Promise}
import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue
import scala.scalajs.js
import scala.scalajs.js.|

object ContextMenus extends ChromeAPI {

  def onClicked: EventSource[(MenuInfo, Tab)] = bindings.ContextMenus.onClicked

  val requiredPermissions: Set[API] = Set(API.ContextMenus)

  def create(createProperties: CreateProperties): String | Int =
    bindings.ContextMenus.create(createProperties)

  def create(id: String, title: String, contexts: List[String]): String | Int =
    create(
        bindings
          .CreateProperties(id, title, contexts = js.Array(contexts: _*)))

  def update(id: String | Int, properties: UpdateProperties): Unit =
    bindings.ContextMenus.update(id, properties)

  def remove(menuItemId: String | Int): Future[String | Int] = {
    val promise = Promise[Unit]
    val result = bindings.ContextMenus
      .remove(menuItemId, js.Any.fromFunction0[Unit](() => {
        promise.success(Unit)
      }))
    promise.future.map(_ => result)
  }

  def removeAll(): Future[Unit] = {
    val promise = Promise[Unit]
    bindings.ContextMenus.removeAll(js.Any.fromFunction0[Unit](() => {
      promise.success(Unit)
    }))
    promise.future
  }

} 

package chrome.sockets.tcpServer

import chrome.events.EventSource
import chrome.sockets.tcp
import chrome.sockets.tcpServer.bindings._

import scala.concurrent.Future
import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue
import scala.scalajs.js

class Socket(val socketId: SocketId) {

  val onAccept = TCPServer.onAccept
    .filter(_.socketId == socketId)
    .map(event => Socket.Accepted(tcp.Socket(event.clientSocketId)))
  val onAcceptError = TCPServer.onAcceptError
    .filter(_.socketId == socketId)
    .map(event => Socket.Error(event.resultCode))
  val all: EventSource[Socket.AcceptEvent] = onAccept.merge(onAcceptError)

  def update(properties: SocketProperties): Future[Unit] = {
    TCPServer.update(socketId, properties)
  }

  def setPaused(paused: Boolean): Future[Unit] = {
    TCPServer.setPaused(socketId, paused)
  }

  def listen(address: String,
             port: Int,
             backlog: js.UndefOr[Int] = js.undefined): Future[Int] = {
    TCPServer.listen(socketId, address, port, backlog)
  }

  def disconnect: Future[Unit] = {
    TCPServer.disconnect(socketId)
  }

  def close: Future[Unit] = {
    TCPServer.close(socketId)
  }

  def getInfo: Future[SocketInfo] = {
    TCPServer.getInfo(socketId)
  }

}

object Socket {

  sealed trait AcceptEvent
  case class Accepted(client: chrome.sockets.tcp.Socket) extends AcceptEvent
  case class Error(code: Int) extends AcceptEvent

  def apply(id: SocketId): Socket = new Socket(id)

  def apply(name: String = "", persistent: Boolean): Future[Socket] = {
    TCPServer
      .create(SocketProperties(persistent, name))
      .map(i => Socket(i.socketId))
  }

} 

package chrome.sockets.tcp

import chrome.events.EventSource
import chrome.sockets.tcp.bindings._

import scala.concurrent.Future
import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue
import scala.scalajs.js
import scala.scalajs.js.typedarray.ArrayBuffer

class Socket(val socketId: SocketId) {

  val onReceive = TCP.onReceive
    .filter(_.socketId == socketId)
    .map((event) => Socket.Received(event.data))
  val onReceiveError = TCP.onReceiveError
    .filter(_.socketId == socketId)
    .map((event) => Socket.Error(event.resultCode))
  val all: EventSource[Socket.ReceiveEvent] = onReceive.merge(onReceiveError)

  def update(properties: SocketProperties): Future[Unit] = {
    TCP.update(socketId, properties)
  }

  def setPaused(paused: Boolean): Future[Unit] = {
    TCP.setPaused(socketId, paused)
  }

  def setKeepAlive(enable: Boolean,
                   delay: js.UndefOr[Int] = js.undefined): Future[Int] = {
    TCP.setKeepAlive(socketId, enable, delay)
  }

  def setNoDelay(noDelay: Boolean): Future[Int] = {
    TCP.setNoDelay(socketId, noDelay)
  }

  def connect(peerAddress: String, peerPort: Int): Future[Int] = {
    TCP.connect(socketId, peerAddress, peerPort)
  }

  def disconnect: Future[Unit] = {
    TCP.disconnect(socketId)
  }

  def secure(options: js.UndefOr[SecureOptions]): Future[Unit] = {
    TCP.secure(socketId, options)
  }

  def send(data: ArrayBuffer): Future[SendInfo] = {
    TCP.send(socketId, data)
  }

  def close: Future[Unit] = {
    TCP.close(socketId)
  }

  def getInfo: Future[SocketInfo] = {
    TCP.getInfo(socketId)
  }

}

object Socket {

  sealed trait ReceiveEvent
  case class Received(data: ArrayBuffer) extends ReceiveEvent
  case class Error(code: Int) extends ReceiveEvent

  def apply(id: SocketId): Socket = new Socket(id)

  def apply(name: String = "",
            persistent: Boolean,
            bufferSize: Int): Future[Socket] = {
    TCP
      .create(SocketProperties(persistent, name, bufferSize))
      .map(i => Socket(i.socketId))
  }

} 

package example

import com.thoughtworks.binding.Binding.Var
import com.thoughtworks.binding.{Binding, dom}
import org.scalajs.dom.document
import org.scalajs.dom.ext.Ajax
import org.scalajs.dom.raw.{Event, HTMLElement}

import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue
import scala.scalajs.js
import scala.scalajs.js.JSON



object ScalaJSExample extends js.JSApp {

  implicit def makeIntellijHappy(x: scala.xml.Elem): Binding[HTMLElement] = ???

  
  def countRequest(data: Var[String]) = {
    val url = "http://localhost:9000/count"
    Ajax.get(url).foreach { case xhr =>
      data.value = JSON.parse(xhr.responseText).count.toString
    }
  }

  @dom
  def render = {
    val data = Var("")
    countRequest(data) // initial population
    <div>
      <button onclick={event: Event => countRequest(data) }>
        Boop
      </button>
      From Play: The server has been booped { data.bind } times. Shared Message: {shared.SharedMessages.itWorks}.
    </div>
  }

  def main(): Unit = {
    dom.render(document.body, render)
  }
} 

package com.highcharts.test.frontend

import com.highcharts.CleanJsObject
import com.highcharts.HighchartsUtils._
import com.highcharts.test.frontend.charts.{Test3dPieChartConfig, TestBarChartConfig, TestCombinationChartConfig, TestStockChartConfig}
import org.scalajs.dom
import org.scalajs.jquery._

import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue
import scala.scalajs.js
import scala.scalajs.js.JSApp
import scala.scalajs.js.annotation.JSExport
import scalatags.JsDom.all._

@JSExport
object HighchartsTestApp extends JSApp {
  private def renderChart(chartConfig: CleanJsObject[js.Object]): dom.Element = {
    dom.console.log(chartConfig)
    val container = div().render
    jQuery(container).highcharts(chartConfig)
    container
  }

  private def fixChartSizes(): Unit = {
    jQuery("div[data-highcharts-chart]").each { (_: Int, e: dom.Element) ⇒
      jQuery(e).highcharts().foreach(_.reflow()).asInstanceOf[js.Any]
    }
  }

  @JSExport
  override def main(): Unit = {
    jQuery(() ⇒ {
      // Create charts
      val barChart = renderChart(new TestBarChartConfig)
      val pieChart = renderChart(new Test3dPieChartConfig)
      val comboChart = renderChart(new TestCombinationChartConfig)
      val stockChart = div().render

      // Create navigation elements
      val tabs = new NavigationBar("highcharts-test",
        NavigationTab("Bar chart", "bar", "briefcase", barChart, active = true),
        NavigationTab("Pie chart", "pie", "adjust", pieChart),
        NavigationTab("Combination chart", "combo", "tasks", comboChart),
        NavigationTab("Stock chart", "stock", "usd", stockChart)
      )

      // Bootstrap container
      val container = div(id := "main-container", `class` := "container")(
        div(`class` := "row", div(`class` := "col-md-12")(
          tabs.content
        ))
      ).render

      // Render page
      val body = dom.document.body
      body.appendChild(tabs.navbar("Scala.js Highcharts Test").render)
      body.appendChild(container)

      TestStockChartConfig.loadSampleData().foreach { data ⇒
        val config: CleanJsObject[TestStockChartConfig] = new TestStockChartConfig(data)
        dom.console.log(config)
        jQuery(stockChart).highstock(config)
      }

      // Size fix
      jQuery(dom.document).on("shown.bs.tab", "a[data-toggle=\"tab\"]", (_: JQueryEventObject) ⇒ fixChartSizes())
      fixChartSizes()
    })
  }
} 

package slinky.native

import slinky.core.ExternalComponent
import slinky.core.annotations.react
import slinky.core.facade.ReactElement

import scala.concurrent.Future
import scala.scalajs.js
import scala.scalajs.js.annotation.JSImport
import scala.scalajs.js.|
import scala.scalajs.js.JSConverters._

case class ImageURISource(
  uri: js.UndefOr[String] = js.undefined,
  bundle: js.UndefOr[String] = js.undefined,
  method: js.UndefOr[String] = js.undefined,
  headers: js.UndefOr[js.Object] = js.undefined,
  body: js.UndefOr[String] = js.undefined,
  cache: js.UndefOr[String] = js.undefined,
  width: js.UndefOr[Int] = js.undefined,
  height: js.UndefOr[Int] = js.undefined,
  scale: js.UndefOr[Double] = js.undefined
)

@js.native
trait ImageInterface extends js.Object

case class ImageErrorEvent(error: js.Error)

case class ImageProgressEvent(loaded: Int, total: Int)

@react object Image extends ExternalComponent {
  case class Props(
    style: js.UndefOr[js.Object] = js.undefined,
    blurRadius: js.UndefOr[Int] = js.undefined,
    onLayout: js.UndefOr[NativeSyntheticEvent[LayoutChangeEvent] => Unit] = js.undefined,
    onLoad: js.UndefOr[() => Unit] = js.undefined,
    onLoadEnd: js.UndefOr[() => Unit] = js.undefined,
    onLoadStart: js.UndefOr[() => Unit] = js.undefined,
    resizeMode: js.UndefOr[String] = js.undefined,
    source: js.UndefOr[ImageURISource | Int | Seq[ImageURISource]] = js.undefined,
    loadingIndicatorSource: js.UndefOr[Seq[ImageURISource | Int]] = js.undefined,
    onError: js.UndefOr[NativeSyntheticEvent[ImageErrorEvent] => Unit] = js.undefined,
    testID: js.UndefOr[String] = js.undefined,
    resizeMethod: js.UndefOr[String] = js.undefined,
    accessibilityLabel: js.UndefOr[ReactElement] = js.undefined,
    accessible: js.UndefOr[Boolean] = js.undefined,
    capInsets: js.UndefOr[BoundingBox] = js.undefined,
    defaultSource: js.UndefOr[js.Object | Int] = js.undefined,
    onPartialLoad: js.UndefOr[() => Unit] = js.undefined,
    onProgress: js.UndefOr[NativeSyntheticEvent[ImageProgressEvent] => Unit] = js.undefined
  )

  @js.native
  @JSImport("react-native", "Image")
  object Component extends js.Object {
    def getSize(
      uri: String,
      success: js.Function2[Int, Int, Unit],
      failure: js.UndefOr[js.Function1[js.Error, Unit]]
    ): Unit                                                                   = js.native
    def prefetch(uri: String): Int | Unit                                     = js.native
    def abortPrefetch(requestId: Int): Unit                                   = js.native
    def queryCache(urls: js.Array[String]): js.Promise[js.Dictionary[String]] = js.native
  }

  override val component = Component

  def getSize(uri: String, success: (Int, Int) => Unit, failure: js.UndefOr[(js.Error) => Unit] = js.undefined): Unit =
    Component.getSize(uri, success, failure.map(v => v))

  def prefetch(uri: String): Int | Unit = Component.prefetch(uri)

  def abortPrefetch(requestId: Int): Unit = Component.abortPrefetch(requestId)

  def queryCache(urls: Seq[String]): Future[Map[String, String]] = {
    import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue
    Component.queryCache(urls.toJSArray).toFuture.map(_.toMap)
  }
} 

package com.payalabs.scalajs.react.bridge.test

import scala.concurrent.Future
import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue
import scala.scalajs.js

import com.payalabs.scalajs.react.bridge._
import org.scalatest.funsuite.AnyFunSuite


class JsWriterTest extends AnyFunSuite {
  test("unionWriter") {
    val writer = unionWriter[Seq[String], Future[String]]
    val value1 = Seq("hello", "goodbye")
    val value2 = Future.successful("hello")
    val res1 = writer.toJs(value1)
    val res2 = writer.toJs(value2)
    assert(res1.isInstanceOf[js.Array[_]])
    assert(!res1.isInstanceOf[js.Promise[_]])
    assert(!res2.isInstanceOf[js.Array[_]])
    assert(res2.isInstanceOf[js.Promise[_]])
  }
}