🥮 mooncakes.io

    #mizchi/js_web/streams

    Streams API for processing data incrementally.

    #Installation

    Add to your moon.mod:

    import {
  "mizchi/js_web@0.13.0",
}

    ...and to the moon.pkg of the package that uses it:

    import {
  "mizchi/js_web/streams",
}

    #Overview

    Provides bindings for the Streams API: ReadableStream, WritableStream, and TransformStream.

    #Usage Example

    fn main {
      // Create a readable stream
      let readable = @streams.ReadableStream()

      // Get a reader
      let reader = readable.get_reader()

      // Create a writable stream
      let writable = @streams.WritableStream()

      // Get a writer
      let writer = writable.get_writer()

      // Create a transform stream
      let transform = @streams.TransformStream()

      // Pipe streams
      // readable.pipe_to(writable)
    }

    #Available Types

    • ReadableStream - Stream of data to read
    • WritableStream - Stream to write data to
    • TransformStream - Transform data in a stream
    • Compression/Decompression - gzip, deflate streams

    #Reference

    CompressionStream

    source
    pub(all) struct CompressionStream {
      readable : ReadableStream
      writable : WritableStream
    }

    CompressionStream is a TransformStream that compresses data using gzip, deflate, or deflate-raw https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream

    CompressionStream::CompressionStream

    source
    fn CompressionStream::CompressionStream(format : String) -> CompressionStream

    Create a new CompressionStream with the specified format

    Supported formats:
    • "gzip" - GZIP compression
    • "deflate" - DEFLATE compression (with zlib wrapper)
    • "deflate-raw" - DEFLATE compression (without wrapper)

    Example:
    let _compressor = CompressionStream("gzip")

    CompressionStream::as_any

    source

    CompressionStream::new

    source
    #deprecated("use `CompressionStream(..)` instead")
    fn CompressionStream::new(format : String) -> CompressionStream

    Deprecated alias for the CompressionStream(..) constructor.

    DecompressionStream

    source
    pub(all) struct DecompressionStream {
      readable : ReadableStream
      writable : WritableStream
    }

    DecompressionStream is a TransformStream that decompresses data using gzip, deflate, or deflate-raw https://developer.mozilla.org/en-US/docs/Web/API/DecompressionStream

    DecompressionStream::DecompressionStream

    source
    fn DecompressionStream::DecompressionStream(format : String) -> DecompressionStream

    Create a new DecompressionStream with the specified format

    Supported formats:
    • "gzip" - GZIP decompression
    • "deflate" - DEFLATE decompression (with zlib wrapper)
    • "deflate-raw" - DEFLATE decompression (without wrapper)

    Example:
    let _decompressor = DecompressionStream("gzip")

    DecompressionStream::as_any

    source

    DecompressionStream::new

    source
    #deprecated("use `DecompressionStream(..)` instead")
    fn DecompressionStream::new(format : String) -> DecompressionStream

    Deprecated alias for the DecompressionStream(..) constructor.

    ReadableStream

    source
    #external
    pub type ReadableStream

    ReadableStream represents a readable stream of byte data https://developer.mozilla.org/ja/docs/Web/API/ReadableStream

    ReadableStream::ReadableStream

    source
    fn ReadableStream::ReadableStream(underlying_source : 
    Any    ) -> ReadableStream

    Create a new ReadableStream with an underlying source

    ReadableStream::as_any

    source

    ReadableStream::cancel

    source
    async fn ReadableStream::cancel(self : ReadableStream, reason? : 
    Any    ) -> Unit

    Cancel the stream

    ReadableStream::getReader

    source
    #alias(get_reader)
    fn ReadableStream::getReader(self : ReadableStream) -> ReadableStreamDefaultReader

    Get a reader for this stream

    ReadableStream::locked

    source
    fn ReadableStream::locked(self : ReadableStream) -> Bool

    Check if the stream is locked

    ReadableStream::new

    source
    #deprecated("use `ReadableStream(..)` instead")
    fn ReadableStream::new(underlying_source : 
    Any    ) -> ReadableStream

    Deprecated alias for the ReadableStream(..) constructor.

    ReadableStream::pipeThrough

    source
    #alias(pipe_through)
    fn ReadableStream::pipeThrough(self : ReadableStream, transform : 
    Any    , options? : 
    Any    ) -> ReadableStream

    Pipe through a transform stream

    ReadableStream::pipeTo

    source
    #alias(pipe_to)
    async fn ReadableStream::pipeTo(self : ReadableStream, destination : WritableStream, options? : 
    Any    ) -> Unit

    Pipe this stream to a WritableStream

    ReadableStream::tee

    source

    Tee this stream into two branches

    ReadableStreamDefaultReader

    source
    #external
    pub type ReadableStreamDefaultReader

    ReadableStreamDefaultReader represents a default reader for reading from a ReadableStream

    ReadableStreamDefaultReader::as_any

    source

    ReadableStreamDefaultReader::cancel

    source

    Cancel the stream

    ReadableStreamDefaultReader::closed

    source

    Get the closed promise

    ReadableStreamDefaultReader::read

    source

    Read a chunk from the stream

    ReadableStreamDefaultReader::releaseLock

    source
    #alias(release_lock)
    fn ReadableStreamDefaultReader::releaseLock(self : ReadableStreamDefaultReader) -> Unit

    Release the reader's lock on the stream

    TransformStream

    source
    #external
    pub type TransformStream

    TransformStream represents a transform stream for piping data through a transformation

    TransformStream::TransformStream

    source
    fn TransformStream::TransformStream(transformer : 
    Any    ) -> TransformStream

    Create a new TransformStream with a transformer

    TransformStream::as_any

    source

    TransformStream::identity

    source
    #alias(newIdentity)
    fn TransformStream::identity() -> TransformStream

    Create a new identity TransformStream (passes data through unmodified)

    TransformStream::new

    source
    #deprecated("use `TransformStream(..)` instead")
    fn TransformStream::new(transformer : 
    Any    ) -> TransformStream

    Deprecated alias for the TransformStream(..) constructor.

    TransformStream::new_identity

    source
    #deprecated("use `TransformStream::identity()` instead")
    fn TransformStream::new_identity() -> TransformStream

    Deprecated alias for TransformStream::identity().

    TransformStream::readable

    source

    Get the readable side of the transform stream

    TransformStream::writable

    source

    Get the writable side of the transform stream

    WritableStream

    source
    #external
    pub type WritableStream

    WritableStream represents a writable stream

    WritableStream::WritableStream

    source
    fn WritableStream::WritableStream(underlying_sink : 
    Any    ) -> WritableStream

    Create a new WritableStream with an underlying sink

    WritableStream::abort

    source
    async fn WritableStream::abort(self : WritableStream, reason? : 
    Any    ) -> Unit

    Abort the stream

    WritableStream::as_any

    source

    WritableStream::close

    source
    async fn WritableStream::close(self : WritableStream) -> Unit

    Close the stream

    WritableStream::getWriter

    source
    #alias(get_writer)
    fn WritableStream::getWriter(self : WritableStream) -> WritableStreamDefaultWriter

    Get a writer for this stream

    WritableStream::locked

    source
    fn WritableStream::locked(self : WritableStream) -> Bool

    Check if the stream is locked

    WritableStream::new

    source
    #deprecated("use `WritableStream(..)` instead")
    fn WritableStream::new(underlying_sink : 
    Any    ) -> WritableStream

    Deprecated alias for the WritableStream(..) constructor.

    WritableStreamDefaultWriter

    source
    #external
    pub type WritableStreamDefaultWriter

    WritableStreamDefaultWriter represents a default writer for writing to a WritableStream

    WritableStreamDefaultWriter::abort

    source

    Abort the writer

    WritableStreamDefaultWriter::as_any

    source

    WritableStreamDefaultWriter::close

    source

    Close the writer

    WritableStreamDefaultWriter::closed

    source

    Get the closed promise

    WritableStreamDefaultWriter::desiredSize

    source

    Get the desired size

    WritableStreamDefaultWriter::ready

    source

    Get the ready promise

    WritableStreamDefaultWriter::releaseLock

    source
    #alias(release_lock)
    fn WritableStreamDefaultWriter::releaseLock(self : WritableStreamDefaultWriter) -> Unit

    Release the writer's lock on the stream

    WritableStreamDefaultWriter::write

    source

    Write a chunk to the stream

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io