@libp2p/interface 2.11.0-8484de8a2 → 2.11.0-87bc8d4fb

package/src/connection-protector.ts

@@ -1,9 +0,0 @@
-import type { AbortOptions, MessageStream } from './index.ts'
-
-export interface ConnectionProtector {
-  /**
-   * Takes a MessageStream and creates a private encryption stream between
-   * the two peers from the shared key the Protector instance was created with.
-   */
-  protect (connection: MessageStream, options?: AbortOptions): Promise<MessageStream>
-}

package/src/events.ts

@@ -1,44 +0,0 @@
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-/**
- * A custom implementation of MessageEvent as the Undici version does too much
- * validation in it's constructor so is very slow.
- */
-export class StreamMessageEvent extends Event {
-  public data: Uint8Array | Uint8ArrayList
-
-  constructor (data: Uint8Array | Uint8ArrayList, eventInitDict?: EventInit) {
-    super('message', eventInitDict)
-
-    this.data = data
-  }
-}
-
-/**
- * An event dispatched when the stream is closed. The `error` property can be
- * inspected to discover if the closing was graceful or not, and the `remote`
- * property shows which end of the stream initiated the closure
- */
-export class StreamCloseEvent extends Event {
-  public error?: Error
-  public local?: boolean
-
-  constructor (local?: boolean, error?: Error, eventInitDict?: EventInit) {
-    super('close', eventInitDict)
-
-    this.error = error
-    this.local = local
-  }
-}
-
-export class StreamAbortEvent extends StreamCloseEvent {
-  constructor (error: Error, eventInitDict?: EventInit) {
-    super(true, error, eventInitDict)
-  }
-}
-
-export class StreamResetEvent extends StreamCloseEvent {
-  constructor (error: Error, eventInitDict?: EventInit) {
-    super(false, error, eventInitDict)
-  }
-}

package/src/message-stream.ts

@@ -1,168 +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 an 'error' event emitted.
-   */
-  maxReadBufferLength: 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>
-}