@rsvelte/compiler 0.1.0

package/README.md

@@ -0,0 +1,183 @@
+# rsvelte
+
+A high-performance Rust implementation of the Svelte compiler. Drop-in replacement for `svelte/compiler` with up to 100x performance improvement.
+
+## Installation
+
+```bash
+npm install @rsvelte/compiler
+```
+
+## Usage
+
+### Basic Usage
+
+```js
+import { compile, parse, VERSION } from '@rsvelte/compiler';
+
+const result = compile('<h1>Hello {name}!</h1>', {
+  filename: 'App.svelte',
+  generate: 'client',
+});
+
+console.log(result.js.code);
+```
+
+### With Vite + vite-plugin-svelte
+
+Use `resolve.alias` to replace the Svelte compiler:
+
+```js
+// vite.config.js
+import { defineConfig } from 'vite';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      'svelte/compiler': '@rsvelte/compiler',
+    },
+  },
+  plugins: [svelte()],
+});
+```
+
+## API
+
+### `compile(source, options?)`
+
+Compile a Svelte component to JavaScript.
+
+```js
+const result = compile(source, {
+  dev: false,
+  generate: 'client', // 'client' | 'server'
+  filename: 'Component.svelte',
+  css: 'external', // 'injected' | 'external'
+  // ... see CompileOptions for all options
+});
+
+// result.js.code - Generated JavaScript
+// result.js.map - Source map
+// result.css?.code - Generated CSS (if css: 'external')
+// result.css?.map - CSS source map
+// result.warnings - Compiler warnings
+// result.metadata.runes - Whether component uses runes
+```
+
+### `compileModule(source, options?)`
+
+Compile a Svelte module (`.svelte.js` / `.svelte.ts`).
+
+```js
+const result = compileModule(source, {
+  dev: false,
+  generate: 'client',
+  filename: 'utils.svelte.js',
+});
+```
+
+### `parse(source, options?)`
+
+Parse a Svelte component into an AST.
+
+```js
+const ast = parse('<h1>Hello</h1>', {
+  modern: true, // Use modern AST format
+});
+```
+
+### `preprocess(source, preprocessors, options?)`
+
+Preprocess a Svelte component (async).
+
+```js
+const processed = await preprocess(source, [
+  {
+    markup({ content, filename }) {
+      return { code: transformedContent };
+    },
+    script({ content, filename }) {
+      return { code: transformedContent };
+    },
+    style({ content, filename }) {
+      return { code: transformedContent };
+    },
+  },
+], { filename: 'App.svelte' });
+```
+
+### `print(ast, options?)`
+
+Print an AST back to source code.
+
+```js
+const ast = parse(source, { modern: true });
+const { code } = print(ast);
+```
+
+### `parseCss(source)`
+
+Parse CSS into an AST.
+
+### `VERSION`
+
+The compiler version string.
+
+```js
+import { VERSION } from '@rsvelte/compiler';
+console.log(VERSION); // "0.1.0"
+```
+
+## Limitations
+
+### Callback Options Not Supported
+
+The following options accept JavaScript callback functions and are **not currently supported** in rsvelte. These options will be silently ignored, and the default behavior will be used instead:
+
+| Option | Description | Default Behavior |
+|--------|-------------|-----------------|
+| `cssHash` | Custom function to generate CSS hash for scoping | Uses the built-in hash function (same algorithm as the official Svelte compiler default) |
+| `warningFilter` | Function to filter compiler warnings | All warnings are included in the result |
+
+**Why?** rsvelte is implemented in Rust and compiled to a native binary. JavaScript callback functions cannot be directly executed inside the Rust runtime. Supporting these would require crossing the Rust-JavaScript boundary for each invocation, which would negate the performance benefits.
+
+**Workaround for `warningFilter`:** Filter warnings from the result after compilation:
+
+```js
+const result = compile(source, options);
+const filteredWarnings = result.warnings.filter(
+  (w) => w.code !== 'a11y-missing-attribute'
+);
+```
+
+**Workaround for `cssHash`:** Currently no workaround. The default hash function is used. If you require a custom hash, please open an issue.
+
+### Not Yet Implemented
+
+| API | Status |
+|-----|--------|
+| `migrate()` | Not implemented - throws error |
+| `walk()` | Deprecated in Svelte 5 - throws error directing to estree-walker |
+
+## Platform Support
+
+rsvelte ships native binaries for the following platforms:
+
+| Platform | Architecture | Package |
+|----------|-------------|---------|
+| macOS | ARM64 (Apple Silicon) | `@rsvelte/binding-darwin-arm64` |
+| macOS | x64 (Intel) | `@rsvelte/binding-darwin-x64` |
+| Linux | x64 | `@rsvelte/binding-linux-x64-gnu` |
+| Linux | ARM64 | `@rsvelte/binding-linux-arm64-gnu` |
+| Windows | x64 | `@rsvelte/binding-win32-x64-msvc` |
+
+Native binaries are installed automatically via `optionalDependencies`. If no native binary is available for your platform, an error will be thrown at runtime.
+
+## Svelte Compatibility
+
+rsvelte targets compatibility with **Svelte 5** (`svelte/compiler`). It passes 100% of the official Svelte compiler test suite (3028/3028 tests).
+
+## License
+
+MIT

