@walkhi/code-relax 0.1.0-beta.1

package/node_modules/node-datachannel/src/cpp/web-socket-wrapper.h

@@ -0,0 +1,63 @@
+#ifndef WEB_SOCKET_WRAPPER_H
+#define WEB_SOCKET_WRAPPER_H
+
+#include <memory>
+#include <unordered_set>
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+
+#include "thread-safe-callback.h"
+
+class WebSocketWrapper : public Napi::ObjectWrap<WebSocketWrapper>
+{
+public:
+  static Napi::FunctionReference constructor;
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  WebSocketWrapper(const Napi::CallbackInfo &info);
+  ~WebSocketWrapper();
+
+  // Functions
+  void open(const Napi::CallbackInfo &info);
+  void close(const Napi::CallbackInfo &info);
+  void forceClose(const Napi::CallbackInfo &info);
+  Napi::Value sendMessage(const Napi::CallbackInfo &info);
+  Napi::Value sendMessageBinary(const Napi::CallbackInfo &info);
+  Napi::Value isOpen(const Napi::CallbackInfo &info);
+  Napi::Value bufferedAmount(const Napi::CallbackInfo &info);
+  Napi::Value maxMessageSize(const Napi::CallbackInfo &info);
+  void setBufferedAmountLowThreshold(const Napi::CallbackInfo &info);
+  Napi::Value remoteAddress(const Napi::CallbackInfo &info);
+  Napi::Value path(const Napi::CallbackInfo &info);
+
+  // Callbacks
+  void onOpen(const Napi::CallbackInfo &info);
+  void onClosed(const Napi::CallbackInfo &info);
+  void onError(const Napi::CallbackInfo &info);
+  void onBufferedAmountLow(const Napi::CallbackInfo &info);
+  void onMessage(const Napi::CallbackInfo &info);
+
+  // Close all existing WebSockets
+  static void CloseAll();
+
+  // Reset all Callbacks for existing WebSockets
+  static void CleanupAll();
+
+private:
+  static std::unordered_set<WebSocketWrapper *> instances;
+
+  void doClose();
+  void doForceClose();
+  void doCleanup();
+
+  std::shared_ptr<rtc::WebSocket> mWebSocketPtr = nullptr;
+
+  // Callback Ptrs
+  std::unique_ptr<ThreadSafeCallback> mOnOpenCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnClosedCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnErrorCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnBufferedAmountLowCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnMessageCallback = nullptr;
+};
+
+#endif // WEB_SOCKET_WRAPPER_H

package/node_modules/node-datachannel/src/index.ts

@@ -0,0 +1,9 @@
+// This file is created for builder process
+// So builder can find and compile all files and folders
+// Not intended to be imported directly
+
+import n from './lib/index';
+import p from './polyfill/index';
+
+export const nodeDataChannel = n;
+export const polyfill = p;

package/node_modules/node-datachannel/src/lib/datachannel-stream.ts

