haouarihk
commented
5 days ago i was able to generate a declaration file using o1-mini
declare module "p2pcf" {
import { EventEmitter } from "events";
/**
* Configuration options for initializing a P2PCF instance.
*/
export interface P2PCFOptions {
/**
* RTC Peer Connection options.
*/
rtcPeerConnectionOptions?: RTCConfiguration;
/**
* Proprietary constraints for RTC Peer Connection.
*/
rtcPeerConnectionProprietaryConstraints?: { [key: string]: any };
/**
* Function to transform SDP before setting it.
*/
sdpTransform?: (sdp: string) => string;
/**
* URL of the Cloudflare Worker signaling server.
* @default 'https://p2pcf.minddrop.workers.dev'
*/
workerUrl?: string;
/**
* Array of STUN ICE servers.
*/
stunIceServers?: RTCIceServer[];
/**
* Array of TURN ICE servers.
*/
turnIceServers?: RTCIceServer[];
/**
* Interval in milliseconds to poll for network changes.
* @default 15000
*/
networkChangePollIntervalMs?: number;
/**
* Interval in milliseconds after which the state expires.
* @default 120000 (2 minutes)
*/
stateExpirationIntervalMs?: number;
/**
* Heartbeat window in milliseconds to maintain state.
* @default 30000 (30 seconds)
*/
stateHeartbeatWindowMs?: number;
/**
* Duration in milliseconds for fast polling.
* @default 10000 (10 seconds)
*/
fastPollingDurationMs?: number;
/**
* Rate in milliseconds for fast polling.
* @default 1500
*/
fastPollingRateMs?: number;
/**
* Rate in milliseconds for slow polling.
* @default 5000
*/
slowPollingRateMs?: number;
/**
* Time in milliseconds after which polling becomes idle.
* @default Infinity
*/
idlePollingAfterMs?: number;
/**
* Rate in milliseconds for idle polling.
* @default Infinity
*/
idlePollingRateMs?: number;
}
/**
* Events emitted by the P2PCF instance.
*/
export interface P2PCFEvents {
/**
* Emitted when a peer successfully connects.
* @param peer The connected peer.
*/
peerconnect: (peer: Peer) => void;
/**
* Emitted when a peer disconnects or is removed.
* @param peer The disconnected peer.
*/
peerclose: (peer: Peer) => void;
/**
* Emitted when a message is received from a peer.
* @param peer The peer that sent the message.
* @param msg The received message as an ArrayBuffer.
*/
msg: (peer: Peer, msg: ArrayBuffer) => void;
}
/**
* Configuration options for initializing a Peer instance.
*/
export interface PeerOptions {
/**
* RTC Peer Connection options.
*/
config?: RTCConfiguration;
/**
* Whether this peer is the initiator of the connection.
*/
initiator?: boolean;
/**
* Timeout in milliseconds for ICE completion.
*/
iceCompleteTimeout?: number;
/**
* Proprietary constraints for RTC Peer Connection.
*/
proprietaryConstraints?: { [key: string]: any };
/**
* Function to transform SDP before setting it.
*/
sdpTransform?: (sdp: string) => string;
/**
* Certificates to use for DTLS.
*/
certificates?: RTCCertificate[];
}
/**
* Events emitted by the Peer instance.
*/
export interface PeerEvents {
/**
* Emitted when the peer connection is successfully established.
*/
connect: () => void;
/**
* Emitted when data is received from the peer.
* @param data The received data as an ArrayBuffer.
*/
data: (data: ArrayBuffer) => void;
/**
* Emitted when an error occurs in the peer connection.
* @param err The error object.
*/
error: (err: Error) => void;
/**
* Emitted when the peer connection is closed.
*/
close: () => void;
/**
* Emitted when signaling data is generated.
* @param data The signaling data.
*/
signal: (data: any) => void;
}
/**
* Peer class representing an individual WebRTC connection.
* Extends EventEmitter to handle events related to the peer connection.
*/
export class Peer extends EventEmitter {
/**
* Unique identifier for the peer session.
*/
id: string;
/**
* Identifier for the client.
*/
client_id: string;
/**
* Indicates if the peer is connected.
*/
connected: boolean;
/**
* Creates a new Peer instance.
* @param options Configuration options for the peer.
*/
constructor(options: PeerOptions);
/**
* Sends data to the connected peer.
* @param data The data to send, either as an ArrayBuffer or Uint8Array.
*/
send(data: ArrayBuffer | Uint8Array): void;
/**
* Signals the peer with data received from the remote peer.
* @param data The signaling data.
*/
signal(data: any): void;
/**
* Destroys the peer connection.
*/
destroy(): void;
/**
* Adds an event listener for the specified event.
* @param event The event name.
* @param listener The event handler.
*/
on<K extends keyof PeerEvents>(event: K, listener: PeerEvents[K]): this;
/**
* Removes an event listener for the specified event.
* @param event The event name.
* @param listener The event handler to remove.
*/
off<K extends keyof PeerEvents>(event: K, listener: PeerEvents[K]): this;
}
/**
* Peer-to-Peer Cloudflare Workers Signaling (P2PCF) class.
* Manages WebRTC connections between peers using a Cloudflare Worker as the signaling server.
*/
export default class P2PCF extends EventEmitter {
/**
* Creates a new P2PCF instance.
* @param clientId Unique identifier for the client (minimum 4 characters).
* @param roomId Identifier for the room (minimum 4 characters).
* @param options Optional configuration options.
* @throws Will throw an error if `clientId` or `roomId` is invalid.
*/
constructor(clientId: string, roomId: string, options?: P2PCFOptions);
/**
* Starts the P2PCF instance, initializing connections and discovering peers.
* @returns A promise that resolves when initialization is complete.
*/
start(): Promise<void>;
/**
* Destroys the P2PCF instance, cleaning up all connections and resources.
*/
destroy(): void;
/**
* Sends a message to a specific peer.
* @param peer The peer to send the message to.
* @param msg The message to send, either as an ArrayBuffer or Uint8Array.
* @throws Will throw an error if the peer is not connected or the message type is unsupported.
*/
send(peer: Peer, msg: ArrayBuffer | Uint8Array): void;
/**
* Broadcasts a message to all connected peers.
* @param msg The message to broadcast, either as an ArrayBuffer or Uint8Array.
*/
broadcast(msg: ArrayBuffer | Uint8Array): void;
/**
* Map of connected peers, keyed by their session IDs.
*/
readonly peers: Map<string, Peer>;
/**
* Array of session IDs that are currently connected.
*/
readonly connectedSessions: string[];
/**
* Adds an event listener for the specified event.
* @param event The event name.
* @param listener The event listener function.
*/
on<K extends keyof P2PCFEvents>(event: K, listener: P2PCFEvents[K]): this;
/**
* Removes an event listener for the specified event.
* @param event The event name.
* @param listener The event listener function to remove.
*/
off<K extends keyof P2PCFEvents>(event: K, listener: P2PCFEvents[K]): this;
}
}
We do need some typescript support or at least declaration file targeting interfaces