package/index.cjs

@@ -0,0 +1,79 @@
+'use strict';
+
+const { createRequire } = require('node:module');
+
+let nativeBinding = null;
+let loadError = null;
+
+const platform = process.platform;
+const arch = process.arch;
+
+const platformPackages = {
+  'darwin-arm64': '@rsvelte/binding-darwin-arm64',
+  'darwin-x64': '@rsvelte/binding-darwin-x64',
+  'linux-x64': '@rsvelte/binding-linux-x64-gnu',
+  'linux-arm64': '@rsvelte/binding-linux-arm64-gnu',
+  'win32-x64': '@rsvelte/binding-win32-x64-msvc',
+};
+
+const key = `${platform}-${arch}`;
+const packageName = platformPackages[key];
+
+if (packageName) {
+  try {
+    nativeBinding = require(packageName);
+  } catch (e) {
+    loadError = e;
+  }
+} else {
+  loadError = new Error(`Unsupported platform: ${key}`);
+}
+
+function getBinding() {
+  if (nativeBinding) return nativeBinding;
+  throw new Error(
+    `rsvelte native binding not available for this platform. ` +
+    `Ensure the correct @rsvelte/binding-* package is installed. ` +
+    `Error: ${loadError?.message}`
+  );
+}
+
+module.exports.compile = function compile(source, options = {}) {
+  return getBinding().compile(source, options);
+};
+
+module.exports.compileModule = function compileModule(source, options = {}) {
+  return getBinding().compileModule(source, options);
+};
+
+module.exports.parse = function parse(source, options = {}) {
+  return getBinding().parse(source, options);
+};
+
+module.exports.preprocess = async function preprocess(source, preprocessor, options = {}) {
+  return getBinding().preprocess(source, preprocessor, options);
+};
+
+module.exports.print = function print(ast, options = {}) {
+  return getBinding().print(ast, options);
+};
+
+module.exports.parseCss = function parseCss(source) {
+  return getBinding().parseCss(source);
+};
+
+module.exports.walk = function walk() {
+  throw new Error(
+    'walk() is deprecated. Use estree-walker instead: https://github.com/Rich-Harris/estree-walker'
+  );
+};
+
+module.exports.migrate = function migrate() {
+  throw new Error('migrate() is not yet implemented in rsvelte.');
+};
+
+try {
+  module.exports.VERSION = nativeBinding?.getVersion?.() ?? '0.1.0';
+} catch {
+  module.exports.VERSION = '0.1.0';
+}

package/index.d.ts

