websocketx

type CloseCause struct {
	// CloseFrame it the close frame that cause the closure.
	// If no close frame was received, contains the [StatusAbnormalClosure] code.
	Frame CloseFrame

	// WasClean indicates if the connection is closed after receiving a close frame
	// from the client, or after having sent a close frame.
	//
	// NOTE: This roughly corresponds to the websocket JavaScript API's CloseEvent's wasClean.
	// However in situations where the server sends a close frame, but never receives a response
	// the WasClean field may still be true.
	// This detail is not considered part of the public API of this package, and may change in the future.
	WasClean bool

	// Err contains the error that caused the closure of this connection.
	// This may be an error returned from the read or write end of the connection,
	// or a server-side error.
	//
	// A special value contained in this field is ErrShuttingDown.
	Err error
}

type CloseFrame struct {
	Code   StatusCode
	Reason string
}

type Connection struct {
	// contains filtered or unexported fields
}

type ConnectionState int

type Handler func(*Connection)

type Message struct {
	Type int
	Body []byte
}

type Options struct {
	// HandshakeTimeout specifies the duration for the open and close handshakes to complete.
	// If the handshakes fail within this time, the connection is closed immediately with an error.
	HandshakeTimeout time.Duration

	// ReadBufferSize and WriteBufferSize specify I/O buffer sizes in bytes. If a buffer
	// size is zero, then buffers allocated by the HTTP server are used. The
	// I/O buffer sizes do not limit the size of the messages that can be sent
	// or received.
	ReadBufferSize, WriteBufferSize int

	// ReadInterval is the maximum amount of time to wait for a new packet on
	// the underlying network connection.
	// After a read has timed out, the websocket connection state is corrupt and
	// the connection will be closed.
	//
	// To ensure that the client sends at least some packet within this time, use [PingInterval].
	ReadInterval time.Duration

	// WriteInterval is the write deadline on the underlying network
	// connection. After a write has timed out, the websocket state is corrupt and
	// the connection will be closed.
	WriteInterval time.Duration

	// WriteBufferPool is a pool of buffers for write operations. If the value
	// is not set, then write buffers are allocated to the connection for the
	// lifetime of the connection.
	//
	// A pool is most useful when the application has a modest volume of writes
	// across a large number of connections.
	//
	// Applications should use a single pool for each unique value of
	// WriteBufferSize.
	WriteBufferPool websocket.BufferPool

	// Subprotocols specifies the server's supported protocols in order of
	// preference. If this field is not nil, then the server negotiates a
	// subprotocol by selecting the first match in this list with a protocol
	// requested by the client. If there's no match, then no protocol is
	// negotiated (the Sec-Websocket-Protocol header is not included in the
	// handshake response).
	Subprotocols []string

	// PingInterval is the amount of time between successive Ping messages sent to be sent to the peer.
	// A ping message is intended to invoke a Poke response from the client, ensuring that the connection
	// has not been corrupted, and a package is received in at most [ReadInterval].
	//
	// For this purpose, PingInterval should be less than [ReadInterval].
	PingInterval time.Duration

	// ReadLimit is the maximum size in bytes for a message read from the peer. If a
	// message exceeds the limit, the connection sends a close message to the peer
	// and returns an error to the application.
	ReadLimit int64

	// CompressionLevel is the compression level of packages received to and from the peer.
	// See the [compress/flate] package for compression levels.
	//
	// A compression level of [flate.NoCompression] means that compression is disabled.
	// This is ignored if compression has not been negotiated with the client.
	CompressionLevel int
}

type PreparedMessage struct {
	// contains filtered or unexported fields
}

type Server struct {

	// Handler is called for incoming client connections.
	// It must not be nil.
	Handler Handler

	// Fallback specifies the handler for generating HTTP responses if the client
	// did not request an upgrade to a websocket connection.
	// If Fallback is nil, sends an appropriate [http.StatusUpgradeRequired]
	Fallback http.Handler

	// Check check if additional client requirements are met before establishing
	// a websocket connection and returns a caller-exposed error if
	// this is not the case. If Check is nil, every potential client is
	// allowed to connect.
	//
	// A client that is rejected will receive a [http.StatusForbidden] response
	// with a body of the error returned by this function.
	//
	// A typical use case includes enforcing a specific subprotocol,
	// before even reaching the handler, see [RequireProtocols].
	//
	// Check is called before CheckOrigin.
	Check func(r *http.Request) error

	// CheckOrigin returns true if the request Origin header is acceptable. If
	// CheckOrigin is nil, then a safe default is used: return false if the
	// Origin request header is present and the origin host is not equal to
	// request Host header.
	//
	// A CheckOrigin function should carefully validate the request origin to
	// prevent cross-site request forgery.
	//
	// CheckOrigin is only called if the Check function passes.
	CheckOrigin func(r *http.Request) bool

	// Error specifies the function for generating HTTP error responses. If Error
	// is nil, then http.Error is used to generate the HTTP response.
	Error func(w http.ResponseWriter, r *http.Request, status int, reason error)

	// Options determine further options for future connections.
	Options Options
	// contains filtered or unexported fields
}

type StatusCode uint16