@macroforge/mcp-server 0.1.30 → 0.1.31

package/docs/custom-macros/ts-quote/quick-reference.md

@@ -1,83 +1,131 @@
 ## Quick Reference
 
 | `@{expr}` 
-| Interpolate a Rust expression (adds space after) 
-
-| `{| content |}` 
-| Ident block: concatenates without spaces (e.g., `{|get@{name}|}` → `getUser`) 
-
-| `&#123;> comment <&#125;` 
-| Block comment: outputs `/* comment */` 
-
-| `&#123;>> doc <<&#125;` 
-| Doc comment: outputs `/** doc */` (for JSDoc) 
-
-| `@@&#123;` 
-| Escape for literal `@&#123;` (e.g., `"@@&#123;foo&#125;"` → `@&#123;foo&#125;`) 
-
-| `"text @&#123;expr&#125;"` 
-| String interpolation (auto-detected) 
-
-| `"'^template $&#123;js&#125;^'"` 
-| JS backtick template literal (outputs ``template $&#123;js&#125;``) 
-
-| `&#123;#if cond&#125;...&#123;/if&#125;` 
-| Conditional block 
-
-| `&#123;#if cond&#125;...&#123;:else&#125;...&#123;/if&#125;` 
-| Conditional with else 
-
-| `&#123;#if a&#125;...&#123;:else if b&#125;...&#123;:else&#125;...&#123;/if&#125;` 
-| Full if/else-if/else chain 
-
-| `&#123;#if let pattern = expr&#125;...&#123;/if&#125;` 
-| Pattern matching if-let 
-
-| `&#123;#match expr&#125;&#123;:case pattern&#125;...&#123;/match&#125;` 
-| Match expression with case arms 
-
-| `&#123;#for item in list&#125;...&#123;/for&#125;` 
-| Iterate over a collection 
-
-| `&#123;#while cond&#125;...&#123;/while&#125;` 
-| While loop 
-
-| `&#123;#while let pattern = expr&#125;...&#123;/while&#125;` 
-| While-let pattern matching loop 
-
-| `&#123;$let name = expr&#125;` 
-| Define a local constant 
-
-| `&#123;$let mut name = expr&#125;` 
-| Define a mutable local variable 
-
-| `&#123;$do expr&#125;` 
-| Execute a side-effectful expression 
-
-| `&#123;$typescript stream&#125;` 
-| Inject a TsStream, preserving its source and runtime_patches (imports)
-
-**Note:** A single `@` not followed by `&#123;` passes through unchanged (e.g., `email@domain.com` works as expected).
-
-## Interpolation: `@&#123;expr&#125;`
-
-Insert Rust expressions into the generated TypeScript:
-
-```rust
-let class_name = "User";
-let method = "toString";
-
-let code = ts_template! {
-    @{class_name}.prototype.@{method} = function() {
-        return "User instance";
-    };
-};
-```
-
-**Generates:**
-
-```typescript
-User.prototype.toString = function () {
-  return "User instance";
-};
-```
+            | Interpolate a Rust expression (adds space after) 
+        
+
+        
+            | `&#123;| content |&#125;` 
+            | Ident block: concatenates without spaces (e.g., <code
+                    >&#123;|get@&#123;name&#125;|&#125;</code
+                >
+                → `getUser`)</td
+            >
+        
+
+        
+            <td>`&#123;> "comment" <&#125;` 
+            | Block comment: outputs `/* comment */` (string preserves
+                whitespace)</td
+            >
+        
+
+        
+            <td>`&#123;>> "doc" <<&#125;` 
+            | Doc comment: outputs `/** doc */` (string preserves whitespace)</td
+            >
+        
+
+        
+            <td>`@@&#123;` 
+            | Escape for literal `@&#123;` (e.g.,
+                `"@@&#123;foo&#125;"`
+                → `@&#123;foo&#125;`)</td
+            >
+        
+
+        
+            <td>`"text @&#123;expr&#125;"` 
+            | String interpolation (auto-detected) 
+        
+
+        
+            | `"'^template $&#123;js&#125;^'"` 
+            | JS backtick template literal (outputs <code
+                    >`template $&#123;js&#125;`</code
+                >)</td
+            >
+        
+
+        
+            <td>`&#123;#if cond&#125;...&#123;/if&#125;` 
+            | Conditional block 
+        
+
+        
+            | <code
+                    >&#123;#if cond&#125;...&#123;:else&#125;...&#123;/if&#125;</code
+                ></td
+            >
+            <td>Conditional with else 
+        
+
+        
+            | <code
+                    >&#123;#if a&#125;...&#123;:else if
+                    b&#125;...&#123;:else&#125;...&#123;/if&#125;</code
+                ></td
+            >
+            <td>Full if/else-if/else chain 
+        
+
+        
+            | <code
+                    >&#123;#if let pattern = expr&#125;...&#123;/if&#125;</code
+                ></td
+            >
+            <td>Pattern matching if-let 
+        
+
+        
+            | <code
+                    >&#123;#match expr&#125;&#123;:case
+                    pattern&#125;...&#123;/match&#125;</code
+                ></td
+            >
+            <td>Match expression with case arms 
+        
+
+        
+            | <code>&#123;#for item in list&#125;...&#123;/for&#125;</code
+                ></td
+            >
+            <td>Iterate over a collection 
+        
+
+        
+            | `&#123;#while cond&#125;...&#123;/while&#125;` 
+            | While loop 
+        
+
+        
+            | <code
+                    >&#123;#while let pattern = expr&#125;...&#123;/while&#125;</code
+                ></td
+            >
+            <td>While-let pattern matching loop 
+        
+
+        
+            | `&#123;$let name = expr&#125;` 
+            | Define a local constant 
+        
+
+        
+            | `&#123;$let mut name = expr&#125;` 
+            | Define a mutable local variable 
+        
+
+        
+            | `&#123;$do expr&#125;` 
+            | Execute a side-effectful expression 
+        
+
+        
+            | `&#123;$typescript stream&#125;` 
+            <td
+                >Inject a TsStream, preserving its source and runtime_patches
+                (imports)</td
+            >
+
+**Note:** A single `@` not followed by `&#123;` passes through unchanged (e.g., `email@domain.com` works as expected).

package/docs/custom-macros/ts-quote/side-effects-do.md

@@ -16,8 +16,72 @@ Common uses for `{$do}`:
 
 - Incrementing counters: `{$do i += 1}`
 
-- Building collections: `{$do vec.push(item)}`
+    - Building collections: `{$do vec.push(item)}`
 
-- Setting flags: `{$do found = true}`
+    - Setting flags: `{$do found = true}`
 
-- Any mutating operation
+    - Any mutating operation
+
+<h2 id="typescript-injection">
+    TsStream Injection: `&#123;$typescript&#125;`
+</h2>
+
+Inject another TsStream into your template, preserving both its source code and runtime patches (like imports added via `add_import()`):
+
+```rust
+// Create a helper method with its own import
+let mut helper = body! {
+    validateEmail(email: string): boolean {
+        return Result.ok(true);
+    }
+};
+helper.add_import("Result", "macroforge/utils");
+
+// Inject the helper into the main template
+let result = body! {
+    {$typescript helper}
+
+    process(data: Record<string, unknown>): void {
+        // ...
+    }
+};
+// result now includes helper's source AND its Result import
+```
+
+This is essential for composing multiple macro outputs while preserving imports and patches:
+
+```rust
+let extra_methods = if include_validation {
+    Some(body! {
+        validate(): boolean { return true; }
+    })
+} else {
+    None
+};
+
+body! {
+    mainMethod(): void {}
+
+    {#if let Some(methods) = extra_methods}
+        {$typescript methods}
+    {/if}
+}
+```
+
+## Escape Syntax
+
+If you need a literal `@&#123;` in your output (not interpolation), use `@@&#123;`:
+
+```rust
+ts_template! {
+    // This outputs a literal @{foo}
+    const example = "Use @@{foo} for templates";
+}
+```
+
+**Generates:**
+
+```typescript
+// This outputs a literal @{foo}
+const example = "Use @{foo} for templates";
+```

package/docs/custom-macros/ts-quote/tsstream-injection-typescript.md

@@ -9,7 +9,7 @@ let mut helper = body! {
         return Result.ok(true);
     }
 };
-helper.add_import("Result", "macroforge/result");
+helper.add_import("Result", "macroforge/utils");
 
 // Inject the helper into the main template
 let result = body! {

package/docs/custom-macros/ts-quote/while-loops-while.md

@@ -45,37 +45,4 @@ let code = ts_template! {
         result.@{next_field.name} = this.@{next_field.name};
     {/while}
 };
-```
-
-## Local Constants: `{$let}`
-
-Define local variables within the template scope:
-
-```rust
-let items = vec![("user", "User"), ("post", "Post")];
-
-let code = ts_template! {
-    {#for (key, class_name) in items}
-        {$let upper = class_name.to_uppercase()}
-        console.log("Processing @{upper}");
-        const @{key} = new @{class_name}();
-    {/for}
-};
-```
-
-This is useful for computing derived values inside loops without cluttering the Rust code.
-
-## Mutable Variables: `{$let mut}`
-
-When you need to modify a variable within the template (e.g., in a `while` loop), use `{$let mut}`:
-
-```rust
-let code = ts_template! {
-    {$let mut count = 0}
-    {#for item in items}
-        console.log("Item @{count}: @{item}");
-        {$do count += 1}
-    {/for}
-    console.log("Total: @{count}");
-};
 ```