@@ -0,0 +1,140 @@
+export interface CompileOptions {
+  /** Enable dev mode */
+  dev?: boolean;
+  /** Generate client or server code */
+  generate?: 'client' | 'server' | false;
+  /** Component filename */
+  filename?: string;
+  /** Root directory */
+  rootDir?: string;
+  /** Component name */
+  name?: string;
+  /** Enable custom element mode */
+  customElement?: boolean;
+  /** Enable accessors */
+  accessors?: boolean;
+  /** HTML namespace */
+  namespace?: 'html' | 'svg' | 'mathml';
+  /** Enable immutable mode */
+  immutable?: boolean;
+  /** CSS mode */
+  css?: 'injected' | 'external';
+  /**
+   * Custom CSS hash function.
+   *
+   * **Note:** Currently not supported in @rsvelte/compiler. The default hash function
+   * will always be used. See README for details.
+   */
+  cssHash?: (args: { hash: (input: string) => string; css: string; name: string; filename: string | undefined }) => string;
+  /** Preserve HTML comments */
+  preserveComments?: boolean;
+  /** Preserve whitespace */
+  preserveWhitespace?: boolean;
+  /** Enable runes mode */
+  runes?: boolean;
+  /** Disclose compiler version in output */
+  discloseVersion?: boolean;
+  /** Source map configuration */
+  sourcemap?: object | string;
+  /** Output JS filename */
+  outputFilename?: string;
+  /** Output CSS filename */
+  cssOutputFilename?: string;
+  /** Enable HMR */
+  hmr?: boolean;
+  /** Use modern AST */
+  modernAst?: boolean;
+  /**
+   * Warning filter function.
+   *
+   * **Note:** Currently not supported in @rsvelte/compiler. All warnings will be
+   * included. See README for details.
+   */
+  warningFilter?: (warning: Warning) => boolean;
+  /** Experimental options */
+  experimental?: {
+    async?: boolean;
+  };
+  /** Compatibility options */
+  compatibility?: {
+    componentApi?: 4 | 5;
+  };
+}
+
+export interface ModuleCompileOptions {
+  dev?: boolean;
+  generate?: 'client' | 'server' | false;
+  filename?: string;
+  rootDir?: string;
+}
+
+export interface Warning {
+  code: string;
+  message: string;
+  start?: { line: number; column: number; character: number };
+  end?: { line: number; column: number; character: number };
+}
+
+export interface CompileResult {
+  js: { code: string; map: any };
+  css: { code: string; map: any; hasGlobal: boolean } | null;
+  warnings: Warning[];
+  metadata: { runes: boolean };
+  ast?: any;
+}
+
+export interface PrintResult {
+  code: string;
+  map?: any;
+}
+
+export interface Processed {
+  code: string;
+  map?: any;
+  dependencies?: string[];
+}
+
+/**
+ * Compile a Svelte component.
+ */
+export function compile(source: string, options?: CompileOptions): CompileResult;
+
+/**
+ * Compile a Svelte module (.svelte.js / .svelte.ts).
+ */
+export function compileModule(source: string, options?: ModuleCompileOptions): CompileResult;
+
+/**
+ * Parse a Svelte component into an AST.
+ */
+export function parse(source: string, options?: { modern?: boolean; loose?: boolean }): any;
+
+/**
+ * Parse CSS.
+ */
+export function parseCss(source: string): any;
+
+/**
+ * Preprocess a Svelte component.
+ */
+export function preprocess(source: string, preprocessor: any | any[], options?: { filename?: string }): Promise<Processed>;
+
+/**
+ * Print an AST back to source code.
+ */
+export function print(ast: any, options?: any): PrintResult;
+
+/**
+ * Compiler version.
+ */
+export const VERSION: string;
+
+/**
+ * @deprecated Use estree-walker instead.
+ */
+export function walk(): never;
+
+/**
+ * Not yet implemented in @rsvelte/compiler.
+ */
+export function migrate(): never;

package/index.js

