Crate rkyv_js_codegen 

rkyv-js-codegen

TypeScript codec-binding generator for rkyv types, targeting the rkyv-js runtime.

The generator parses Rust sources with syn, extracts every type marked with #[derive(Archive)] (or a custom marker), and emits one export const Archived{Name} = ... codec per type. TypeScript types are always derived from the codecs via r.Infer<typeof Archived{Name}>.

build.rs

use rkyv_js_codegen::CodeGenerator;

fn main() -> Result<(), rkyv_js_codegen::Error> {
    CodeGenerator::new()
        .add_source_file("src/lib.rs")?
        .write_to_file("generated/bindings.ts")?;

    println!("cargo:rerun-if-changed=src/lib.rs");
    Ok(())
}

Expressions instead of format strings

Codec expressions are a typed tree (CodecExpr) with builders that mirror the runtime combinators (codec):

use rkyv_js_codegen::{CodeGenerator, codec};

let mut generator = CodeGenerator::new();
generator.add_struct("Person", [
    ("name", codec::string()),
    ("age", codec::u32()),
    ("email", codec::option(codec::string())),
]);
let code = generator.generate()?;
assert!(code.contains("email: r.option(r.string),"));

Extending the registry

External crate types are registered by fully-qualified Rust path:

use rkyv_js_codegen::{CodeGenerator, CodecExpr, ExternalType, WithWrapper};

let mut generator = CodeGenerator::new();

// `my_crate::MyVec<T>` → `myVec(T)` from a custom module.
generator.register_external(
    "my_crate::MyVec",
    ExternalType::generic1(|t| {
        CodecExpr::call(CodecExpr::import_from("my-package/codecs", "myVec"), [t])
    }),
);

// `#[rkyv(with = AsJson)]` fields → a hand-written codec.
generator.register_with(
    "AsJson",
    WithWrapper::replace(CodecExpr::import_from("./custom.ts", "asJson")),
);

Error handling

Parse failures surface immediately from add_source_*; everything else is validated in CodeGenerator::generate, which aggregates all Diagnostics into a single Error::Codegen. Set OnUnknown::SkipContainingType to emit cargo:warnings and omit affected types instead of failing.

Modules

codec

Builders mirroring the rkyv-js runtime combinators.

Structs

CodeGenerator

Collects type definitions — from Rust sources or programmatically — and generates TypeScript codec bindings for the rkyv-js runtime.

Diagnostic

A single code-generation problem with optional provenance.

ExternalType

A codec template for an external Rust type.

Import

A named import contributed by a CodecExpr::Import node.

SourceLocation

A position in a parsed source file.

WithWrapper

A handler for a #[rkyv(with = W)] field wrapper.

Enums

CodecExpr

A TypeScript codec expression.

DiagnosticKind

The kinds of code-generation diagnostics.

Direction

Which half of the codec surface the generated bindings target.

EnumVariant

An enum variant for CodeGenerator::add_enum.

Error

Top-level error type for the code generator.

OnUnknown

How to handle a field whose type cannot be mapped to a codec.

Functions

generate_import_block

Generate the import block for a set of expressions.