Cocoar.JsEval.Engine 3.3.0

Cocoar.JsEval

JavaScript/TypeScript execution library for .NET, built on Jint.

Features

• JavaScript execution via Jint (ES2025 support)
• Execution methods: ExecuteAsync(string) / ExecuteAsync(prepared module) (standard), Evaluate(string) / Evaluate(prepared), EvaluateAsync()
• Pre-parsed scripts (Prepare() / PrepareModule()) for maximum throughput
• TypeScript 6.0 transpilation with embedded compiler
• fetch() API with opt-in sandboxing
• Automatic .NET Task → JS Promise interop
• console.log/warn/error/debug via ILogger
• setTimeout/setInterval support
• Extensible module system (HTTP, Database, SMTP, Templates, and more)
• .d.ts generation for IntelliSense support
• Built for .NET 10

Quick Start

dotnet add package Cocoar.JsEval.Engine

Basic JavaScript Execution

services.AddJsEval();

var engine = sp.GetRequiredService<JsEngine>();
engine.SetValue("name", "World");
engine.Evaluate("var greeting = 'Hello, ' + name + '!';");
var result = engine.GetValue<string>("greeting"); // "Hello, World!"

With ES Modules

services.AddJsEval(b => b
    .AddModule<CommonModule>()
    .AddModule<HttpModule>()
);

var engine = sp.GetRequiredService<JsEngine>();
await engine.ExecuteAsync(@"
    import * as common from 'common';
    export function newId() { return common.Guid.New().toString(); }
");
var id = engine.InvokeFunction("newId"); // fresh GUID each call

ES-module semantics: top-level code runs once per unique script on a given engine — repeated ExecuteAsync calls return the cached module namespace. Put per-call work inside exported functions and invoke them via InvokeFunction. For true per-call re-execution use the lightweight Evaluate(string) path.

Pre-Parsed Scripts (for repeated execution)

// Parse once (thread-safe, cacheable)
var prepared = JsEngine.Prepare("query.WhereResponsible(ctx.UserId);");

// Execute many times — no re-parsing
engine.SetValue("ctx", accessContext);
engine.SetValue("query", queryBuilder);
engine.Evaluate(prepared);

TypeScript Transpilation

dotnet add package Cocoar.JsEval.TypeScript

services.AddTsTranspiler();

var transpiler = sp.GetRequiredService<TsTranspiler>();
var js = transpiler.Transpile(tsCode);  // transpile once
await engine.ExecuteAsync(js);          // execute

fetch()

services.AddJsEval(b => b.EnableFetch());

const response = await fetch('https://api.example.com/data');
const body = await response.text();
console.log(response.status, response.ok);

.NET async → JS Promise (automatic)

engine.SetValue("loadData", new Func<string, Task<string>>(async id => {
    return await db.FindAsync(id);
}));

const data = await loadData('item-123'); // .NET Task becomes a Promise

Execution Methods

ExecuteAsync is the default/standard method -- it provides the full module system and is always safe. Evaluate is a conscious opt-in for a restricted execution mode -- choose it when you know your scripts don't need modules.

Packages

License

Apache-2.0 — COCOAR e.U.