@@ -0,0 +1,100 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as stream from 'stream';
+
+/**
+ * Turns a node-datachannel DataChannel into a real Node.js stream, complete with buffering,
+ * backpressure (up to a point - if the buffer fills up, messages are dropped), and
+ * support for piping data elsewhere.
+ *
+ * Read & written data may be either UTF-8 strings or Buffers - this difference exists at
+ * the protocol level, and is preserved here throughout.
+ */
+export default class DataChannelStream extends stream.Duplex {
+  private _rawChannel: any;
+  private _readActive: boolean;
+
+  constructor(rawChannel: any, streamOptions?: Omit<stream.DuplexOptions, 'objectMode'>) {
+    super({
+      allowHalfOpen: false, // Default to autoclose on end().
+      ...streamOptions,
+      objectMode: true, // Preserve the string/buffer distinction (WebRTC treats them differently)
+    });
+
+    this._rawChannel = rawChannel;
+    this._readActive = true;
+
+    rawChannel.onMessage((msg: any) => {
+      if (!this._readActive) return; // If the buffer is full, drop messages.
+
+      // If the push is rejected, we pause reading until the next call to _read().
+      this._readActive = this.push(msg);
+    });
+
+    // When the DataChannel closes, the readable & writable ends close
+    rawChannel.onClosed(() => {
+      this.push(null);
+      this.destroy();
+    });
+
+    rawChannel.onError((errMsg: string) => {
+      this.destroy(new Error(`DataChannel error: ${errMsg}`));
+    });
+
+    // Buffer all writes until the DataChannel opens
+    if (!rawChannel.isOpen()) {
+      this.cork();
+      rawChannel.onOpen(() => this.uncork());
+    }
+  }
+
+  _read(): void {
+    // Stop dropping messages, if the buffer filling up meant we were doing so before.
+    this._readActive = true;
+  }
+
+  _write(chunk, _encoding, callback): void {
+    let sentOk;
+
+    try {
+      if (Buffer.isBuffer(chunk)) {
+        sentOk = this._rawChannel.sendMessageBinary(chunk);
+      } else if (typeof chunk === 'string') {
+        sentOk = this._rawChannel.sendMessage(chunk);
+      } else {
+        const typeName = chunk.constructor.name || typeof chunk;
+        throw new Error(`Cannot write ${typeName} to DataChannel stream`);
+      }
+    } catch (err) {
+      return callback(err);
+    }
+
+    if (sentOk) {
+      callback(null);
+    } else {
+      callback(new Error('Failed to write to DataChannel'));
+    }
+  }
+
+  _final(callback): void {
+    if (!this.allowHalfOpen) this.destroy();
+    callback(null);
+  }
+
+  _destroy(maybeErr, callback): void {
+    // When the stream is destroyed, we close the DataChannel.
+    this._rawChannel.close();
+    callback(maybeErr);
+  }
+
+  get label(): string {
+    return this._rawChannel.getLabel();
+  }
+
+  get id(): number {
+    return this._rawChannel.getId();
+  }
+
+  get protocol(): string {
+    return this._rawChannel.getProtocol();
+  }
+}

package/node_modules/node-datachannel/src/lib/index.ts

