Constants for the value of esVersion
.
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.
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:
---
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()
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.
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:
class
'es, therefore a) they can extend
native JavaScript class
'es and b) they inherit static members from
their parent class.js.Function
s that are not also js.ThisFunction
s are
JavaScript arrow functions (=>
). Lambdas for js.ThisFunction
s are
function
functions.NoModule
) mode, top-level exports are defined as let
s. When false
, the following semantics apply:
function
s 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.js.Function
s are function
s.Error.prototype
in their
prototype chain, but they are not considered proper error classes.NoModule
) mode, top-level exports are defined as var
s. 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()
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()
(Since version 1.6.0) use esVersion >= ESVersion.ES2015 instead