@libp2p/interface 2.11.0-6059227cb → 2.11.0-87bc8d4fb

package/src/message-stream.ts

@@ -1,183 +0,0 @@
-import type { Logger, StreamCloseEvent, StreamMessageEvent, TypedEventTarget, AbortOptions } from './index.js'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-/**
- * The direction of the message stream
- */
-export type MessageStreamDirection = 'inbound' | 'outbound'
-
-/**
- * The states a message stream can be in
- */
-export type MessageStreamStatus = 'open' | 'closing' | 'closed' | 'aborted' | 'reset'
-
-/**
- * The states the readable end of a message stream can be in
- */
-export type MessageStreamReadStatus = 'readable' | 'paused' | 'closing' | 'closed'
-
-/**
- * The states the writable end of a message stream can be in
- */
-export type MessageStreamWriteStatus = 'writable' | 'closing' | 'closed'
-
-/**
- * An object that records the times of various events
- */
-export interface MessageStreamTimeline {
-  /**
-   * A timestamp of when the message stream was opened
-   */
-  open: number
-
-  /**
-   * A timestamp of when the message stream was closed for both reading and
-   * writing by both ends of the stream
-   */
-  close?: number
-}
-
-export interface MessageStreamEvents {
-  /**
-   * Data was received from the remote end of the message stream
-   */
-  message: StreamMessageEvent
-
-  /**
-   * The local send buffer has emptied and the stream may be written to once
-   * more, unless it is currently closing.
-   */
-  drain: Event
-
-  /**
-   * The underlying resource is closed - no further events will be emitted and
-   * the stream cannot be used to send or receive any more data.
-   *
-   * When the `.error` field is set, the `local` property of the event will be
-   * `true` value if the `.abort` was invoked, otherwise it means a remote error
-   * occurred and the peer sent a reset signal.
-   */
-  close: StreamCloseEvent
-
-  /**
-   * Where the stream implementation supports half-closing, it may emit this
-   * event when the remote end of the stream closes it's writable end.
-   *
-   * After this event is received no further 'message' events will be emitted
-   * though the stream can still be written to, if it has not been closed at
-   * this end.
-   */
-  remoteCloseWrite: Event
-
-  /**
-   * The outgoing write queue emptied - there are no more bytes queued for
-   * sending to the remote end of the stream.
-   */
-  idle: Event
-}
-
-export interface MessageStream<Timeline extends MessageStreamTimeline = MessageStreamTimeline> extends TypedEventTarget<MessageStreamEvents>, AsyncIterable<Uint8Array | Uint8ArrayList> {
-  /**
-   * The current status of the message stream
-   */
-  status: MessageStreamStatus
-
-  /**
-   * Timestamps of when stream events occurred
-   */
-  timeline: Timeline
-
-  /**
-   * A logging implementation that can be used to log stream-specific messages
-   */
-  log: Logger
-
-  /**
-   * Whether this stream is inbound or outbound
-   */
-  direction: MessageStreamDirection
-
-  /**
-   * The maximum number of bytes to store when paused. If receipt of more bytes
-   * from the remote end of the stream causes the buffer size to exceed this
-   * value the stream will be reset and a 'close' event emitted.
-   *
-   * This value can be changed at runtime.
-   */
-  maxReadBufferLength: number
-
-  /**
-   * When the `.send` method returns false it means that the underlying resource
-   * has signalled that it's write buffer is full. If the user continues to call
-   * `.send`, outgoing bytes are stored in an internal buffer until the
-   * underlying resource signals that it can accept more data.
-   *
-   * If the size of that internal buffer exceed this value the stream will be
-   * reset and a 'close' event emitted.
-   *
-   * This value can be changed at runtime.
-   */
-  maxWriteBufferLength?: number
-
-  /**
-   * If no data is transmitted over the stream in this many ms, the stream will
-   * be aborted with an InactivityTimeoutError
-   */
-  inactivityTimeout: number
-
-  /**
-   * If this property is `true`, the underlying transport has signalled that its
-   * write buffer is full and that `.send` should not be called again.
-   *
-   * A `drain` event will be emitted after which is its safe to call `.send`
-   * again to resume sending.
-   */
-  writableNeedsDrain: boolean
-
-  /**
-   * Write data to the stream. If the method returns false it means the
-   * internal buffer is now full and the caller should wait for the 'drain'
-   * event before sending more data.
-   *
-   * This method may throw if:
-   * - The internal send buffer is full
-   * - The stream has previously been closed for writing locally or remotely
-   */
-  send (data: Uint8Array | Uint8ArrayList): boolean
-
-  /**
-   * Stop accepting new data to send and return a promise that resolves when any
-   * unsent data has been written into the underlying resource.
-   */
-  close (options?: AbortOptions): Promise<void>
-
-  /**
-   * Stop accepting new data to send, discard any unsent/unread data, and emit a
-   * 'close' event with the 'error' property set to the passed error.
-   */
-  abort (err: Error): void
-
-  /**
-   * Stop emitting further 'message' events. Any received data will be stored in
-   * an internal buffer. If the buffer size reaches `maxReadBufferLength`, the
-   * stream will be reset and a StreamAbortEvent emitted.
-   *
-   * If the underlying resource supports it, the remote peer will be instructed
-   * to pause transmission of further data.
-   */
-  pause (): void
-
-  /**
-   * Resume emitting 'message' events.
-   *
-   * If the underlying resource supports it, the remote peer will be informed
-   * that it is ok to start sending data again.
-   */
-  resume (): void
-
-  /**
-   * Queue the passed data to be emitted as a 'message' event either during the
-   * next tick or sooner if data is received from the underlying resource.
-   */
-  push (buf: Uint8Array | Uint8ArrayList): void
-}

