scala-js/scala-js
Scala Js
Scala.js is a compiler and cross-platform language toolchain that transforms Scala source code into JavaScript or WebAssembly. It functions as a statically typed tool for the JavaScript ecosystem, enabling the development of applications for web browsers and Node.js environments.
The project serves as a JavaScript interop framework, allowing the creation of type-safe facades and bindings to interact with external libraries and global objects. It provides mechanisms for both static and dynamic JavaScript invocation, including the generation of TypeScript bindings and the ability to export internal logic for use in external JavaScript code.
The toolchain includes a frontend build tool for production bundling and output optimization, including dead code elimination and module splitting. It covers a broad capability surface including DOM element type checking for UI development, cross-platform code sharing for full-stack development, and various testing frameworks for verifying optimized build artifacts.
Compiled scripts can be executed directly within a command-line environment using a JavaScript interpreter.
Features
- JavaScript Interoperability - Provides a framework for creating type-safe facades and bindings to interact with external JavaScript libraries and APIs.
- Source-to-Source Compilers - Transforms Scala source code into JavaScript or WebAssembly binaries while preserving original language semantics.
- Node.js Runtimes - Executes compiled code within the Node.js runtime to enable server-side execution or tooling.
- Cross-Platform Compilers - Functions as a toolchain that targets multiple platforms, including JavaScript and WebAssembly, from a single source.
- Single Codebase Targets - Enables a single source folder to be compiled for multiple target environments, maintaining a unified codebase.
- JavaScript Compilers - Transforms Scala source code into executable JavaScript for use in web browsers or server environments.
- JavaScript Interop - Provides type-safe interfaces and facades for interacting with external JavaScript libraries and global objects.
- Interop Facades - Allows the creation of type-safe representations of external APIs to map structural interfaces to a strict type system.
- JavaScript Class Definitions - Provides the ability to define classes and objects that follow native JavaScript semantics for external consumption.
- JavaScript Function Exporting - Makes internal logic and APIs available to be called directly by external JavaScript code.
- JavaScript Logic Exposure - Marks classes and methods as accessible to JavaScript environments via global scope or module exports.
- JVM-to-JavaScript Type Mappings - Maps JVM-based Scala types and collection structures to corresponding JavaScript primitives and prototypes.
- Prototype-Based Implementations - Implements classes that adhere to the prototype-based object model for compatibility with external JavaScript expectations.
- Static Type Checking - Provides a statically typed development environment that verifies API compatibility and correctness for the JavaScript ecosystem.
- Frontend Development - Enables the creation of interactive web user interfaces using a statically typed language compiled to JavaScript.
- Full-Stack Development - Allows sharing business logic and data models between server and client by compiling a single codebase for multiple platforms.
- JavaScript Library Integrations - Defines type-safe facade types to integrate and utilize existing JavaScript libraries and global objects.
- WebAssembly Compilation - Produces binary files from source code to enable execution in environments supporting the WebAssembly standard.
- TypeScript Binding Generation - Converts type definition files into facades to provide static typing for JavaScript libraries.
- Frontend Build Tools - Includes a build tool for bundling, optimizing, and minimizing JavaScript output for production web deployments.
- Bundle Size Optimization - Reduces the footprint of generated JavaScript for production deployments using external optimization tools.
- Dead Code Elimination - Analyzes the call graph to remove unused code and optimize the final production bundle size.
- Development Refreshers - Detects changes in source files and updates the output instantly to shorten the development cycle.
- Static Analysis Editors - Provides real-time type errors and method signatures directly within the editor to improve development productivity.
- Prototype-to-Class Mappings - Maps static class definitions to JavaScript prototypes to ensure compatibility with native object-oriented behavior.
- Class Extensions - Adds new methods to existing types or classes using implicit extension mechanisms to maintain type safety.
- Deferred Parameter Evaluation - Delays the computation of a function argument until the value is actually accessed within the function body.
- Shared Class Exporting - Marks shared code with annotations to make it accessible from JavaScript while providing compatibility stubs.
- Execution Optimizations - Optimizes runtime speed by rewriting iterators as loops and applying function inlining during compilation.
- External Module Imports - Links internal definitions to specific exports of external modules using standard module loading semantics.
- Module Emission Formats - Produces code as CommonJS or ECMAScript modules to integrate with modern toolchains.
- JavaScript Optimizers and Minifiers - Utilizes specialized linking and minification tools to reduce JavaScript file sizes and increase execution speed.
- Cross-Language Primitive Mappings - Maps high-level Scala types to the closest matching JavaScript primitives and collection structures.
- Object Structure Matching - Extracts values from nested data structures using pattern matching to replace traditional conditional logic.
- Tail-Call Optimizations - Converts tail-recursive functions into iterative loops during compilation to prevent stack overflows in JavaScript engines.
- Dependency Resolution - Resolves libraries compiled for JavaScript while distinguishing them from other binaries to ensure compatibility.
- Optimized Artifact Validation - Verifies that production-ready, fully optimized build artifacts behave correctly by running dedicated test suites.
- Reactive User Interfaces - Supports building visual layouts using a reactive flow to synchronize interface state with underlying data.
- Asynchronous Module Loading - Implements dynamic imports to split compiled code into separate files for on-demand loading at runtime.
- Node.js Server Frameworks - Supports building server-side tools and applications that execute within the Node.js runtime.
- DOM Element Typing - Checks HTML tags and attributes during the build process to prevent runtime crashes via static typing.
- Code Splitting - Implements techniques for dividing the compiled output into smaller chunks to optimize loading and shared code.
- Production Asset Bundling - Optimizes and minimizes compiled files into a single production-ready bundle for deployment.
- JavaScript Interop - Compiler for targeting JavaScript from Scala.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