@@ -0,0 +1,290 @@
+import nodeDataChannel from './node-datachannel';
+import _DataChannelStream from './datachannel-stream';
+import { WebSocketServer } from './websocket-server';
+import {
+  Channel,
+  DataChannelInitConfig,
+  DescriptionType,
+  Direction,
+  LogLevel,
+  NalUnitSeparator,
+  ObuPacketization,
+  RtcConfig,
+  RTCIceConnectionState,
+  RTCIceGatheringState,
+  RTCPeerConnectionState,
+  RTCSignalingState,
+  SctpSettings,
+  SelectedCandidateInfo,
+} from './types';
+import { WebSocket } from './websocket';
+import type { CertificateFingerprint, IceUdpMuxRequest, LocalDescriptionInit } from './types';
+
+export function preload(): void {
+  nodeDataChannel.preload();
+}
+export function initLogger(level: LogLevel, cb?: (level: LogLevel, message: string) => void): void {
+  nodeDataChannel.initLogger(level, cb);
+}
+export function cleanup(): void {
+  nodeDataChannel.cleanup();
+}
+export function setSctpSettings(settings: SctpSettings): void {
+  nodeDataChannel.setSctpSettings(settings);
+}
+export function getLibraryVersion(): string {
+  return nodeDataChannel.getLibraryVersion();
+}
+
+export interface Audio {
+  addAudioCodec(payloadType: number, codec: string, profile?: string): void;
+  addOpusCodec(payloadType: number, profile?: string): string;
+  direction(): Direction;
+  generateSdp(eol: string, addr: string, port: number): string;
+  mid(): string;
+  setDirection(dir: Direction): void;
+  description(): string;
+  removeFormat(fmt: string): void;
+  addSSRC(ssrc: number, name?: string, msid?: string, trackID?: string): void;
+  removeSSRC(ssrc: number): void;
+  replaceSSRC(oldSsrc: number, ssrc: number, name?: string, msid?: string, trackID?: string): void;
+  hasSSRC(ssrc: number): boolean;
+  getSSRCs(): number[];
+  getCNameForSsrc(ssrc: number): string;
+  setBitrate(bitRate: number): void;
+  getBitrate(): number;
+  hasPayloadType(payloadType: number): boolean;
+  addRTXCodec(payloadType: number, originalPayloadType: number, clockRate: number): void;
+  addRTPMap(): void;
+  parseSdpLine(line: string): void;
+}
+export const Audio: {
+  new (mid: string, dir: Direction): Audio;
+} = nodeDataChannel.Audio;
+
+export interface Video {
+  addVideoCodec(payloadType: number, codec: string, profile?: string): void;
+  addH264Codec(payloadType: number, profile?: string): void;
+  addH265Codec(payloadType: number): void;
+  addVP8Codec(payloadType: number): void;
+  addVP9Codec(payloadType: number): void;
+  addAV1Codec(payloadType: number): void;
+  direction(): Direction;
+  generateSdp(eol: string, addr: string, port: number): string;
+  mid(): string;
+  setDirection(dir: Direction): void;
+  description(): string;
+  removeFormat(fmt: string): void;
+  addSSRC(ssrc: number, name?: string, msid?: string, trackID?: string): void;
+  removeSSRC(ssrc: number): void;
+  replaceSSRC(oldSsrc: number, ssrc: number, name?: string, msid?: string, trackID?: string): void;
+  hasSSRC(ssrc: number): boolean;
+  getSSRCs(): number[];
+  getCNameForSsrc(ssrc: number): string;
+  setBitrate(bitRate: number): void;
+  getBitrate(): number;
+  hasPayloadType(payloadType: number): boolean;
+  addRTXCodec(payloadType: number, originalPayloadType: number, clockRate: number): void;
+  addRTPMap(): void;
+  parseSdpLine(line: string): void;
+}
+export const Video: {
+  new (mid: string, dir: Direction): Video;
+} = nodeDataChannel.Video;
+
+export interface Track {
+  direction(): Direction;
+  mid(): string;
+  type(): string;
+  close(): void;
+  sendMessage(msg: string): boolean;
+  sendMessageBinary(buffer: Buffer): boolean;
+  isOpen(): boolean;
+  isClosed(): boolean;
+  bufferedAmount(): number;
+  maxMessageSize(): number;
+  requestBitrate(bitRate: number): boolean;
+  setBufferedAmountLowThreshold(newSize: number): void;
+  requestKeyframe(): boolean;
+  setMediaHandler(handler: MediaHandler): void;
+  onOpen(cb: () => void): void;
+  onClosed(cb: () => void): void;
+  onError(cb: (err: string) => void): void;
+  onMessage(cb: (msg: Buffer) => void): void;
+}
+export const Track: {
+  new (): Track;
+} = nodeDataChannel.Track;
+
+export interface DataChannel extends Channel {
+  getLabel(): string;
+  getId(): number;
+  getProtocol(): string;
+
+  // Channel implementation
+  close(): void;
+  sendMessage(msg: string): boolean;
+  sendMessageBinary(buffer: Buffer | Uint8Array): boolean;
+  isOpen(): boolean;
+  bufferedAmount(): number;
+  maxMessageSize(): number;
+  setBufferedAmountLowThreshold(newSize: number): void;
+  onOpen(cb: () => void): void;
+  onClosed(cb: () => void): void;
+  onError(cb: (err: string) => void): void;
+  onBufferedAmountLow(cb: () => void): void;
+  onMessage(cb: (msg: string | Buffer | ArrayBuffer) => void): void;
+}
+export const DataChannel: {
+  // DataChannel implementation
+} = nodeDataChannel.DataChannel;
+
+export interface PeerConnection {
+  close(): void;
+  setLocalDescription(type?: DescriptionType, init?: LocalDescriptionInit): void;
+  setRemoteDescription(sdp: string, type: DescriptionType): void;
+  localDescription(): { type: DescriptionType; sdp: string } | null;
+  remoteDescription(): { type: DescriptionType; sdp: string } | null;
+  remoteFingerprint(): CertificateFingerprint;
+  addRemoteCandidate(candidate: string, mid: string): void;
+  createDataChannel(label: string, config?: DataChannelInitConfig): DataChannel;
+  addTrack(media: Video | Audio): Track;
+  hasMedia(): boolean;
+  state(): RTCPeerConnectionState;
+  iceState(): RTCIceConnectionState;
+  signalingState(): RTCSignalingState;
+  gatheringState(): RTCIceGatheringState;
+  onLocalDescription(cb: (sdp: string, type: DescriptionType) => void): void;
+  onLocalCandidate(cb: (candidate: string, mid: string) => void): void;
+  onStateChange(cb: (state: string) => void): void;
+  onIceStateChange(cb: (state: string) => void): void;
+  onSignalingStateChange(cb: (state: string) => void): void;
+  onGatheringStateChange(cb: (state: string) => void): void;
+  onDataChannel(cb: (dc: DataChannel) => void): void;
+  onTrack(cb: (track: Track) => void): void;
+  bytesSent(): number;
+  bytesReceived(): number;
+  rtt(): number;
+  getSelectedCandidatePair(): {
+    local: SelectedCandidateInfo;
+    remote: SelectedCandidateInfo;
+  } | null;
+  maxDataChannelId(): number;
+  maxMessageSize(): number;
+}
+export const PeerConnection: {
+  new (peerName: string, config: RtcConfig): PeerConnection;
+} = nodeDataChannel.PeerConnection;
+
+export interface IceUdpMuxListener {
+  address(): string | undefined;
+  port(): number;
+  stop(): void;
+  onUnhandledStunRequest(cb: (req: IceUdpMuxRequest) => void): void;
+}
+export const IceUdpMuxListener: {
+  new (port: number, address?: string): IceUdpMuxListener;
+} = nodeDataChannel.IceUdpMuxListener;
+
+export interface RtpPacketizationConfig {
+  playoutDelayId: number,
+  playoutDelayMin: number,
+  playoutDelayMax: number,
+  timestamp: number,
+  get clockRate(): number
+}
+
+export const RtpPacketizationConfig: {
+  new(ssrc: number, cname: string, payloadType: number, clockRate: number, videoOrientationId?: number): RtpPacketizationConfig
+} = nodeDataChannel.RtpPacketizationConfig
+
+export interface MediaHandler {
+  addToChain(handler: MediaHandler): void
+}
+
+export interface PacingHandler extends MediaHandler {}
+
+export const PacingHandler: {
+  new (bitsPerSecond: number, sendInterval: number): PacingHandler;
+} = nodeDataChannel.PacingHandler;
+
+export interface RtcpReceivingSession extends MediaHandler {}
+
+export const RtcpReceivingSession: {
+  new (): RtcpReceivingSession;
+} = nodeDataChannel.RtcpReceivingSession;
+
+export interface RtcpNackResponder extends MediaHandler {}
+
+export const RtcpNackResponder: {
+  new (maxSize?: number): RtcpNackResponder
+} = nodeDataChannel.RtcpNackResponder;
+
+export interface RtcpSrReporter extends MediaHandler {
+  get rtpConfig(): RtpPacketizationConfig
+}
+
+export const RtcpSrReporter: {
+  new (rtpConfig: RtpPacketizationConfig): RtcpSrReporter
+} = nodeDataChannel.RtcpSrReporter;
+
+export interface RtpPacketizer extends MediaHandler {
+  get rtpConfig(): RtpPacketizationConfig
+}
+
+export const RtpPacketizer: {
+  new (rtpConfig: RtpPacketizationConfig): RtpPacketizer
+} = nodeDataChannel.RtpPacketizer;
+
+export interface H264RtpPacketizer extends RtpPacketizer {}
+
+export const H264RtpPacketizer: {
+  new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H264RtpPacketizer
+} = nodeDataChannel.H264RtpPacketizer
+
+export interface H265RtpPacketizer extends RtpPacketizer {}
+
+export const H265RtpPacketizer: {
+  new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H265RtpPacketizer
+} = nodeDataChannel.H265RtpPacketizer
+
+export interface AV1RtpPacketizer extends RtpPacketizer {}
+
+export const AV1RtpPacketizer: {
+  new (packetization: ObuPacketization, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): AV1RtpPacketizer
+} = nodeDataChannel.AV1RtpPacketizer
+
+export { WebSocketServer } from './websocket-server';
+export { WebSocket } from './websocket';
+
+export const DataChannelStream = _DataChannelStream;
+
+export default {
+  initLogger,
+  cleanup,
+  preload,
+  setSctpSettings,
+  getLibraryVersion,
+  PacingHandler,
+  RtcpReceivingSession,
+  RtcpNackResponder,
+  RtcpSrReporter,
+  RtpPacketizationConfig,
+  RtpPacketizer,
+  H264RtpPacketizer,
+  H265RtpPacketizer,
+  AV1RtpPacketizer,
+  Track,
+  Video,
+  Audio,
+  DataChannel,
+  PeerConnection,
+  WebSocket,
+  WebSocketServer,
+  DataChannelStream,
+  IceUdpMuxListener,
+};
+
+// Types
+// https://github.com/murat-dogan/node-datachannel/issues/300
+export * from './types';