@@ -0,0 +1,133 @@
+// rsvelte - High-performance Svelte compiler
+// Native binding with WASM fallback
+
+import { createRequire } from 'node:module';
+
+let nativeBinding = null;
+let loadError = null;
+
+function loadNativeBinding() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const platformPackages = {
+    'darwin-arm64': '@rsvelte/binding-darwin-arm64',
+    'darwin-x64': '@rsvelte/binding-darwin-x64',
+    'linux-x64': '@rsvelte/binding-linux-x64-gnu',
+    'linux-arm64': '@rsvelte/binding-linux-arm64-gnu',
+    'win32-x64': '@rsvelte/binding-win32-x64-msvc',
+  };
+
+  const key = `${platform}-${arch}`;
+  const packageName = platformPackages[key];
+
+  if (!packageName) {
+    loadError = new Error(`Unsupported platform: ${key}`);
+    return null;
+  }
+
+  try {
+    const require = createRequire(import.meta.url);
+    return require(packageName);
+  } catch (e) {
+    loadError = e;
+    return null;
+  }
+}
+
+nativeBinding = loadNativeBinding();
+
+function getBinding() {
+  if (nativeBinding) return nativeBinding;
+  throw new Error(
+    `rsvelte native binding not available for this platform. ` +
+    `Ensure the correct @rsvelte/binding-* package is installed. ` +
+    `Error: ${loadError?.message}`
+  );
+}
+
+/**
+ * Compile a Svelte component.
+ * @param {string} source - Svelte component source code
+ * @param {object} [options] - Compilation options
+ * @returns {object} Compilation result with js, css, warnings, and metadata
+ */
+export function compile(source, options = {}) {
+  return getBinding().compile(source, options);
+}
+
+/**
+ * Compile a Svelte module (.svelte.js/.svelte.ts).
+ * @param {string} source - Module source code
+ * @param {object} [options] - Compilation options
+ * @returns {object} Compilation result
+ */
+export function compileModule(source, options = {}) {
+  return getBinding().compileModule(source, options);
+}
+
+/**
+ * Parse a Svelte component into an AST.
+ * @param {string} source - Svelte component source code
+ * @param {object} [options] - Parse options
+ * @returns {object} AST
+ */
+export function parse(source, options = {}) {
+  return getBinding().parse(source, options);
+}
+
+/**
+ * Preprocess a Svelte component.
+ * NOTE: This is an async function.
+ * @param {string} source - Svelte component source code
+ * @param {object|object[]} preprocessor - Preprocessor(s)
+ * @param {object} [options] - Preprocess options
+ * @returns {Promise<object>} Preprocessed result
+ */
+export async function preprocess(source, preprocessor, options = {}) {
+  return getBinding().preprocess(source, preprocessor, options);
+}
+
+/**
+ * Print an AST back to source code.
+ * @param {object} ast - Svelte AST
+ * @param {object} [options] - Print options
+ * @returns {object} Print result with code and map
+ */
+export function print(ast, options = {}) {
+  return getBinding().print(ast, options);
+}
+
+/**
+ * Parse CSS.
+ * @param {string} source - CSS source code
+ * @returns {object} Parsed CSS AST
+ */
+export function parseCss(source) {
+  return getBinding().parseCss(source);
+}
+
+/**
+ * @deprecated Use estree-walker instead.
+ */
+export function walk() {
+  throw new Error(
+    'walk() is deprecated. Use estree-walker instead: https://github.com/Rich-Harris/estree-walker'
+  );
+}
+
+/**
+ * Not yet implemented in rsvelte.
+ */
+export function migrate() {
+  throw new Error('migrate() is not yet implemented in rsvelte.');
+}
+
+/** Compiler version string. */
+let _version;
+try {
+  _version = nativeBinding?.getVersion?.() ?? '0.1.0';
+} catch {
+  _version = '0.1.0';
+}
+export const VERSION = _version;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@rsvelte/compiler",
+  "version": "0.1.0",
+  "description": "A high-performance Rust implementation of the Svelte compiler - drop-in replacement",
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.cjs"
+    }
+  },
+  "files": [
+    "index.js",
+    "index.cjs",
+    "index.d.ts",
+    "README.md"
+  ],
+  "optionalDependencies": {
+    "@rsvelte/binding-darwin-arm64": "0.1.0",
+    "@rsvelte/binding-darwin-x64": "0.1.0",
+    "@rsvelte/binding-linux-x64-gnu": "0.1.0",
+    "@rsvelte/binding-linux-arm64-gnu": "0.1.0",
+    "@rsvelte/binding-win32-x64-msvc": "0.1.0"
+  },
+  "keywords": [
+    "svelte",
+    "compiler",
+    "rust",
+    "napi",
+    "performance"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/baseballyama/svelte-compiler-rust"
+  },
+  "engines": {
+    "node": ">= 18"
+  }
+}