Package

scala.scalajs

js

Permalink

package js

Types, methods and values for interoperability with JavaScript libraries.

This package is only relevant to the Scala.js compiler, and should not be referenced by any project compiled to the JVM.

Guide

General documentation on Scala.js is available at http://www.scala-js.org/doc/.

Overview

The trait js.Any is the root of the hierarchy of JavaScript types. This package defines important subtypes of js.Any that are defined in the standard library of ECMAScript 5.1 (or ES 6, with a label in the documentation), such as js.Object, js.Array and js.RegExp.

Implicit conversions to and from standard Scala types to their equivalent in JavaScript are provided. For example, from Scala functions to JavaScript functions and back.

The most important subtypes of js.Any declared in this package are:

The trait js.Dynamic is a special subtrait of js.Any. It can represent any JavaScript value in a dynamically-typed way. It is possible to call any method and read and write any field of a value of type js.Dynamic.

There are no explicit definitions for JavaScript primitive types, as one could expect, because the corresponding Scala types stand in their stead:

js.UndefOr gives a scala.Option-like interface where the JavaScript value undefined takes the role of None.

A | B is an unboxed pseudo-union type, suitable to type values that admit several unrelated types in facade types.

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. js
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. trait Any extends AnyRef

    Permalink

    Root of the hierarchy of JavaScript types.

    Root of the hierarchy of JavaScript types.

    Subtypes of js.Any are JavaScript types, which have different semantics and guarantees than Scala types (subtypes of AnyRef and AnyVal). Operations on JavaScript types behave as the corresponding operations in the JavaScript language.

    By default, JavaScript types are native: they are facade types to APIs implemented in JavaScript code. Their implementation is irrelevant and never emitted. As such, all members must be defined with their right-hand-side being js.native. For forward source compatibility with the next major version, the class/trait/object itself should be annotated with @js.native.

    In most cases, you should not directly extend this trait, but rather extend js.Object.

    To implement a JavaScript type in Scala.js (therefore non-native), its declaration must be annotated with @ScalaJSDefined. Scala.js-defined JS types cannot directly extend native JS traits; and Scala.js-defined JS traits cannot declare concrete term members.

    It is not possible to define traits or classes that inherit both from this trait and a strict subtype of AnyRef. In fact, you should think of js.Any as a third direct subclass of scala.Any, besides scala.AnyRef and scala.AnyVal.

    See the JavaScript interoperability guide of Scala.js for more details.

    Annotations
    @RawJSType() @ScalaJSDefined()
  2. class Array[A] extends Object

    Permalink

    Arrays are list-like objects whose prototype has methods to perform traversal and mutation operations.

    Arrays are list-like objects whose prototype has methods to perform traversal and mutation operations. Neither the length of a JavaScript array nor the types of its elements are fixed. Since an array's size length grow or shrink at any time, JavaScript arrays are not guaranteed to be dense. In general, these are convenient characteristics; but if these features are not desirable for your particular use, you might consider using typed arrays.

    MDN

    To construct a new array with uninitialized elements, use the constructor of this class. To construct a new array with specified elements, as if you used the array literal syntax in JavaScript, use the Array.apply method instead.

    A

    Type of the elements of the array

    Annotations
    @RawJSType() @native()
  3. final class ArrayOps[A] extends ArrayLike[A, Array[A]] with Builder[A, Array[A]]

    Permalink

    Equivalent of scm.ArrayOps for js.Array

    Equivalent of scm.ArrayOps for js.Array

    Annotations
    @inline()
  4. final class ConstructorTag[T <: Any] extends AnyVal

    Permalink

    Stores the JS constructor function of a JS class.

    Stores the JS constructor function of a JS class.

    A ConstructorTag[T] holds the constructor function of a JS class, as retrieved by js.constructorOf[T]. Similarly to ClassTags, ConstructorTags can be implicitly materialized when T is statically known to be a JS class, i.e., a valid type argument to js.constructorOf.

  5. class Date extends Object

    Permalink

    Creates a JavaScript Date instance that represents a single moment in time.

    Creates a JavaScript Date instance that represents a single moment in time. Date objects are based on a time value that is the number of milliseconds since 1 January, 1970 UTC.

    MDN

    Annotations
    @RawJSType() @native()
  6. sealed trait Dictionary[A] extends Any

    Permalink

    Dictionary "view" of a JavaScript value.

    Dictionary "view" of a JavaScript value.

    Using objects as dictionaries (maps from strings to values) through their properties is a common idiom in JavaScript. This trait lets you treat an object as such a dictionary, with the familiar API of a Map.

    To use it, cast your object, say x, into a Dictionary using

    val xDict = x.asInstanceOf[js.Dictionary[Int]]

    then use it as

    xDict("prop") = 5
    println(xDict.get("prop")) // displays Some(5)
    xDict -= "prop"            // removes the property "prop"
    println(xDict.get("prop")) // displays None

    To enumerate all the keys of a dictionary, use collection methods or for comprehensions. For example:

    for ((prop, value) <- xDict) {
      println(prop + " -> " + value)
    }

    Note that this does not enumerate properties in the prototype chain of xDict.

    This trait extends js.Any directly, because it is not safe to call methods of js.Object on it, given that the name of these methods could be used as keys in the dictionary.

    Annotations
    @RawJSType() @native()
  7. sealed trait Dynamic extends Any with scala.Dynamic

    Permalink

    Dynamically typed JavaScript value.

    Dynamically typed JavaScript value.

    Values of this trait accept all possible JavaScript operations in a dynamically typed way. You can read and write any field, call any method, apply any JavaScript operator to values of this type.

    Annotations
    @RawJSType() @native()
  8. class Error extends Object

    Permalink
    Annotations
    @RawJSType() @native()
  9. class EvalError extends Error

    Permalink

    An instance representing an error that occurs regarding the global function eval()

    An instance representing an error that occurs regarding the global function eval()

    MDN

    Annotations
    @RawJSType() @native()
  10. class Function extends Object

    Permalink

    The Function constructor creates a new Function object.

    The Function constructor creates a new Function object. In JavaScript every function is actually a Function object.

    Function objects created with the Function constructor are parsed when the function is created. This is less efficient than declaring a function and calling it within your code, because functions declared with the function statement are parsed with the rest of the code.

    All arguments passed to the function are treated as the names of the identifiers of the parameters in the function to be created, in the order in which they are passed.

    Note: Functions created with the Function constructor do not create closures to their creation contexts; they always are created in the global scope. When running them, they will only be able to access their own local variables and global ones, not the ones from the scope in which the Function constructor was called. This is different from using eval with code for a function expression.

    Invoking the Function constructor as a function (without using the new operator) has the same effect as invoking it as a constructor.

    MDN

    Annotations
    @RawJSType() @native()
  11. trait Function0[+R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  12. trait Function1[-T1, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  13. trait Function10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  14. trait Function11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  15. trait Function12[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  16. trait Function13[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  17. trait Function14[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  18. trait Function15[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  19. trait Function16[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  20. trait Function17[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  21. trait Function18[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  22. trait Function19[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  23. trait Function2[-T1, -T2, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  24. trait Function20[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  25. trait Function21[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  26. trait Function22[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  27. trait Function3[-T1, -T2, -T3, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  28. trait Function4[-T1, -T2, -T3, -T4, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  29. trait Function5[-T1, -T2, -T3, -T4, -T5, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  30. trait Function6[-T1, -T2, -T3, -T4, -T5, -T6, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  31. trait Function7[-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  32. trait Function8[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  33. trait Function9[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R] extends Function

    Permalink
    Annotations
    @RawJSType() @native()
  34. trait GlobalScope extends Any

    Permalink

    Marker trait for top-level objects representing the JS global scope.

    Marker trait for top-level objects representing the JS global scope.

    When calling method on a top-level object or package object that is a subtype of GlobalScope, the receiver is dropped, and the JavaScript global scope is used instead.

    Annotations
    @RawJSType() @native()
    See also

    Calling JavaScript from Scala.js

  35. trait JSApp extends AnyRef

    Permalink

    Base class for top-level, entry point main objects.

    Base class for top-level, entry point main objects.

    Objects inheriting from JSApp are automatically exported to JavaScript under their fully qualified name, and their main method as well.

    JSApp is typically used to mark the entry point of a Scala.js application. As such, the sbt plugin also recognizes top-level objects extending JSApp. It allows to run their main method with sbt run, and can also generate a tiny JavaScript launcher snippet executing the main method of one specific JSApp object.

    Annotations
    @JSExportDescendentObjects()
  36. trait JSArrayOps[A] extends Object

    Permalink

    Discouraged native JavaScript Array methods.

    Discouraged native JavaScript Array methods.

    In general, you should prefer the Scala collection methods available implicitly through ArrayOps, because they are inlineable, and hence faster.

    To enable the use of these functions on js.Arrays, import the implicit conversion JSArrayOps.jsArrayOps.

    Annotations
    @RawJSType() @native()
  37. sealed abstract class JSConvertersLowPrioImplicits extends AnyRef

    Permalink
  38. trait JSNumberOps extends Any

    Permalink

    Operations on JavaScript numbers.

    Operations on JavaScript numbers.

    Annotations
    @RawJSType() @native()
  39. trait JSStringOps extends Any

    Permalink

    Operations on JavaScript strings.

    Operations on JavaScript strings.

    The methods with an equivalent signature in String but with a different meaning are prefixed by js in this trait.

    Annotations
    @RawJSType() @native()
  40. case class JavaScriptException(exception: scala.Any) extends RuntimeException with Product with Serializable

    Permalink
  41. trait LowPrioAnyImplicits extends AnyRef

    Permalink
  42. class Object extends Any

    Permalink

    Base class of all JavaScript objects.

    Base class of all JavaScript objects.

    Annotations
    @RawJSType() @native()
  43. class Promise[+A] extends Object with Thenable[A]

    Permalink

    ECMAScript 6 Promise of an asynchronous result.

    ECMAScript 6 Promise of an asynchronous result.

    Attention! The nature of this class, from the ECMAScript specification, makes it inherently un-typeable, because it is not type parametric.

    The signatures of the constructor and the methods then and catch are only valid provided that the values of A and B are not Thenables.

    We recommend to use Scala's Futures instead of Promise as much as possible. A Promise can be converted to a Future with .toFuture and back with .toJSPromise (provided by JSConverters).

    With

    import scala.scalajs.js.Thenable.Implicits._

    you can implicitly convert a Promise to a Future, and therefore you can directly use the methods of Future on Promises.

    Annotations
    @RawJSType() @native()
  44. trait PropertyDescriptor extends Object

    Permalink
    Annotations
    @RawJSType() @native()
  45. class RangeError extends Error

    Permalink

    An instance representing an error that occurs when a numeric variable or parameter is outside of its valid range.

    An instance representing an error that occurs when a numeric variable or parameter is outside of its valid range.

    A RangeError is thrown when trying to pass a number as an argument to a function that does not allow a range that includes that number. This can be encountered when to create an array of an illegal length with the Array constructor, or when passing bad values to the numeric methods toExponential, toFixed, or toPrecision.

    MDN

    Annotations
    @RawJSType() @native()
  46. class ReferenceError extends Error

    Permalink

    Represents an error when a non-existent variable is referenced.

    Represents an error when a non-existent variable is referenced.

    A ReferenceError is thrown when trying to dereference a variable that has not been declared.

    MDN

    Annotations
    @RawJSType() @native()
  47. class RegExp extends Object

    Permalink

    The RegExp constructor creates a regular expression object for matching text with a pattern.

    The RegExp constructor creates a regular expression object for matching text with a pattern.

    MDN

    Annotations
    @RawJSType() @native()
  48. class SyntaxError extends Error

    Permalink

    Represents an error when trying to interpret syntactically invalid code.

    Represents an error when trying to interpret syntactically invalid code.

    A SyntaxError is thrown when the JavaScript engine encounters tokens or token order that does not conform to the syntax of the language when parsing code.

    MDN

    Annotations
    @RawJSType() @native()
  49. trait Thenable[+A] extends Object

    Permalink

    A thing on which one can call the then method.

    A thing on which one can call the then method.

    Thenables are automatically transitively flattened by the then method of Thenables. In particular, this is true for Promises.

    Attention! The nature of this interface, from the ECMAScript specification, makes it inherently un-typeable, because it is not type parametric.

    The signature of the then method is only valid provided that the values of B do not have a then method.

    Annotations
    @RawJSType() @ScalaJSDefined()
  50. trait ThisFunction extends Function

    Permalink

    A JavaScript function where this is considered as a first parameter.

    A JavaScript function where this is considered as a first parameter.

    Annotations
    @RawJSType() @native()
    See also

    Calling JavaScript from Scala.js

  51. trait ThisFunction0[-T0, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  52. trait ThisFunction1[-T0, -T1, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  53. trait ThisFunction10[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  54. trait ThisFunction11[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  55. trait ThisFunction12[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  56. trait ThisFunction13[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  57. trait ThisFunction14[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  58. trait ThisFunction15[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  59. trait ThisFunction16[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  60. trait ThisFunction17[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  61. trait ThisFunction18[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  62. trait ThisFunction19[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  63. trait ThisFunction2[-T0, -T1, -T2, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  64. trait ThisFunction20[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  65. trait ThisFunction21[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  66. trait ThisFunction3[-T0, -T1, -T2, -T3, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  67. trait ThisFunction4[-T0, -T1, -T2, -T3, -T4, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  68. trait ThisFunction5[-T0, -T1, -T2, -T3, -T4, -T5, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  69. trait ThisFunction6[-T0, -T1, -T2, -T3, -T4, -T5, -T6, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  70. trait ThisFunction7[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  71. trait ThisFunction8[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  72. trait ThisFunction9[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R] extends Function with ThisFunction

    Permalink
    Annotations
    @RawJSType() @native()
  73. sealed trait Tuple10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10] extends Object

    Permalink

    A tuple "view" of 10 elements of a JavaScript Array.

    A tuple "view" of 10 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  74. sealed trait Tuple11[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11] extends Object

    Permalink

    A tuple "view" of 11 elements of a JavaScript Array.

    A tuple "view" of 11 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  75. sealed trait Tuple12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12] extends Object

    Permalink

    A tuple "view" of 12 elements of a JavaScript Array.

    A tuple "view" of 12 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  76. sealed trait Tuple13[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13] extends Object

    Permalink

    A tuple "view" of 13 elements of a JavaScript Array.

    A tuple "view" of 13 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  77. sealed trait Tuple14[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14] extends Object

    Permalink

    A tuple "view" of 14 elements of a JavaScript Array.

    A tuple "view" of 14 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  78. sealed trait Tuple15[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15] extends Object

    Permalink

    A tuple "view" of 15 elements of a JavaScript Array.

    A tuple "view" of 15 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  79. sealed trait Tuple16[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16] extends Object

    Permalink

    A tuple "view" of 16 elements of a JavaScript Array.

    A tuple "view" of 16 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple16

  80. sealed trait Tuple17[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17] extends Object

    Permalink

    A tuple "view" of 17 elements of a JavaScript Array.

    A tuple "view" of 17 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  81. sealed trait Tuple18[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18] extends Object

    Permalink

    A tuple "view" of 18 elements of a JavaScript Array.

    A tuple "view" of 18 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  82. sealed trait Tuple19[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19] extends Object

    Permalink

    A tuple "view" of 19 elements of a JavaScript Array.

    A tuple "view" of 19 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  83. sealed trait Tuple2[+T1, +T2] extends Object

    Permalink

    A tuple "view" of 2 elements of a JavaScript Array.

    A tuple "view" of 2 elements of a JavaScript Array. Combines

    0: T0;
    1: T1;

    to

    js.Tuple2[T0,T1]

    Supports implicit conversion to scala.Tuple2. To use it, cast your array into a Tuple2 using

    val array = js.Array[Any](42, "foobar")
    val tuple2 = array.asInstanceOf[js.Tuple2[Int, String]]

    or convert a Scala tuple

    val obj: js.Tuple2[Int, String] = (42, "foobar")
    Annotations
    @RawJSType() @native()
  84. sealed trait Tuple20[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20] extends Object

    Permalink

    A tuple "view" of 20 elements of a JavaScript Array.

    A tuple "view" of 20 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  85. sealed trait Tuple21[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21] extends Object

    Permalink

    A tuple "view" of 21 elements of a JavaScript Array.

    A tuple "view" of 21 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  86. sealed trait Tuple22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22] extends Object

    Permalink

    A tuple "view" of 22 elements of a JavaScript Array.

    A tuple "view" of 22 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  87. sealed trait Tuple3[+T1, +T2, +T3] extends Object

    Permalink

    A tuple "view" of 3 elements of a JavaScript Array.

    A tuple "view" of 3 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  88. sealed trait Tuple4[+T1, +T2, +T3, +T4] extends Object

    Permalink

    A tuple "view" of 4 elements of a JavaScript Array.

    A tuple "view" of 4 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  89. sealed trait Tuple5[+T1, +T2, +T3, +T4, +T5] extends Object

    Permalink

    A tuple "view" of 5 elements of a JavaScript Array.

    A tuple "view" of 5 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  90. sealed trait Tuple6[+T1, +T2, +T3, +T4, +T5, +T6] extends Object

    Permalink

    A tuple "view" of 6 elements of a JavaScript Array.

    A tuple "view" of 6 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  91. sealed trait Tuple7[+T1, +T2, +T3, +T4, +T5, +T6, +T7] extends Object

    Permalink

    A tuple "view" of 7 elements of a JavaScript Array.

    A tuple "view" of 7 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  92. sealed trait Tuple8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8] extends Object

    Permalink

    A tuple "view" of 8 elements of a JavaScript Array.

    A tuple "view" of 8 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  93. sealed trait Tuple9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9] extends Object

    Permalink

    A tuple "view" of 9 elements of a JavaScript Array.

    A tuple "view" of 9 elements of a JavaScript Array.

    Annotations
    @RawJSType() @native()
    See also

    Tuple2

  94. class TypeError extends Error

    Permalink

    Represents an error when a value is not of the expected type.

    Represents an error when a value is not of the expected type.

    A TypeError is thrown when an operand or argument passed to a function is incompatible with the type expected by that operator or function.

    MDN

    Annotations
    @RawJSType() @native()
  95. class URIError extends Error

    Permalink

    Represents an error when a malformed URI is encountered.

    Represents an error when a malformed URI is encountered.

    A URIError is thrown when the URI handling functions are passed a malformed URI.

    MDN

    Annotations
    @RawJSType() @native()
  96. sealed trait UndefOr[+A] extends AnyRef

    Permalink

    Value of type A or the JS undefined value.

    Value of type A or the JS undefined value.

    js.UndefOr[A] is the type of a value that can be either undefined or an A. It provides an API similar to that of scala.Option through the UndefOrOps implicit class, where undefined take the role of None.

    By extension, this type is also suited to typing optional fields in native JS types, i.e., fields that may not exist on the object.

    Annotations
    @RawJSType()
  97. sealed abstract class UndefOrLowPrioImplicits extends AnyRef

    Permalink
  98. final class UndefOrOps[A] extends AnyVal

    Permalink

  99. sealed trait UnicodeNormalizationForm extends Any

    Permalink

    A Unicode Normalization Form.

    A Unicode Normalization Form.

    Annotations
    @RawJSType() @native()
    See also

    Unicode Normalization Forms

    JSStringOps.normalize

  100. final class Using[A] extends AnyVal

    Permalink

    Helper for syntactic sugar of js.use.

    Helper for syntactic sugar of js.use. Only use in js.use(x).as[T]

  101. final class WrappedArray[A] extends AbstractBuffer[A] with GenericTraversableTemplate[A, WrappedArray] with collection.mutable.IndexedSeq[A] with BufferLike[A, WrappedArray[A]] with ArrayLike[A, WrappedArray[A]] with Builder[A, WrappedArray[A]]

    Permalink

    Equivalent of scm.WrappedArray for js.Array

    Equivalent of scm.WrappedArray for js.Array

    Annotations
    @inline()
  102. class WrappedDictionary[A] extends AbstractMap[String, A] with Map[String, A] with MapLike[String, A, WrappedDictionary[A]]

    Permalink

    Wrapper to use a js.Dictionary as a scala.mutable.Map

    Wrapper to use a js.Dictionary as a scala.mutable.Map

    Annotations
    @inline()
  103. class native extends Annotation with StaticAnnotation

    Permalink

    Marks the annotated class, trait or object as a native JS entity.

    Marks the annotated class, trait or object as a native JS entity.

    Native JS entities are not implemented in Scala.js. They are facade types for native JS libraries.

    In Scala.js 0.6.x, all types extending js.Any are native by default (unless they are annotated with annotation.ScalaJSDefined), but this will not be the case in the next major version anymore.

    Only types extending js.Any can be annotated with @js.native. The body of all concrete members in a native JS class, trait or object must be = js.native.

  104. sealed trait |[A, B] extends AnyRef

    Permalink

    Value of type A or B (union type).

    Value of type A or B (union type).

    Scala does not have union types, but they are important to many interoperability scenarios. This type provides a (partial) encoding of union types using implicit evidences.

    Annotations
    @RawJSType()

Value Members

  1. object Any extends LowPrioAnyImplicits

    Permalink

    Provides implicit conversions from Scala values to JavaScript values.

  2. object Array extends Object

    Permalink

    Factory for js.Array objects.

    Factory for js.Array objects.

    Annotations
    @native()
  3. object ArrayOps

    Permalink
  4. object ConstructorTag

    Permalink
  5. object Date extends Object

    Permalink

    Factory for js.Date objects.

    Factory for js.Date objects.

    Annotations
    @native()
  6. object Dictionary

    Permalink

    Factory for Dictionary instances.

  7. object Dynamic

    Permalink

    Factory for dynamically typed JavaScript values.

  8. object DynamicImplicits

    Permalink

    Provides implicit conversions and operations to write in JavaScript style with js.Dynamic.

    Provides implicit conversions and operations to write in JavaScript style with js.Dynamic.

    Be **very** careful when importing members of this object. You may want to selectively import the implicits that you want to reduce the likelihood of making mistakes.

  9. object Error extends Object

    Permalink
    Annotations
    @native()
  10. object EvalError extends Object

    Permalink
    Annotations
    @native()
  11. object Function extends Object

    Permalink
    Annotations
    @native()
  12. object JSArrayOps

    Permalink
  13. object JSConverters extends JSConvertersLowPrioImplicits

    Permalink

    A collection of decorators that allow converting Scala types to corresponding JS facade types

  14. object JSNumberOps

    Permalink
  15. object JSON extends Object

    Permalink

    The JSON object contains methods for converting values to JavaScript Object Notation (JSON) and for converting JSON to values.

    The JSON object contains methods for converting values to JavaScript Object Notation (JSON) and for converting JSON to values.

    MDN

    Annotations
    @native()
  16. object JSStringOps

    Permalink
  17. object Math extends Object

    Permalink

    Math is a built-in object that has properties and methods for mathematical constants and functions.

    Math is a built-in object that has properties and methods for mathematical constants and functions. Not a function object.

    MDN

    Annotations
    @native()
  18. object Object extends Object

    Permalink

    The top-level Object JavaScript object.

    The top-level Object JavaScript object.

    Annotations
    @native()
  19. object Promise extends Object

    Permalink
    Annotations
    @native()
  20. object RangeError extends Object

    Permalink
    Annotations
    @native()
  21. object ReferenceError extends Object

    Permalink
    Annotations
    @native()
  22. object RegExp extends Object

    Permalink
    Annotations
    @native()
  23. object SyntaxError extends Object

    Permalink
    Annotations
    @native()
  24. object Thenable

    Permalink
  25. object ThisFunction

    Permalink
  26. object Tuple10

    Permalink
  27. object Tuple11

    Permalink
  28. object Tuple12

    Permalink
  29. object Tuple13

    Permalink
  30. object Tuple14

    Permalink
  31. object Tuple15

    Permalink
  32. object Tuple16

    Permalink
  33. object Tuple17

    Permalink
  34. object Tuple18

    Permalink
  35. object Tuple19

    Permalink
  36. object Tuple2

    Permalink
  37. object Tuple20

    Permalink
  38. object Tuple21

    Permalink
  39. object Tuple22

    Permalink
  40. object Tuple3

    Permalink
  41. object Tuple4

    Permalink
  42. object Tuple5

    Permalink
  43. object Tuple6

    Permalink
  44. object Tuple7

    Permalink
  45. object Tuple8

    Permalink
  46. object Tuple9

    Permalink
  47. object TypeError extends Object

    Permalink
    Annotations
    @native()
  48. object URIError extends Object

    Permalink
    Annotations
    @native()
  49. object URIUtils extends GlobalScope

    Permalink

    Methods related to URIs, provided by ECMAScript 5.1.

    Methods related to URIs, provided by ECMAScript 5.1.

    Annotations
    @native()
  50. object UndefOr extends UndefOrLowPrioImplicits

    Permalink
  51. object UndefOrOps

    Permalink
  52. object UnicodeNormalizationForm

    Permalink
  53. object WrappedArray extends SeqFactory[WrappedArray]

    Permalink

    Factory for WrappedArray.

    Factory for WrappedArray. Mainly provides the relevant CanBuildFromss and implicit conversions.

  54. object WrappedDictionary

    Permalink
  55. package annotation

    Permalink
  56. def constructorOf[T <: Any]: Dynamic

    Permalink

    Returns the constructor function of a JavaScript class.

    Returns the constructor function of a JavaScript class.

    The specified type parameter T must be a class type (i.e., valid for classOf[T]) and represent a class extending js.Any (not a trait nor an object).

  57. def constructorTag[T <: Any](implicit tag: ConstructorTag[T]): ConstructorTag[T]

    Permalink

    Makes explicit an implicitly available ConstructorTag[T].

  58. def debugger(): Unit

    Permalink

    Invokes any available debugging functionality.

    Invokes any available debugging functionality. If no debugging functionality is available, this statement has no effect.

    MDN

    Browser support:

    • Has no effect in Rhino nor, apparently, in Firefox
    • In Chrome, it has no effect unless the developer tools are opened beforehand.
  59. def eval(x: String): Any

    Permalink

    Evaluates JavaScript code and returns the result.

    Evaluates JavaScript code and returns the result.

    Annotations
    @inline()
  60. def isUndefined(v: scala.Any): Boolean

    Permalink

    Tests whether the given value is undefined.

    Tests whether the given value is undefined.

    Annotations
    @inline()
  61. def native: Nothing

    Permalink

    Denotes a method body as native JavaScript.

    Denotes a method body as native JavaScript. For use in facade types:

    class MyJSClass extends js.Object {
      def myMethod(x: String): Int = js.native
    }
  62. package timers

    Permalink

    Non-Standard Non-standard, but in general well supported methods to schedule asynchronous exeuction.

    Non-Standard Non-standard, but in general well supported methods to schedule asynchronous exeuction.

    The methods in this package work in all JavaScript virtual machines supported by Scala.js (currently Rhino, Node.js and PhantomJS).

  63. def typeOf(x: Any): String

    Permalink

    Returns the type of x as identified by typeof x in JavaScript.

  64. package typedarray

    Permalink

    ECMAScript 6 The typdearray package provides facade types for JavaScript ArrayBuffer, TypeArrays and DataView.

    ECMAScript 6 The typdearray package provides facade types for JavaScript ArrayBuffer, TypeArrays and DataView. Further, it provides conversions between primitive Scala arrays and TypedArrays

  65. def undefined: UndefOr[Nothing]

    Permalink

    The undefined value.

    The undefined value.

    Annotations
    @inline()
  66. def use[A](x: A): Using[A]

    Permalink

    Allows to cast a value to a facade trait in a type-safe way.

    Allows to cast a value to a facade trait in a type-safe way.

    Use as follows:

    js.use(x).as[MyFacade]

    Note that the method calls are only syntactic sugar. There is no overhead at runtime for such an operation. Using use(x).as[T] is strictly equivalent to x.asInstanceOf[T] if the compile time check does not fail.

    This method supports both Scala classes with exports and facade types which are structurally equivalent.

    Examples

    Given the following facade type:

    trait MyFacade extends js.Object {
      def foo(x: Int): String = js.native
      val bar: Int = js.native
    }

    We show a couple of examples:

    class MyClass1 {
      @JSExport
      def foo(x: Int): String = x.toString
    
      @JSExport
      val bar: Int = 1
    }
    
    val x1 = new MyClass1
    js.use(x1).as[MyFacade] // OK

    Note that JS conventions apply: The val bar can be implemented with a def.

    class MyClass2 {
      @JSExport
      def foo(x: Int): String = x.toString
    
      @JSExport
      def bar: Int = 1 // def instead of val
    }
    
    val x2 = new MyClass2
    js.use(x2).as[MyFacade] // OK

    Missing methods or methods with wrong types will cause a compile-time failure.

    class MyClass3 {
      @JSExport
      def foo(x: String): String = x.toString // wrong type signature
    
      // bar is missing
    }
    
    val x3 = new MyClass3
    js.use(x2).as[MyFacade] // Fails: bar is missing and foo has wrong type

    Methods must be exported, otherwise they are not taken into consideration.

    class MyClass4 {
      def foo(x: Int): String = x.toString
    
      @JSExport
      def bar: Int = 1 // def instead of val
    }
    
    val x4 = new MyClass4
    js.use(x4).as[MyFacade] // Fails, foo is missing

    Other facade types can also be used

    trait MyOtherFacade extends js.Object {
      def foo(x: Any): String = js.native
      val bar: Int = js.native
      def otherMethod(): Unit = js.native
    }
    
    val x5: MyOtherFacade = // ...
    js.use(x5).as[MyFacade] // OK

    Restrictions

    • Facade types may only be traits and not have any class ancestors
    • Polymorphic methods are currently not supported
    • Facade types defining an apply method cannot used (this is a JavaScript restriction).
  67. object |

    Permalink

Inherited from AnyRef

Inherited from scala.Any

Ungrouped