package/src/multiaddr-connection.ts

@@ -1,27 +0,0 @@
-import type { MessageStream, MessageStreamTimeline } from './message-stream.ts'
-import type { Multiaddr } from '@multiformats/multiaddr'
-
-export interface MultiaddrConnectionTimeline extends MessageStreamTimeline {
-  /**
-   * When the MultiaddrConnection was upgraded to a Connection - the type of
-   * connection encryption and multiplexing was negotiated.
-   */
-  upgraded?: number
-}
-
-/**
- * A MultiaddrConnection is returned by a transport after dialing a peer. It is
- * a low-level primitive and is the raw connection, typically without encryption
- * or stream multiplexing.
- */
-export interface MultiaddrConnection extends MessageStream<MultiaddrConnectionTimeline> {
-  /**
-   * The address of the remote end of the connection
-   */
-  remoteAddr: Multiaddr
-
-  /**
-   * When stream life cycle events occurred
-   */
-  timeline: MultiaddrConnectionTimeline
-}

package/src/stream.ts

@@ -1,70 +0,0 @@
-import type { AbortOptions } from './index.ts'
-import type { MessageStream, MessageStreamReadStatus, MessageStreamWriteStatus } from './message-stream.js'
-
-/**
- * A Stream is a lightweight data channel between two peers that can be written
- * to and read from at both ends.
- *
- * It is half-closable - that is in order for it to be closed fully and any
- * associated memory reclaimed, both ends must close their writeable end of the
- * stream.
- *
- * It's also possible to close the readable end of the stream, but this depends
- * on the underlying stream muxer supporting this operation which not all do.
- */
-export interface Stream extends MessageStream {
-  /**
-   * Unique identifier for a stream. Identifiers are not unique across muxers.
-   */
-  id: string
-
-  /**
-   * The protocol negotiated for this stream
-   */
-  protocol: string
-
-  /**
-   * The status of the readable end of the stream
-   */
-  readStatus: MessageStreamReadStatus
-
-  /**
-   * The status of the writable end of the stream
-   */
-  writeStatus: MessageStreamWriteStatus
-
-  /**
-   * The status of the readable end of the remote end of the stream - n.b. this
-   * requires the underlying stream transport to support sending STOP_SENDING
-   * messages or similar.
-   */
-  remoteReadStatus: MessageStreamReadStatus
-
-  /**
-   * The status of the writable end of the remote end of the stream
-   */
-  remoteWriteStatus: MessageStreamWriteStatus
-
-  /**
-   * Close stream for writing and return a promise that resolves once any
-   * pending data has been passed to the underlying transport.
-   *
-   * Note that the stream itself will remain readable until the remote end also
-   * closes it's writable end.
-   *
-   * To close without waiting for the remote, call `.abort` instead. If you want
-   * to wait for data to be sent first, ensure if the `.writableStatus` property
-   * is not 'paused', if it is, wait for a `drain` event before aborting.
-   */
-  close (options?: AbortOptions): Promise<void>
-
-  /**
-   * Send a message to the remote end of the stream informing them that any
-   * incoming data will be discarded so they should stop sending.
-   *
-   * This requires the underlying resource to support this operation - for
-   * example the QUIC, WebTransport, WebRTC transports do but anything
-   * multiplexed using Yamux or Mplex do not.
-   */
-  closeRead(options?: AbortOptions): Promise<void>
-}