Packages

  • package root
    Definition Classes
    root
  • package scala
    Definition Classes
    root
  • package scalajs
    Definition Classes
    scala
  • package concurrent
    Definition Classes
    scalajs
  • package js

    Types, methods and values for interoperability with JavaScript libraries.

    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:

    • Boolean is the type of primitive JavaScript booleans
    • Double is the type of primitive JavaScript numbers
    • String is the type of primitive JavaScript strings (or null)
    • Unit is the type of the JavaScript undefined value
    • Null is the type of the JavaScript null value

    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.

    Definition Classes
    scalajs
  • package reflect
    Definition Classes
    scalajs
  • LinkingInfo
o

scala.scalajs

LinkingInfo

object LinkingInfo

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

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  6. def developmentMode: Boolean

    Returns true if we are linking for development, false otherwise.

    Returns true if we are linking for development, false otherwise.

    developmentMode is always equal to !productionMode.

    This ends up being constant-folded to a constant at link-time. So constant-folding, inlining, and other local optimizations can be leveraged with this "constant" to write code that should only be executed in production mode or development mode.

    A typical usage of this method is:

    if (developmentMode) {
      performExpensiveSanityChecks()
    }

    At link-time, developmentMode will either be a constant true, in which case the above snippet folds into

    performExpensiveSanityChecks()

    or a constant false, in which case it is dead-code-eliminated away, yielding maximum performance in production.

    Annotations
    @inline()
    See also

    productionMode

  7. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  8. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  9. def esVersion: Int

    Version (edition) of the ECMAScript Language Specification that is assumed to be supported by the runtime.

    Version (edition) of the ECMAScript Language Specification that is assumed to be supported by the runtime.

    This is an integer that represents the *edition* of the ECMAScript Language Specification. For example, ECMAScript 2015 is represented with the value 6.

    As an exception, ECMAScript 5.1 is represented with the value 5.

    This value can be used to:

    • avoid feature tests and dead-code-eliminate polyfills (see below), or
    • conditionally offer library features that depend on underlying ECMAScript support.

    ---

    This ends up being constant-folded to a constant at link-time. So constant-folding, inlining, and other local optimizations can be leveraged with this "constant" to write polyfills that can be dead-code-eliminated.

    A typical usage of this method is:

    if (esVersion >= ESVersion.ES2018 || featureTest())
      useES2018Feature()
    else
      usePolyfill()

    At link-time, esVersion will either be a constant less than ESVersion.ES2018, in which case the above snippet folds into

    if (featureTest())
      useES2018Feature()
    else
      usePolyfill()

    or a constant greater or equal to ESVersion.ES2018, in which case it folds into

    useES2018Feature()
    Annotations
    @inline()
  10. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  11. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  12. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  13. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  14. def isWebAssembly: Boolean

    Whether we are linking to WebAssembly.

    Whether we are linking to WebAssembly.

    This property can be used to delegate to different code paths optimized for WebAssembly rather than for JavaScript.

    ---

    This ends up being constant-folded to a constant at link-time. So constant-folding, inlining, and other local optimizations can be leveraged with this "constant" to write alternatives that can be dead-code-eliminated.

    A typical usage of this method is:

    if (isWebAssembly)
      implementationOptimizedForWebAssembly()
    else
      implementationOptimizedForJavaScript()

    At link-time, isWebAssembly will either be a constant true, in which case the above snippet folds into

    implementationOptimizedForWebAssembly()

    or a constant false, in which case it folds into

    implementationOptimizedForJavaScript()
    Annotations
    @inline()
  15. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  16. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  17. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  18. def productionMode: Boolean

    Returns true if we are linking for production, false otherwise.

    Returns true if we are linking for production, false otherwise.

    productionMode is always equal to !developmentMode.

    This ends up being constant-folded to a constant at link-time. So constant-folding, inlining, and other local optimizations can be leveraged with this "constant" to write code that should only be executed in production mode or development mode.

    A typical usage of this method is:

    val warningsLogger =
      if (productionMode) new NullLogger
      else new ConsoleLogger

    At link-time, productionMode will either be a constant true, in which case the above snippet folds into

    val warningsLogger = new NullLogger

    or a constant false, in which case it folds into

    val warningsLogger = new ConsoleLogger.
    Annotations
    @inline()
    See also

    developmentMode

  19. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  20. def toString(): String
    Definition Classes
    AnyRef → Any
  21. def useECMAScript2015Semantics: Boolean

    Whether Scala.js language features use ECMAScript 2015 (edition 6) semantics or not.

    Whether Scala.js language features use ECMAScript 2015 (edition 6) semantics or not.

    When true, the following semantics apply:

    • JavaScript classes are true class'es, therefore a) they can extend native JavaScript class'es and b) they inherit static members from their parent class.
    • Lambdas for js.Functions that are not also js.ThisFunctions are JavaScript arrow functions (=>). Lambdas for js.ThisFunctions are function functions.
    • Throwable classes are proper JavaScript error classes, recognized as such by debuggers.
    • In Script (NoModule) mode, top-level exports are defined as lets.

    When false, the following semantics apply:

    • All classes defined in Scala.js are functions instead of class'es. Non-native JS classes cannot extend native JS class'es and they do not inherit static members from their parent class.
    • All lambdas for js.Functions are functions.
    • Throwable classes have JavaScript's Error.prototype in their prototype chain, but they are not considered proper error classes.
    • In Script (NoModule) mode, top-level exports are defined as vars.

    Prefer reading this value instead of esVersion to determine which semantics apply.

    For example, it can be used in tests whose results depend on which semantics are used.

    ---

    This ends up being constant-folded to a constant at link-time. So constant-folding, inlining, and other local optimizations can be leveraged with this "constant" to write alternatives that can be dead-code-eliminated.

    A typical usage of this method is:

    if (useECMAScript2015Semantics)
      implementationWithES2015Semantics()
    else
      implementationWithoutES2015Semantics()

    At link-time, useECMAScript2015Semantics will either be a constant true, in which case the above snippet folds into

    implementationWithES2015Semantics()

    or a constant false, in which case it folds into

    implementationWithoutES2015Semantics()
    Annotations
    @inline()
  22. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  23. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  24. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  25. object ESVersion

    Constants for the value of esVersion.

Deprecated Value Members

  1. def assumingES6: Boolean

    Returns true if we are assuming that the target platform supports ECMAScript 6, false otherwise.

    Returns true if we are assuming that the target platform supports ECMAScript 6, false otherwise.

    This is true if and only if esVersion >= ESVersion.ES2015.

    ---

    This ends up being constant-folded to a constant at link-time. So constant-folding, inlining, and other local optimizations can be leveraged with this "constant" to write polyfills that can be dead-code-eliminated.

    A typical usage of this method is:

    if (assumingES6 || featureTest())
      useES6Feature()
    else
      usePolyfill()

    At link-time, assumingES6 will either be a constant false, in which case the above snippet folds into

    if (featureTest())
      useES6Feature()
    else
      usePolyfill()

    or a constant true, in which case it folds into

    useES6Feature()
    Annotations
    @deprecated @inline()
    Deprecated

    (Since version 1.6.0) use esVersion >= ESVersion.ES2015 instead

Inherited from AnyRef

Inherited from Any

Ungrouped