Struct JsGenerator 

pub struct JsGenerator { /* private fields */ }

JavaScript code generator implementing the CodeGenerator trait.

Implementations

impl JsGenerator

pub fn new() -> Self

Creates a new JavaScript code generator.

Trait Implementations

impl CodeGenerator for JsGenerator

fn generate_project( &self, modules: &[(&AIRModule, &Path)], ) -> Result<GeneratedCode, CodegenError>

Emit a per-module native ES-module import tree (spec §20.6.1; DQ19 resolved): each module the entry program reaches through a real use is emitted to its own .js file, and cross-module references resolve through real ESM import { … } from "./…". This is the sole bock build output path.

Output-path mapping is keyed on each module’s declared path, not its on-disk source path, so the file layout and the import specifier agree: module core.option ⇒ core/option.js and import … from "./core/option.js". The entry module (the one declaring main, else the last in dependency order) is always emitted as main.js so the run model is stable.

To run under node main.js, the emitted tree is ESM (relative specifiers carry .js, declarations use export); the minimal package.json {"type":"module"} run affordance — which makes Node treat the .js files as ES modules — is emitted by the scaffolder in project mode (S6a / DV18), not by codegen, so --source-only output is bare source. The concurrency and range runtime helpers are emitted once into a shared _bock_runtime.js (see RUNTIME_MODULE_JS); every module that references one imports the helpers it needs.

fn generate_tests( &self, modules: &[(&AIRModule, &Path)], framework: &str, ) -> Result<TestArtifacts, CodegenError>

Transpile @test functions into a Vitest/Jest bock.test.js file (S7).

framework selects the idiom: "jest" uses Jest’s global describe/ it/expect; anything else uses Vitest (import { describe, it, expect } from "vitest"). Both share the expect(actual).toEqual/toBe(...) API, so the per-assertion lowering is identical; only the framework import differs. The functions under test are imported by name from their emitted modules.

fn target(&self) -> &TargetProfile

Returns the target profile for this generator.

fn generate_module( &self, module: &AIRModule, ) -> Result<GeneratedCode, CodegenError>

Generates target code from a fully-lowered AIR module.

fn entry_invocation(&self, main_is_async: bool) -> Option<String>

Returns the source-code snippet that invokes the user’s main function as the entry point for this target, or None if the target has a native entry-point convention (Rust fn main, Go func main) that runs without a synthetic call.

fn needs_ai_synthesis(&self, node: &AIRNode) -> bool

Returns true when the given AIR node should go through Tier 1 AI synthesis (§17.2, Q3 amended).

impl Debug for JsGenerator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for JsGenerator

fn default() -> Self

Returns the “default value” for a type.