Struct Exporter 

#[non_exhaustive]
pub struct Exporter {
    pub header: Cow<'static, str>,
    pub bigint: BigIntExportBehavior,
    pub layout: Layout,
    pub serde: Option<SerdeMode>,
    /* private fields */
}

Typescript language exporter.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

header: Cow<'static, str>

Custom header prepended to exported files.

bigint: BigIntExportBehavior

Strategy for exporting Rust bigint-compatible primitives.

layout: Layout

Output layout mode for generated TypeScript.

serde: Option<SerdeMode>

Optional Serde compatibility processing mode.

Implementations

impl Exporter

pub fn framework_prelude(self, prelude: impl Into<Cow<'static, str>>) -> Self

Provide a prelude which is added to the start of all exported files.

pub fn framework_runtime( self, builder: impl Fn(FrameworkExporter<'_>) -> Result<Cow<'static, str>, Error> + Send + Sync + 'static, ) -> Self

Add some custom Typescript or Javascript code that is exported as part of the bindings. It’s appending to the types file for single-file layouts or put in a root index.{ts/js} for multi-file.

The closure is wrapped in [specta::datatype::collect()] to capture any referenced types. Ensure you call T::reference() within the closure if you want an import to be created.

pub fn branded_type_impl( self, builder: impl for<'a> Fn(BrandedTypeExporter<'a>, &Branded) -> Result<Cow<'static, str>, Error> + Send + Sync + 'static, ) -> Self

Configure how specta_typescript::branded! types are rendered with exporter context.

This callback receives both the branded payload and a BrandedTypeExporter, allowing you to call BrandedTypeExporter::inline / BrandedTypeExporter::reference while preserving the current export configuration.

Examples

ts-brand style:

let exporter = Typescript::default().branded_type_impl(|ctx, branded| {
    let datatype = ctx.inline(branded.ty())?;

    Ok(Cow::Owned(format!(
        "import(\"ts-brand\").Brand<{}, \"{}\">",
        datatype,
        branded.brand()
    )))
});

Effect style:

let exporter = Typescript::default().branded_type_impl(|ctx, branded| {
    let datatype = ctx.inline(branded.ty())?;

    Ok(Cow::Owned(format!(
        "{} & import(\"effect\").Brand.Brand<\"{}\">",
        datatype,
        branded.brand()
    )))
});

pub fn header(self, header: impl Into<Cow<'static, str>>) -> Self

Configure a header for the file.

This is perfect for configuring lint ignore rules or other file-level comments.

pub fn bigint(self, bigint: BigIntExportBehavior) -> Self

Configure the BigInt handling behaviour

pub fn layout(self, layout: Layout) -> Self

Configure the bindings layout

pub fn with_serde(self, mode: SerdeMode) -> Self

Configure the exporter to use specta-serde with the specified mode

pub fn with_serde_serialize(self) -> Self

Configure the exporter to export the types for #[derive(serde::Serialize)]

pub fn with_serde_deserialize(self) -> Self

Configure the exporter to export the types for #[derive(serde::Deserialize)]

pub fn export(&self, types: &TypeCollection) -> Result<String, Error>

Export the files into a single string.

Note: This returns an error if the format is Format::Files.

pub fn export_to( &self, path: impl AsRef<Path>, types: &TypeCollection, ) -> Result<(), Error>

Export the types to a specific file/folder.

When configured when format is Format::Files, you must provide a directory path. Otherwise, you must provide the path of a single file.

Trait Implementations

impl AsMut<Exporter> for Exporter

fn as_mut(&mut self) -> &mut Exporter

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Exporter> for JSDoc

fn as_mut(&mut self) -> &mut Exporter

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Exporter> for Typescript

fn as_mut(&mut self) -> &mut Exporter

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Exporter> for BrandedTypeExporter<'_>

fn as_ref(&self) -> &Exporter

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Exporter> for Exporter

fn as_ref(&self) -> &Exporter

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Exporter> for FrameworkExporter<'_>

fn as_ref(&self) -> &Exporter

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Exporter> for JSDoc

fn as_ref(&self) -> &Exporter

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Exporter> for Typescript

fn as_ref(&self) -> &Exporter

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Exporter

fn clone(&self) -> Exporter

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Exporter

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

Formats the value using the given formatter.

impl From<Exporter> for JSDoc

fn from(value: Exporter) -> Self

Converts to this type from the input type.

impl From<Exporter> for Typescript

fn from(value: Exporter) -> Self

Converts to this type from the input type.

impl From<JSDoc> for Exporter

fn from(value: JSDoc) -> Self

Converts to this type from the input type.

impl From<Typescript> for Exporter

fn from(value: Typescript) -> Self

Converts to this type from the input type.