@srcmap/gen-mapping 0.3.3

package/README.md

@@ -0,0 +1,77 @@
+# @srcmap/gen-mapping
+
+[![npm](https://img.shields.io/npm/v/@srcmap/gen-mapping.svg)](https://www.npmjs.com/package/@srcmap/gen-mapping)
+[![CI](https://github.com/fallow-rs/srcmap/actions/workflows/ci.yml/badge.svg)](https://github.com/fallow-rs/srcmap/actions/workflows/ci.yml)
+
+Drop-in replacement for [`@jridgewell/gen-mapping`](https://github.com/jridgewell/gen-mapping) powered by Rust via WebAssembly.
+
+Same API, same types, same behavior. Swap the import and get source map generation backed by Rust under the hood.
+
+## Install
+
+```bash
+npm install @srcmap/gen-mapping
+```
+
+## Usage
+
+```js
+// Before:
+// import { GenMapping, addMapping, toEncodedMap } from '@jridgewell/gen-mapping'
+
+// After:
+import { GenMapping, addMapping, toEncodedMap } from '@srcmap/gen-mapping'
+
+const map = new GenMapping({ file: 'bundle.js' })
+
+addMapping(map, {
+  generated: { line: 1, column: 0 },
+  source: 'src/app.ts',
+  original: { line: 10, column: 4 },
+  name: 'handleClick',
+  content: 'const handleClick = () => { ... }',
+})
+
+const encoded = toEncodedMap(map)
+
+// Cleanup WASM memory (optional, also via `using` with Symbol.dispose)
+map.free()
+```
+
+## API compatibility
+
+All exports from `@jridgewell/gen-mapping` are supported:
+
+| Export | Description |
+|--------|-------------|
+| `GenMapping` | Main class — creates a new source map builder |
+| `addMapping(map, mapping)` | Add a mapping (1-based lines, 0-based columns) |
+| `maybeAddMapping(map, mapping)` | Add only if it differs from the previous mapping on the same line |
+| `setSourceContent(map, source, content)` | Set source content for a source file |
+| `setIgnore(map, source, ignore?)` | Mark a source as ignored |
+| `toEncodedMap(map)` | Return as encoded source map (VLQ string mappings) |
+| `toDecodedMap(map)` | Return as decoded source map (array mappings) |
+| `allMappings(map)` | Return all mappings as `Mapping[]` |
+| `fromMap(input)` | Construct from an existing source map |
+
+### Line/column convention
+
+Follows `@jridgewell/gen-mapping` conventions:
+- `addMapping` / `maybeAddMapping`: **1-based lines**, 0-based columns
+- Decoded mappings output: **0-based lines**, 0-based columns
+
+## Differences from @jridgewell/gen-mapping
+
+- **WASM memory**: Call `map.free()` when done, or use `using map = new GenMapping(...)` with `Symbol.dispose`
+- **VLQ encoding runs in WASM**: No JS-side encoding overhead
+
+## Part of [srcmap](https://github.com/fallow-rs/srcmap)
+
+High-performance source map tooling written in Rust. See also:
+- [`@srcmap/trace-mapping`](https://www.npmjs.com/package/@srcmap/trace-mapping) - Drop-in for `@jridgewell/trace-mapping` (consumer)
+- [`@srcmap/remapping`](https://www.npmjs.com/package/@srcmap/remapping) - Drop-in for `@ampproject/remapping` (composition)
+- [`@srcmap/generator-wasm`](https://www.npmjs.com/package/@srcmap/generator-wasm) - Lower-level WASM generator API
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,155 @@
+/**
+ * @srcmap/gen-mapping — drop-in replacement for @jridgewell/gen-mapping
+ * powered by Rust via WebAssembly.
+ */
+
+// ── Segment types ────────────────────────────────────────────────
+
+/** A segment with only a generated column (unmapped). */
+export type UnmappedSegment = [generatedColumn: number];
+
+/** A segment with source location but no name. */
+export type MappedSegment = [
+  generatedColumn: number,
+  sourcesIndex: number,
+  sourceLine: number,
+  sourceColumn: number,
+];
+
+/** A segment with source location and name. */
+export type NamedMappedSegment = [
+  generatedColumn: number,
+  sourcesIndex: number,
+  sourceLine: number,
+  sourceColumn: number,
+  namesIndex: number,
+];
+
+export type SourceMapSegment = UnmappedSegment | MappedSegment | NamedMappedSegment;
+
+// ── Source map types ─────────────────────────────────────────────
+
+export interface SourceMapV3 {
+  version: 3;
+  file?: string | undefined;
+  sourceRoot?: string | undefined;
+  sources: string[];
+  sourcesContent?: (string | null)[];
+  names: string[];
+  ignoreList?: number[];
+}
+
+export interface EncodedSourceMap extends SourceMapV3 {
+  mappings: string;
+}
+
+export interface DecodedSourceMap extends SourceMapV3 {
+  mappings: SourceMapSegment[][];
+}
+
+// ── Position types ───────────────────────────────────────────────
+
+export interface Pos {
+  line: number;
+  column: number;
+}
+
+// ── Mapping type ─────────────────────────────────────────────────
+
+export type Mapping =
+  | {
+      generated: Pos;
+      source: undefined;
+      original: undefined;
+      name: undefined;
+    }
+  | {
+      generated: Pos;
+      source: string;
+      original: Pos;
+      name: string;
+    }
+  | {
+      generated: Pos;
+      source: string;
+      original: Pos;
+      name: undefined;
+    };
+
+// ── Options ──────────────────────────────────────────────────────
+
+export interface Options {
+  file?: string | null;
+  sourceRoot?: string | null;
+}
+
+// ── Mapping input ────────────────────────────────────────────────
+
+export interface MappingInput {
+  generated: Pos;
+  source?: string;
+  original?: Pos;
+  name?: string;
+  content?: string | null;
+}
+
+// ── GenMapping class ─────────────────────────────────────────────
+
+export declare class GenMapping {
+  constructor(opts?: Options);
+
+  file: string | undefined;
+  sourceRoot: string | undefined;
+
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+// ── Free functions ───────────────────────────────────────────────
+
+/**
+ * Add a mapping to the source map.
+ * Lines are 1-based, columns are 0-based.
+ */
+export declare function addMapping(map: GenMapping, mapping: MappingInput): void;
+
+/**
+ * Add a mapping only if it differs from the previous mapping on the same line.
+ * Requires mappings to be added in order.
+ */
+export declare function maybeAddMapping(map: GenMapping, mapping: MappingInput): void;
+
+/**
+ * Set the source content for a source file by source name.
+ */
+export declare function setSourceContent(
+  map: GenMapping,
+  source: string,
+  content: string | null,
+): void;
+
+/**
+ * Mark a source as ignored (or not).
+ */
+export declare function setIgnore(map: GenMapping, source: string, ignore?: boolean): void;
+
+/**
+ * Return all mappings as an array of Mapping objects.
+ * Lines are 1-based, columns are 0-based.
+ */
+export declare function allMappings(map: GenMapping): Mapping[];
+
+/**
+ * Return the source map as an encoded source map object (with VLQ string mappings).
+ */
+export declare function toEncodedMap(map: GenMapping): EncodedSourceMap;
+
+/**
+ * Return the source map as a decoded source map object (with decoded mappings array).
+ */
+export declare function toDecodedMap(map: GenMapping): DecodedSourceMap;
+
+/**
+ * Construct a GenMapping from an existing source map input.
+ */
+export declare function fromMap(input: EncodedSourceMap | DecodedSourceMap | string): GenMapping;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@srcmap/gen-mapping",
+  "version": "0.3.3",
+  "description": "Drop-in replacement for @jridgewell/gen-mapping powered by Rust via WebAssembly",
+  "keywords": [
+    "builder",
+    "drop-in",
+    "gen-mapping",
+    "generator",
+    "performance",
+    "source-map",
+    "sourcemap",
+    "wasm",
+    "webassembly"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fallow-rs/srcmap.git"
+  },
+  "files": [
+    "src/",
+    "index.d.ts",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "src/gen-mapping.cjs",
+  "module": "src/gen-mapping.mjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./src/gen-mapping.mjs",
+      "require": "./src/gen-mapping.cjs",
+      "default": "./src/gen-mapping.mjs"
+    }
+  },
+  "scripts": {
+    "test": "node --test __tests__/gen-mapping.test.mjs",
+    "test:cjs": "node --test __tests__/gen-mapping.cjs.test.cjs",
+    "test:coverage": "mkdir -p coverage && node --test --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=coverage/lcov.info --test-reporter=spec --test-reporter-destination=stdout __tests__/gen-mapping.test.mjs"
+  },
+  "dependencies": {
+    "@srcmap/generator-wasm": "0.3.3",
+    "@srcmap/sourcemap-wasm": "0.3.3"
+  }
+}

package/src/gen-mapping-core.cjs

@@ -0,0 +1,334 @@
+"use strict";
+
+const NO_NAME = -1;
+
+const createGenMappingApi = ({ SourceMapGenerator, SourceMap }) => {
+  class GenMapping {
+    constructor({ file, sourceRoot } = {}) {
+      this._wasm = new SourceMapGenerator(file ?? undefined);
+      if (sourceRoot) this._wasm.setSourceRoot(sourceRoot);
+
+      this.file = file ?? undefined;
+      this.sourceRoot = sourceRoot ?? undefined;
+
+      this._sources = [];
+      this._sourceIndexMap = new Map();
+      this._names = [];
+      this._nameIndexMap = new Map();
+      this._sourcesContent = [];
+
+      this._lastLine = -1;
+      this._lastSourcesIndex = -1;
+      this._lastSourceLine = -1;
+      this._lastSourceColumn = -1;
+      this._lastNamesIndex = NO_NAME;
+      this._lastWasSourceless = false;
+    }
+
+    free() {
+      if (this._wasm) {
+        this._wasm.free();
+        this._wasm = null;
+      }
+    }
+
+    [Symbol.dispose]() {
+      this.free();
+    }
+  }
+
+  const putSource = (map, source) => {
+    const existing = map._sourceIndexMap.get(source);
+    if (existing !== undefined) return existing;
+    const idx = map._wasm.addSource(source);
+    map._sources.push(source);
+    map._sourceIndexMap.set(source, idx);
+    if (map._sourcesContent.length <= idx) {
+      map._sourcesContent[idx] = null;
+    }
+    return idx;
+  };
+
+  const putName = (map, name) => {
+    const existing = map._nameIndexMap.get(name);
+    if (existing !== undefined) return existing;
+    const idx = map._wasm.addName(name);
+    map._names.push(name);
+    map._nameIndexMap.set(name, idx);
+    return idx;
+  };
+
+  const addMappingInternal = (skippable, map, mapping) => {
+    const { generated, source, original, name, content } = mapping;
+    const genLine = generated.line - 1;
+    const genColumn = generated.column;
+
+    if (!source) {
+      if (skippable) {
+        if (map._lastLine === genLine && map._lastWasSourceless) return;
+        if (map._lastLine !== genLine) {
+          map._lastLine = genLine;
+          map._lastWasSourceless = true;
+          map._lastSourcesIndex = -1;
+          map._lastSourceLine = -1;
+          map._lastSourceColumn = -1;
+          map._lastNamesIndex = NO_NAME;
+          return;
+        }
+      }
+      map._wasm.addGeneratedMapping(genLine, genColumn);
+      map._lastLine = genLine;
+      map._lastWasSourceless = true;
+      map._lastSourcesIndex = -1;
+      map._lastSourceLine = -1;
+      map._lastSourceColumn = -1;
+      map._lastNamesIndex = NO_NAME;
+      return;
+    }
+
+    const sourcesIndex = putSource(map, source);
+    const sourceLine = original.line - 1;
+    const sourceColumn = original.column;
+    const namesIndex = name ? putName(map, name) : NO_NAME;
+
+    if (content !== undefined && content !== null) {
+      map._sourcesContent[sourcesIndex] = content;
+      map._wasm.setSourceContent(sourcesIndex, content);
+    }
+
+    if (
+      skippable &&
+      map._lastLine === genLine &&
+      !map._lastWasSourceless &&
+      sourcesIndex === map._lastSourcesIndex &&
+      sourceLine === map._lastSourceLine &&
+      sourceColumn === map._lastSourceColumn &&
+      namesIndex === map._lastNamesIndex
+    ) {
+      return;
+    }
+
+    if (namesIndex !== NO_NAME) {
+      map._wasm.addNamedMapping(
+        genLine,
+        genColumn,
+        sourcesIndex,
+        sourceLine,
+        sourceColumn,
+        namesIndex,
+      );
+    } else {
+      map._wasm.addMapping(genLine, genColumn, sourcesIndex, sourceLine, sourceColumn);
+    }
+
+    map._lastLine = genLine;
+    map._lastWasSourceless = false;
+    map._lastSourcesIndex = sourcesIndex;
+    map._lastSourceLine = sourceLine;
+    map._lastSourceColumn = sourceColumn;
+    map._lastNamesIndex = namesIndex;
+  };
+
+  const addMapping = (map, mapping) => {
+    addMappingInternal(false, map, mapping);
+  };
+
+  const maybeAddMapping = (map, mapping) => {
+    addMappingInternal(true, map, mapping);
+  };
+
+  const setSourceContent = (map, source, content) => {
+    const idx = putSource(map, source);
+    map._sourcesContent[idx] = content;
+    if (content != null) {
+      map._wasm.setSourceContent(idx, content);
+    }
+  };
+
+  const setIgnore = (map, source, ignore = true) => {
+    if (!ignore) return;
+    const idx = putSource(map, source);
+    map._wasm.addToIgnoreList(idx);
+  };
+
+  const allMappings = (map) => {
+    const json = map._wasm.toJSON();
+    const parsed = JSON.parse(json);
+    const sm = new SourceMap(json);
+
+    try {
+      const flat = sm.allMappingsFlat();
+      const out = [];
+      const sources = parsed.sources || [];
+      const names = parsed.names || [];
+
+      for (let i = 0; i < flat.length; i += 7) {
+        const genLine = flat[i];
+        const genCol = flat[i + 1];
+        const sourceIdx = flat[i + 2];
+        const origLine = flat[i + 3];
+        const origCol = flat[i + 4];
+        const nameIdx = flat[i + 5];
+
+        const generated = { line: genLine + 1, column: genCol };
+        let source, original, name;
+
+        if (sourceIdx !== -1) {
+          source = sources[sourceIdx];
+          original = { line: origLine + 1, column: origCol };
+          if (nameIdx !== -1) {
+            name = names[nameIdx];
+          }
+        }
+
+        out.push({ generated, source, original, name });
+      }
+
+      return out;
+    } finally {
+      sm.free();
+    }
+  };
+
+  const toEncodedMap = (map) => {
+    const json = map._wasm.toJSON();
+    const parsed = JSON.parse(json);
+
+    return {
+      version: 3,
+      file: parsed.file || undefined,
+      sourceRoot: parsed.sourceRoot || undefined,
+      sources: parsed.sources || [],
+      sourcesContent:
+        parsed.sourcesContent || map._sourcesContent.slice(0, (parsed.sources || []).length),
+      names: parsed.names || [],
+      mappings: parsed.mappings || "",
+      ignoreList: parsed.ignoreList || [],
+    };
+  };
+
+  const toDecodedMap = (map) => {
+    const json = map._wasm.toJSON();
+    const parsed = JSON.parse(json);
+    const sm = new SourceMap(json);
+
+    try {
+      const flat = sm.allMappingsFlat();
+      const lineCount = sm.lineCount;
+      const decoded = [];
+
+      for (let i = 0; i < lineCount; i++) {
+        decoded.push([]);
+      }
+
+      for (let i = 0; i < flat.length; i += 7) {
+        const genLine = flat[i];
+        const genCol = flat[i + 1];
+        const sourceIdx = flat[i + 2];
+        const origLine = flat[i + 3];
+        const origCol = flat[i + 4];
+        const nameIdx = flat[i + 5];
+
+        while (decoded.length <= genLine) decoded.push([]);
+
+        if (sourceIdx === -1) {
+          decoded[genLine].push([genCol]);
+        } else if (nameIdx === -1) {
+          decoded[genLine].push([genCol, sourceIdx, origLine, origCol]);
+        } else {
+          decoded[genLine].push([genCol, sourceIdx, origLine, origCol, nameIdx]);
+        }
+      }
+
+      while (decoded.length > 0 && decoded[decoded.length - 1].length === 0) {
+        decoded.pop();
+      }
+
+      return {
+        version: 3,
+        file: parsed.file || undefined,
+        sourceRoot: parsed.sourceRoot || undefined,
+        sources: parsed.sources || [],
+        sourcesContent:
+          parsed.sourcesContent || map._sourcesContent.slice(0, (parsed.sources || []).length),
+        names: parsed.names || [],
+        mappings: decoded,
+        ignoreList: parsed.ignoreList || [],
+      };
+    } finally {
+      sm.free();
+    }
+  };
+
+  const fromMap = (input) => {
+    const parsed = typeof input === "string" ? JSON.parse(input) : input;
+    const gen = new GenMapping({
+      file: parsed.file,
+      sourceRoot: parsed.sourceRoot,
+    });
+
+    const sources = parsed.sources || [];
+    const names = parsed.names || [];
+    const sourcesContent = parsed.sourcesContent || [];
+
+    for (let i = 0; i < sources.length; i++) {
+      putSource(gen, sources[i]);
+      if (sourcesContent[i] != null) {
+        gen._sourcesContent[i] = sourcesContent[i];
+        gen._wasm.setSourceContent(i, sourcesContent[i]);
+      }
+    }
+
+    for (let i = 0; i < names.length; i++) {
+      putName(gen, names[i]);
+    }
+
+    const json = typeof input === "string" ? input : JSON.stringify(input);
+    const sm = new SourceMap(json);
+
+    try {
+      const flat = sm.allMappingsFlat();
+
+      for (let i = 0; i < flat.length; i += 7) {
+        const genLine = flat[i];
+        const genCol = flat[i + 1];
+        const sourceIdx = flat[i + 2];
+        const origLine = flat[i + 3];
+        const origCol = flat[i + 4];
+        const nameIdx = flat[i + 5];
+
+        if (sourceIdx === -1) {
+          gen._wasm.addGeneratedMapping(genLine, genCol);
+        } else if (nameIdx === -1) {
+          gen._wasm.addMapping(genLine, genCol, sourceIdx, origLine, origCol);
+        } else {
+          gen._wasm.addNamedMapping(genLine, genCol, sourceIdx, origLine, origCol, nameIdx);
+        }
+      }
+    } finally {
+      sm.free();
+    }
+
+    if (parsed.ignoreList) {
+      for (const idx of parsed.ignoreList) {
+        gen._wasm.addToIgnoreList(idx);
+      }
+    }
+
+    return gen;
+  };
+
+  return {
+    GenMapping,
+    addMapping,
+    maybeAddMapping,
+    setSourceContent,
+    setIgnore,
+    allMappings,
+    toEncodedMap,
+    toDecodedMap,
+    fromMap,
+  };
+};
+
+module.exports = { createGenMappingApi };

package/src/gen-mapping.cjs

@@ -0,0 +1,22 @@
+"use strict";
+
+const { createGenMappingApi } = require("./gen-mapping-core.cjs");
+
+let SourceMapGenerator;
+try {
+  SourceMapGenerator = require("@srcmap/generator-wasm").SourceMapGenerator;
+} catch {
+  // fallow-ignore-next-line unresolved-import
+  const GeneratedSourceMapGenerator =
+    require("../../generator-wasm/pkg/srcmap_generator_wasm.js").SourceMapGenerator;
+  SourceMapGenerator = GeneratedSourceMapGenerator;
+}
+
+let SourceMap;
+try {
+  SourceMap = require("@srcmap/sourcemap-wasm").SourceMap;
+} catch {
+  // fallow-ignore-next-line unresolved-import
+  SourceMap = require("../../sourcemap-wasm/pkg/srcmap_sourcemap_wasm.js").SourceMap;
+}
+module.exports = createGenMappingApi({ SourceMapGenerator, SourceMap });

package/src/gen-mapping.mjs

@@ -0,0 +1,29 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const { createGenMappingApi } = require("./gen-mapping-core.cjs");
+const { SourceMapGenerator } = require("@srcmap/generator-wasm");
+const { SourceMap } = require("@srcmap/sourcemap-wasm");
+const {
+  GenMapping,
+  addMapping,
+  maybeAddMapping,
+  setSourceContent,
+  setIgnore,
+  allMappings,
+  toEncodedMap,
+  toDecodedMap,
+  fromMap,
+} = createGenMappingApi({ SourceMapGenerator, SourceMap });
+
+export {
+  GenMapping,
+  addMapping,
+  maybeAddMapping,
+  setSourceContent,
+  setIgnore,
+  allMappings,
+  toEncodedMap,
+  toDecodedMap,
+  fromMap,
+};