Scala.js Standard Library (scalajs-scalalib)

The Scala.js Standard Library provides the core Scala standard library implementation specifically adapted for JavaScript compilation targets. It maintains full API compatibility with the JVM Scala standard library while providing optimized implementations for the JavaScript runtime environment, enabling seamless use of familiar Scala APIs in browser and Node.js environments.

Package Information

• Package Name: scalajs-scalalib_2.13
• Package Type: maven
• Language: Scala
• Build Tool: sbt
• Installation: libraryDependencies += "org.scala-js" %%% "scalalib" % "1.20.1"

Core Imports

The scalalib is automatically available when using Scala.js compilation. Standard Scala imports work as expected:

import scala.App
import scala.Array
import scala.Console
import scala.concurrent.ExecutionContext
import scala.util.DynamicVariable
import scala.collection._

Basic Usage

// Using App trait for main program
object Main extends App {
  Console.println("Hello World: " + (args mkString ", "))
}

// Array operations
val numbers = Array(1, 2, 3, 4, 5)
val doubled = numbers.map(_ * 2)
val filtered = Array.range(1, 10).filter(_ % 2 == 0)

// Concurrent operations  
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future

val future = Future {
  "Hello from JavaScript!"
}

Architecture

The Scala.js Standard Library is organized around JavaScript-specific adaptations:

• Override System: Selective replacement of JVM standard library components with JavaScript-optimized implementations
• Version Compatibility: Separate implementations for Scala 2.12 and 2.13 compiler versions
• Single-threaded Model: Adapted for JavaScript's single-threaded execution environment
• Type Preservation: Maintains Scala's type system while optimizing for JavaScript performance
• API Compatibility: Ensures existing Scala code compiles and runs correctly on JavaScript

Capabilities

Core Language Features

Essential Scala language constructs and basic functionality adapted for JavaScript execution.

trait App extends DelayedInit {
  val args: Array[String]
  val executionStart: Long
}

object Array {
  def apply[T](xs: T*): Array[T]
  def ofDim[T: ClassTag](n1: Int): Array[T]
  def empty[T: ClassTag]: Array[T]
  def fill[T: ClassTag](n: Int)(elem: => T): Array[T]
  def tabulate[T: ClassTag](n: Int)(f: Int => T): Array[T]
  def range(start: Int, end: Int): Array[Int]
  def concat[T: ClassTag](xss: Array[T]*): Array[T]
}

object Console {
  def print(obj: Any): Unit
  def println(obj: Any): Unit
  def println(): Unit
  def printf(text: String, args: Any*): Unit
  def readLine(): String
  def readLine(text: String): String
}

Core Language Features

Concurrent Programming

Asynchronous programming utilities adapted for JavaScript's event loop and single-threaded execution model.

trait ExecutionContext {
  def execute(runnable: Runnable): Unit
  def reportFailure(cause: Throwable): Unit
}

object ExecutionContext {
  def global: ExecutionContext
  def fromExecutor(executor: Executor): ExecutionContext
}

Concurrent Programming

Collections Framework

Scala's collections library adapted for JavaScript with optimized implementations and JavaScript-specific performance characteristics.

// Collection operations and utilities
// (Detailed APIs available in collections sub-doc)

Collections Framework

Utility Classes

General-purpose utility classes for common programming tasks, adapted for JavaScript environment constraints.

class DynamicVariable[T](init: T) {
  def value: T
  def value_=(newval: T): Unit
  def withValue[S](newval: T)(thunk: => S): S
}

class Enumeration {
  protected final def Value: Value
  protected final def Value(i: Int): Value  
  protected final def Value(name: String): Value
  protected final def Value(i: Int, name: String): Value
}

case class Symbol private (name: String) {
  override def toString: String = "'" + name
}

Utility Classes

Math Operations

Mathematical functions and numeric utilities optimized for JavaScript's number system and Math object.

// Math utility functions and constants
// (Detailed APIs available in math sub-doc)

Math Operations

Runtime Support

Low-level runtime support classes and utilities that provide the foundation for Scala.js execution.

// Runtime support APIs
// (Detailed APIs available in runtime sub-doc)

Runtime Support

JavaScript-Specific Adaptations

The scalalib implementations are specifically optimized for JavaScript execution:

• Single-threaded Execution: All concurrent operations adapted for JavaScript's event loop
• JavaScript Data Structures: Optimized array and collection implementations using JavaScript arrays and objects
• Performance Optimization: Implementations tuned for JavaScript engine characteristics
• Memory Management: Adapted for JavaScript's garbage collection patterns
• Type System Integration: Maintains Scala's type safety while integrating with JavaScript's dynamic typing

Version Compatibility

The library provides three levels of compatibility:

1. General Overrides (overrides/scala/) - Core APIs compatible with all Scala versions
2. Scala 2.12 Specific (overrides-2.12/scala/) - Scala 2.12 version-specific implementations
3. Scala 2.13 Specific (overrides-2.13/scala/) - Scala 2.13 version-specific implementations

Error Handling

Standard Scala exception handling works as expected. Common JavaScript-specific considerations:

• TypeError: May occur when interfacing with JavaScript code
• RangeError: Possible with large numeric operations
• Memory Limits: JavaScript heap size limitations may affect large data structures