@macroforge/svelte-preprocessor 0.1.78 → 0.1.80

package/README.md

@@ -1,37 +1,10 @@
 # @macroforge/svelte-preprocessor
 
-Svelte preprocessor for expanding Macroforge macros in component script blocks
-
 [![npm version](https://badge.fury.io/js/%40macroforge%2Fsvelte-preprocessor.svg)](https://www.npmjs.com/package/@macroforge/svelte-preprocessor)
 
 ## Overview
 
-@macroforge/svelte-preprocessor
-
-Svelte preprocessor for expanding Macroforge macros in component script blocks.
-
-This module provides integration between Macroforge's macro expansion system and
-Svelte's preprocessing pipeline. It intercepts `<script>` blocks in `.svelte`
-files, detects `@derive` decorators, and expands them into generated code before
-TypeScript compilation occurs.
-
-## How It Works
-
-1. The preprocessor is registered in `svelte.config.js` as part of the
-   preprocess array
-2. When Svelte compiles a component, it passes each `<script>` block to this
-   preprocessor
-3. The preprocessor checks if the script contains `@derive` decorators
-4. If found, it calls the native `macroforge` binding to expand the macros
-5. The expanded code replaces the original script content
-
-## Important Notes
-
-- Must be placed BEFORE other preprocessors (like `vitePreprocess()`) in the
-  chain
-- Uses lazy-loading for native bindings to avoid initialization overhead
-- Gracefully degrades if native bindings are unavailable
-- Only processes TypeScript blocks by default (configurable via options)
+Svelte preprocessor for expanding Macroforge macros in component script blocks
 
 ## Installation
 
@@ -43,23 +16,17 @@ npm install @macroforge/svelte-preprocessor
 
 ### Functions
 
-- **`macroforgePreprocess`** - Whether to preserve `@derive` decorators in the
-  expanded output.
+- **`macroforgePreprocess`** - Creates a Svelte preprocessor that expands
+  Macroforge macros in `<script>` blocks.
 
-### Types
+### Interfaces
 
-- **`ExpandResult`** - Whether to preserve `@derive` decorators in the expanded
-  output.
 - **`MacroforgePreprocessorOptions`** - Configuration options for the Macroforge
   Svelte preprocessor.
 
-## Examples
+### Constants
 
-```typescript
-macroforgePreprocess();
-macroforgePreprocess({ keepDecorators: true });
-macroforgePreprocess({ processJavaScript: true });
-```
+- **`default`** - Default export for convenient importing.
 
 ## Documentation
 

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAgB,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAyIvE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;;;;;;;;OAUG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;;;;;;;;;OAaG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,GAAE,6BAAkC,GAC1C,iBAAiB,CA2JnB;AAED;;;;;;;GAOG;AACH,eAAe,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAgB,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AA6OvE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;;;;;;;;OAUG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;;;;;;;;;OAaG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,GAAE,6BAAkC,GAC1C,iBAAiB,CAoJnB;AAED;;;;;;;GAOG;AACH,eAAe,oBAAoB,CAAC"}

package/dist/index.js

@@ -25,7 +25,95 @@
  *
  * @packageDocumentation
  */
-import { hasMacroAnnotations } from "@macroforge/shared";
+// ============================================================================
+// Source Map Generation
+// ============================================================================
+const VLQ_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function vlqEncode(value) {
+    let vlq = value < 0 ? (-value << 1) | 1 : value << 1;
+    let encoded = "";
+    do {
+        let digit = vlq & 0x1f;
+        vlq >>>= 5;
+        if (vlq > 0)
+            digit |= 0x20;
+        encoded += VLQ_CHARS[digit];
+    } while (vlq > 0);
+    return encoded;
+}
+/** Build line offsets table: lineOffsets[i] = byte offset of the start of line i */
+function buildLineOffsets(text) {
+    const offsets = [0];
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === "\n")
+            offsets.push(i + 1);
+    }
+    return offsets;
+}
+/** Convert byte offset to { line, column } (0-based) */
+function offsetToLineCol(offset, lineOffsets) {
+    let lo = 0, hi = lineOffsets.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if (lineOffsets[mid] <= offset)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return { line: lo, column: offset - lineOffsets[lo] };
+}
+/**
+ * Build a v3 source map from macroforge's segment-based mapping.
+ * Each segment maps a byte range in the expanded code to a byte range in the original.
+ */
+function buildSourceMap(original, expanded, mapping, filename) {
+    const origOffsets = buildLineOffsets(original);
+    const expOffsets = buildLineOffsets(expanded);
+    // Group segments by expanded line
+    const lineSegments = new Map();
+    for (const seg of mapping.segments) {
+        const exp = offsetToLineCol(seg.expandedStart, expOffsets);
+        const orig = offsetToLineCol(seg.originalStart, origOffsets);
+        if (!lineSegments.has(exp.line))
+            lineSegments.set(exp.line, []);
+        lineSegments.get(exp.line).push({
+            expCol: exp.column,
+            origLine: orig.line,
+            origCol: orig.column,
+        });
+    }
+    // Encode VLQ mappings
+    const totalLines = expOffsets.length;
+    const mappingsArr = [];
+    let prevOrigLine = 0, prevOrigCol = 0;
+    for (let line = 0; line < totalLines; line++) {
+        const segs = lineSegments.get(line);
+        if (!segs || segs.length === 0) {
+            mappingsArr.push("");
+            continue;
+        }
+        segs.sort((a, b) => a.expCol - b.expCol);
+        const parts = [];
+        let lineExpCol = 0;
+        for (const seg of segs) {
+            parts.push(vlqEncode(seg.expCol - lineExpCol) +
+                vlqEncode(0) + // source index (always 0)
+                vlqEncode(seg.origLine - prevOrigLine) +
+                vlqEncode(seg.origCol - prevOrigCol));
+            lineExpCol = seg.expCol;
+            prevOrigLine = seg.origLine;
+            prevOrigCol = seg.origCol;
+        }
+        mappingsArr.push(parts.join(","));
+    }
+    return {
+        version: 3,
+        sources: [filename],
+        sourcesContent: [original],
+        names: [],
+        mappings: mappingsArr.join(";"),
+    };
+}
 /**
  * Cached reference to the native `expandSync` function from the macroforge package.
  *
@@ -182,14 +270,7 @@ export function macroforgePreprocess(options = {}) {
         /*
          * STEP 2: Quick Scan Optimization
          *
-         * Before loading native bindings, do a cheap string check for "@derive".
-         * Most components won't have macros, so this saves the cost of loading
-         * and calling the native expansion engine in the common case.
-         */
-        if (!hasMacroAnnotations(content)) {
-            return;
-        }
-        /*
+         /*
          * STEP 3: Load Native Bindings
          *
          * The expansion engine is a native module (Rust compiled to Node addon).
@@ -238,11 +319,12 @@ export function macroforgePreprocess(options = {}) {
              * - map: Source map for debugging (optional, not yet implemented)
              */
             if (result.code && result.code !== content) {
-                return {
-                    code: result.code,
-                    // TODO: Add source map support when expandSync provides mappings
-                    // map: result.source_mapping
-                };
+                const mapping = result
+                    .sourceMapping;
+                const map = mapping?.segments?.length && filename
+                    ? buildSourceMap(content, result.code, mapping, filename)
+                    : undefined;
+                return { code: result.code, map };
             }
         }
         catch (error) {

package/package.json

@@ -1,13 +1,19 @@
 {
   "dependencies": {
-    "@macroforge/shared": "^0.1.78",
-    "macroforge": "^0.1.78"
+    "@macroforge/shared": "file:../shared",
+    "macroforge": "file:../../crates/macroforge_ts"
   },
   "description": "Svelte preprocessor for expanding Macroforge macros in component script blocks",
   "devDependencies": {
     "svelte": "^5.43.8",
     "typescript": "^5.9.3"
   },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "files": [
     "dist"
   ],
@@ -28,7 +34,7 @@
   "repository": {
     "directory": "packages/svelte-preprocessor",
     "type": "git",
-    "url": "git+https://github.com/macroforge-ts/svelte-preprocessor.git"
+    "url": "git+https://github.com/macroforge-ts/macroforge-ts.git"
   },
   "scripts": {
     "build": "deno install --node-modules-dir --quiet && deno run -A npm:typescript@5/tsc -p tsconfig.json",
@@ -38,5 +44,5 @@
   },
   "type": "module",
   "types": "dist/index.d.ts",
-  "version": "0.1.78"
+  "version": "0.1.80"
 }