import 'package:fjs/fjs.dart'; Future<void> main() async { await LibFjs.init(); runApp(MyApp()); }

// Create runtime with built-in options final runtime = await JsAsyncRuntime.withOptions( builtin: JsBuiltinOptions( fetch: true, console: true, timers: true, ), ); // Create context final context = await JsAsyncContext.from(runtime); // Create engine with bridge support final engine = JsEngine(context); await engine.init(bridgeCall: (jsValue) { // Handle bridge calls from JavaScript print('Bridge call from JS: ${jsValue.value}'); return JsValue.string('Response from Dart'); });

// Simple evaluation final result = await engine.eval(JsCode.code('1 + 2')); print(result.value); // 3 // Async JavaScript final asyncResult = await engine.eval(JsCode.code('''  (async () => {  const response = await fetch('https://api.example.com/data');  return await response.json();  })() '''));

// Built-in modules are enabled during runtime creation // Now you can use fetch, console.log, setTimeout, etc. await engine.eval(JsCode.code('''  console.log('Hello from JavaScript!');  setTimeout(() => console.log('Delayed message'), 1000); '''));

// Declare a single module const moduleCode = ''' export function greet(name) {  return `Hello, ${name}!`; }  export const version = '1.0.0'; '''; await engine.declareNewModule( JsModule.code(module: 'greeting', code: moduleCode) ); // Declare multiple modules at once await engine.declareNewModules([ JsModule.code('math', 'export const add = (a, b) => a + b;'), JsModule.code('string', 'export const reverse = (s) => s.split("").reverse().join("");'), ]); // Check if specific modules are declared final isMathDeclared = await engine.isModuleDeclared('math'); final isUtilsDeclared = await engine.isModuleDeclared('utils'); print('Math module declared: $isMathDeclared'); // true print('Utils module declared: $isUtilsDeclared'); // false // Get all declared modules final declaredModules = await engine.getDeclaredModules(); print('Available modules: $declaredModules'); // Output: Available modules: [greeting, math, string] // Use the modules await engine.eval(JsCode.code('''  import { greet, version } from 'greeting';  import { add } from 'math';  import { reverse } from 'string';    console.log(greet('Flutter'));  console.log('Version:', version);  console.log('Add 2 + 3:', add(2, 3));  console.log('Reverse hello:', reverse('hello')); '''));

// Dart side final engine = JsEngine(context); await engine.init(bridgeCall: (jsValue) async { final data = jsValue.value; // Process data in Dart if (data is Map && data['action'] == 'fetchUserData') { final userId = data['userId']; final userData = await fetchUserFromDatabase(userId); return JsValue.from(userData); } return const JsValue.none(); }); // JavaScript side await engine.eval(JsCode.code('''  const userData = await fjs.bridge_call({  action: 'fetchUserData',  userId: 12345  });  console.log('User data:', userData); '''));

// Set memory limits final runtime = JsAsyncRuntime(); await runtime.setMemoryLimit(50 * 1024 * 1024); // 50MB await runtime.setGcThreshold(10 * 1024 * 1024); // 10MB // Monitor memory usage final usage = await runtime.memoryUsage(); print('Memory used: ${usage.memoryUsedSize} bytes'); // Force garbage collection await runtime.runGc();

try { final result = await engine.eval(JsCode.code('invalid.syntax()')); } on JsError catch (e) { print('JavaScript Error: ${e.message}'); } catch (e) { print('Other Error: $e'); }

// Load from file final result = await engine.eval(JsCode.path('/path/to/script.js')); // Or use evalFile method on context final context = await JsAsyncContext.from(rt: runtime); final result = await context.evalFile(path: '/path/to/script.js');

class JsEngine { // Initialize the engine Future<void> init({FutureOr<JsValue?> Function(JsValue)? bridgeCall}); // Execute JavaScript code Future<JsValue> eval(JsCode source, {JsEvalOptions? options, Duration? timeout}); // Module operations Future<JsValue> declareNewModule(JsModule module, {Duration? timeout}); Future<JsValue> declareNewModules(List<JsModule> modules, {Duration? timeout}); Future<JsValue> evaluateModule(JsModule module, {Duration? timeout}); Future<JsValue> clearNewModules({Duration? timeout}); // Cleanup Future<void> dispose(); // Status bool get disposed; bool get running; bool get initialized; }

sealed class JsValue { // Constructors const factory JsValue.none(); const factory JsValue.boolean(bool value); const factory JsValue.integer(int value); const factory JsValue.float(double value); const factory JsValue.string(String value); const factory JsValue.array(List<JsValue> value); const factory JsValue.object(Map<String, JsValue> value); // Convert from Dart object static JsValue from(Object? any); // Get Dart value dynamic get value; // Type checking bool get isNone; bool get isBoolean; bool get isInteger; // ... other type checkers }