package/node_modules/node-datachannel/src/lib/node-datachannel.ts

@@ -0,0 +1,84 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { familySync, MUSL } from 'detect-libc';
+
+function getPackageName(): string | null {
+  const { platform, arch } = process;
+  if (platform === 'linux') {
+    const libc = familySync();
+    if (libc === MUSL) {
+      if (arch === 'x64') return '@node-datachannel/linux-x64-musl';
+      if (arch === 'arm64') return '@node-datachannel/linux-arm64-musl';
+    } else {
+      if (arch === 'x64') return '@node-datachannel/linux-x64-gnu';
+      if (arch === 'arm64') return '@node-datachannel/linux-arm64-gnu';
+    }
+  } else if (platform === 'darwin') {
+    if (arch === 'arm64') return '@node-datachannel/darwin-arm64';
+    if (arch === 'x64') return '@node-datachannel/darwin-x64';
+  } else if (platform === 'win32') {
+    if (arch === 'x64') return '@node-datachannel/win32-x64-msvc';
+    if (arch === 'arm64') return '@node-datachannel/win32-arm64-msvc';
+  } else if (platform === 'android') {
+    if (arch === 'arm64') return '@node-datachannel/android-arm64';
+  }
+  return null;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function loadBinding(): any {
+  // 1. Try local build candidate paths for development, tests, and source builds
+  const candidateLocalPaths = [
+    path.resolve(__dirname, '../../build/node_datachannel.node'),
+    path.resolve(__dirname, '../../../build/node_datachannel.node'),
+    path.resolve(__dirname, '../../build/Release/node_datachannel.node'),
+    path.resolve(__dirname, '../../../build/Release/node_datachannel.node'),
+    path.resolve(__dirname, '../../build/Debug/node_datachannel.node'),
+    path.resolve(__dirname, '../../../build/Debug/node_datachannel.node'),
+  ];
+
+  let localLoadError: Error | null = null;
+  for (const candidate of candidateLocalPaths) {
+    if (fs.existsSync(candidate)) {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require(candidate);
+      } catch (err: unknown) {
+        localLoadError = err instanceof Error ? err : new Error(String(err));
+      }
+    }
+  }
+
+  if (localLoadError) {
+    throw new Error(
+      `Failed to load local native addon build: ${localLoadError.message}\n` +
+        `Stack: ${localLoadError.stack}`
+    );
+  }
+
+  // 2. Try platform-specific optionalDependencies package
+  const pkgName = getPackageName();
+  if (pkgName) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      return require(pkgName);
+    } catch (err: unknown) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `Cannot load native addon for node-datachannel on ${process.platform} (${process.arch}). ` +
+          `Attempted to require "${pkgName}". ` +
+          `Please ensure optionalDependencies are installed (avoid --no-optional / --omit=optional) ` +
+          `or compile locally with "npm run compile". (Error: ${errorMsg})`
+      );
+    }
+  }
+
+  throw new Error(
+    `Unsupported platform/architecture for node-datachannel: ${process.platform} (${process.arch}). ` +
+      `Please compile from source using "npm run compile".`
+  );
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const nodeDataChannel: any = loadBinding();
+export default nodeDataChannel;