@jsonstudio/zterm-daemon-win32-x64 0.0.0-stage → 0.1.4

package/runtime/node_modules/@roamhq/wrtc/lib/peerconnection.js

@@ -0,0 +1,333 @@
+"use strict";
+
+var inherits = require("util").inherits;
+
+var _webrtc = require("./binding");
+
+var EventTarget = require("./eventtarget");
+
+var RTCDataChannelEvent = require("./datachannelevent");
+var RTCIceCandidate = require("./icecandidate");
+var RTCPeerConnectionIceEvent = require("./rtcpeerconnectioniceevent");
+var RTCPeerConnectionIceErrorEvent = require("./rtcpeerconnectioniceerrorevent");
+var RTCSessionDescription = require("./sessiondescription");
+
+function RTCPeerConnection() {
+  var self = this;
+  var pc = new _webrtc.RTCPeerConnection(arguments[0] || {});
+
+  EventTarget.call(this);
+
+  //
+  // Attach events to the native PeerConnection object
+  //
+  pc.ontrack = function ontrack(receiver, streams, transceiver) {
+    self.dispatchEvent({
+      type: "track",
+      track: receiver.track,
+      receiver: receiver,
+      streams: streams,
+      transceiver: transceiver,
+      target: self,
+    });
+  };
+
+  pc.onconnectionstatechange = function onconnectionstatechange() {
+    self.dispatchEvent({ type: "connectionstatechange", target: self });
+  };
+
+  pc.onicecandidate = function onicecandidate(candidate) {
+    var icecandidate = new RTCIceCandidate(candidate);
+    self.dispatchEvent(
+      new RTCPeerConnectionIceEvent("icecandidate", {
+        candidate: icecandidate,
+        target: self,
+      }),
+    );
+  };
+
+  pc.onicecandidateerror = function onicecandidateerror(eventInitDict) {
+    eventInitDict.target = self;
+    var icecandidateerror = new RTCPeerConnectionIceErrorEvent(
+      "icecandidateerror",
+      eventInitDict,
+    );
+    self.dispatchEvent(icecandidateerror);
+  };
+
+  pc.onsignalingstatechange = function onsignalingstatechange() {
+    self.dispatchEvent({ type: "signalingstatechange", target: self });
+  };
+
+  pc.oniceconnectionstatechange = function oniceconnectionstatechange() {
+    self.dispatchEvent({ type: "iceconnectionstatechange", target: self });
+  };
+
+  pc.onicegatheringstatechange = function onicegatheringstatechange() {
+    self.dispatchEvent({ type: "icegatheringstatechange", target: self });
+
+    // if we have completed gathering candidates, trigger a null candidate event
+    if (
+      self.iceGatheringState === "complete" &&
+      self.connectionState !== "closed"
+    ) {
+      self.dispatchEvent(
+        new RTCPeerConnectionIceEvent("icecandidate", {
+          candidate: null,
+          target: self,
+        }),
+      );
+    }
+  };
+
+  pc.onnegotiationneeded = function onnegotiationneeded() {
+    self.dispatchEvent({ type: "negotiationneeded", target: self });
+  };
+
+  // [ToDo] onnegotiationneeded
+
+  pc.ondatachannel = function ondatachannel(channel) {
+    self.dispatchEvent(
+      new RTCDataChannelEvent("datachannel", { channel, target: self }),
+    );
+  };
+
+  //
+  // PeerConnection properties & attributes
+  //
+
+  Object.defineProperties(this, {
+    _pc: {
+      value: pc,
+    },
+    canTrickleIceCandidates: {
+      get: function getCanTrickleIceCandidates() {
+        return pc.canTrickleIceCandidates;
+      },
+      enumerable: true,
+    },
+    connectionState: {
+      get: function getConnectionState() {
+        return pc.connectionState;
+      },
+      enumerable: true,
+    },
+    currentLocalDescription: {
+      get: function getCurrentLocalDescription() {
+        return pc.currentLocalDescription
+          ? new RTCSessionDescription(pc.currentLocalDescription)
+          : null;
+      },
+      enumerable: true,
+    },
+    localDescription: {
+      get: function getLocalDescription() {
+        return pc.localDescription
+          ? new RTCSessionDescription(pc.localDescription)
+          : null;
+      },
+      enumerable: true,
+    },
+    pendingLocalDescription: {
+      get: function getPendingLocalDescription() {
+        return pc.pendingLocalDescription
+          ? new RTCSessionDescription(pc.pendingLocalDescription)
+          : null;
+      },
+      enumerable: true,
+    },
+    currentRemoteDescription: {
+      get: function getCurrentRemoteDescription() {
+        return pc.currentRemoteDescription
+          ? new RTCSessionDescription(pc.currentRemoteDescription)
+          : null;
+      },
+      enumerable: true,
+    },
+    remoteDescription: {
+      get: function getRemoteDescription() {
+        return pc.remoteDescription
+          ? new RTCSessionDescription(pc.remoteDescription)
+          : null;
+      },
+      enumerable: true,
+    },
+    pendingRemoteDescription: {
+      get: function getPendingRemoteDescription() {
+        return pc.pendingRemoteDescription
+          ? new RTCSessionDescription(pc.pendingRemoteDescription)
+          : null;
+      },
+      enumerable: true,
+    },
+    signalingState: {
+      get: function getSignalingState() {
+        return pc.signalingState;
+      },
+      enumerable: true,
+    },
+    sctp: {
+      get: function () {
+        return pc.sctp;
+      },
+      enumerable: true,
+    },
+    iceGatheringState: {
+      get: function getIceGatheringState() {
+        return pc.iceGatheringState;
+      },
+      enumerable: true,
+    },
+    iceConnectionState: {
+      get: function getIceConnectionState() {
+        return pc.iceConnectionState;
+      },
+      enumerable: true,
+    },
+    onconnectionstatechange: {
+      value: null,
+      writable: true,
+      enumerable: true,
+    },
+    ondatachannel: {
+      value: null,
+      writable: true,
+      enumerable: true,
+    },
+    oniceconnectionstatechange: {
+      value: null,
+      writable: true,
+      enumerable: true,
+    },
+    onicegatheringstatechange: {
+      value: null,
+      writable: true,
+      enumerable: true,
+    },
+    onnegotiationneeded: {
+      value: null,
+      writable: true,
+      enumerable: true,
+    },
+    onsignalingstatechange: {
+      value: null,
+      writable: true,
+      enumerable: true,
+    },
+  });
+}
+
+inherits(RTCPeerConnection, EventTarget);
+
+// NOTE(mroberts): This is a bit of a hack.
+RTCPeerConnection.prototype.ontrack = null;
+
+RTCPeerConnection.prototype.addIceCandidate = function addIceCandidate(
+  candidate,
+) {
+  if (!candidate?.candidate) {
+    // The WebRTC specification says:
+    // * if the `candidate` is undefined/missing
+    // * if the `candidate` parameter is null
+    // * if the `candidate` parameter has an undefined/missing `candidate` property
+    // * if the `candidate` parameter has a `candidate: ""` property
+    // Then, the message is treated as end-of-candidates.
+    // This code normalizes all those conditions into a single value, for convenience.
+    // eslint-disable-next-line no-undefined
+    candidate = undefined;
+  }
+  var promise = this._pc.addIceCandidate(candidate);
+  if (arguments.length === 3) {
+    promise.then(arguments[1], arguments[2]);
+  }
+  return promise;
+};
+
+RTCPeerConnection.prototype.addTransceiver = function addTransceiver() {
+  return this._pc.addTransceiver.apply(this._pc, arguments);
+};
+
+RTCPeerConnection.prototype.addTrack = function addTrack(track, ...streams) {
+  return this._pc.addTrack(track, streams);
+};
+
+RTCPeerConnection.prototype.close = function close() {
+  this._pc.close();
+};
+
+RTCPeerConnection.prototype.createDataChannel = function createDataChannel() {
+  return this._pc.createDataChannel.apply(this._pc, arguments);
+};
+
+RTCPeerConnection.prototype.createOffer = function createOffer() {
+  var options = arguments.length === 3 ? arguments[2] : arguments[0];
+  var promise = this._pc.createOffer(options || {});
+  if (arguments.length >= 2) {
+    promise.then(arguments[0], arguments[1]);
+  }
+  return promise;
+};
+
+RTCPeerConnection.prototype.createAnswer = function createAnswer() {
+  var options = arguments.length === 3 ? arguments[2] : arguments[0];
+  var promise = this._pc.createAnswer(options || {});
+  if (arguments.length >= 2) {
+    promise.then(arguments[0], arguments[1]);
+  }
+  return promise;
+};
+
+RTCPeerConnection.prototype.getConfiguration = function getConfiguration() {
+  return this._pc.getConfiguration();
+};
+
+RTCPeerConnection.prototype.getReceivers = function getReceivers() {
+  return this._pc.getReceivers();
+};
+
+RTCPeerConnection.prototype.getSenders = function getSenders() {
+  return this._pc.getSenders();
+};
+
+RTCPeerConnection.prototype.getTransceivers = function getTransceivers() {
+  return this._pc.getTransceivers();
+};
+
+RTCPeerConnection.prototype.getStats = function getStats() {
+  return this._pc.getStats(arguments[0]);
+};
+
+RTCPeerConnection.prototype.removeTrack = function removeTrack(sender) {
+  this._pc.removeTrack(sender);
+};
+
+RTCPeerConnection.prototype.setConfiguration = function setConfiguration(
+  configuration,
+) {
+  return this._pc.setConfiguration(configuration);
+};
+
+RTCPeerConnection.prototype.setLocalDescription = function setLocalDescription(
+  description,
+) {
+  var promise = this._pc.setLocalDescription(description);
+  if (arguments.length === 3) {
+    promise.then(arguments[1], arguments[2]);
+  }
+  return promise;
+};
+
+RTCPeerConnection.prototype.setRemoteDescription =
+  function setRemoteDescription(description) {
+    var promise = this._pc.setRemoteDescription(description);
+    if (arguments.length === 3) {
+      promise.then(arguments[1], arguments[2]);
+    }
+    return promise;
+  };
+
+RTCPeerConnection.prototype.restartIce = function restartIce() {
+  return this._pc.restartIce();
+};
+
+module.exports = RTCPeerConnection;

package/runtime/node_modules/@roamhq/wrtc/lib/rtcpeerconnectioniceerrorevent.js

@@ -0,0 +1,36 @@
+"use strict";
+
+function RTCPeerConnectionIceErrorEvent(type, eventInitDict) {
+  Object.defineProperties(this, {
+    type: {
+      value: type,
+      enumerable: true,
+    },
+    address: {
+      value: eventInitDict.address,
+      enumerable: true,
+    },
+    port: {
+      value: eventInitDict.port,
+      enumerable: true,
+    },
+    url: {
+      value: eventInitDict.url,
+      enumerable: true,
+    },
+    errorCode: {
+      value: eventInitDict.errorCode,
+      enumerable: true,
+    },
+    errorText: {
+      value: eventInitDict.errorText,
+      enumerable: true,
+    },
+    target: {
+      value: eventInitDict.target,
+      enumerable: true,
+    },
+  });
+}
+
+module.exports = RTCPeerConnectionIceErrorEvent;

package/runtime/node_modules/@roamhq/wrtc/lib/rtcpeerconnectioniceevent.js

@@ -0,0 +1,20 @@
+"use strict";
+
+function RTCPeerConnectionIceEvent(type, eventInitDict) {
+  Object.defineProperties(this, {
+    type: {
+      value: type,
+      enumerable: true,
+    },
+    candidate: {
+      value: eventInitDict.candidate,
+      enumerable: true,
+    },
+    target: {
+      value: eventInitDict.target,
+      enumerable: true,
+    },
+  });
+}
+
+module.exports = RTCPeerConnectionIceEvent;

package/runtime/node_modules/@roamhq/wrtc/lib/sessiondescription.js

@@ -0,0 +1,19 @@
+"use strict";
+
+function RTCSessionDescription(descriptionInitDict) {
+  if (descriptionInitDict) {
+    this.type = descriptionInitDict.type;
+    this.sdp = descriptionInitDict.sdp;
+  }
+
+  this.toJSON = () => {
+    const { sdp, type } = this;
+
+    return {
+      sdp,
+      type,
+    };
+  };
+}
+
+module.exports = RTCSessionDescription;

package/runtime/node_modules/@roamhq/wrtc/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@roamhq/wrtc",
+  "description": "Standards-compliant WebRTC implementation for Node",
+  "keywords": [
+    "webrtc",
+    "p2p",
+    "peer"
+  ],
+  "version": "0.10.0",
+  "author": "Jack Duvall <theduvallj@gmail.com> (https://duvallj.pw)",
+  "homepage": "https://github.com/WonderInventions/node-webrtc",
+  "bugs": "https://github.com/WonderInventions/node-webrtc/issues",
+  "license": "BSD-2-Clause",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/WonderInventions/node-webrtc.git"
+  },
+  "main": "lib/index.js",
+  "types": "types/index.d.ts",
+  "browser": "lib/browser.js",
+  "files": [
+    "AUTHORS",
+    "CHANGELOG.md",
+    "lib",
+    "types"
+  ],
+  "optionalDependencies": {
+    "@roamhq/wrtc-darwin-arm64": "0.10.0",
+    "@roamhq/wrtc-darwin-x64": "0.10.0",
+    "@roamhq/wrtc-linux-arm64": "0.10.0",
+    "@roamhq/wrtc-linux-x64": "0.10.0",
+    "@roamhq/wrtc-win32-x64": "0.10.0",
+    "domexception": "^4.0.0"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.17.0",
+    "@fidm/x509": "^1.2.1",
+    "cmake-js": "^7.3.0",
+    "cross-env": "^5.1.4",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^9.1.0",
+    "globals": "^15.14.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.2.11",
+    "node-addon-api": "^7.0.0",
+    "patch-package": "^8.0.0",
+    "prettier": "^3.4.2",
+    "recursive-copy": "^2.0.14",
+    "simple-peer": "~9.7.0",
+    "tape": "^5.6.1",
+    "temp": "^0.9.4"
+  },
+  "scripts": {
+    "patch": "patch-package --error-on-warn",
+    "build": "node scripts/build-from-source.js",
+    "make-prebuilt": "node scripts/make-prebuilt.js",
+    "install-example": "node scripts/install-example.js",
+    "lint": "eslint lib/*.js lib/**/*.js test/*.js test/**/*.js scripts/*.js",
+    "test": "node --expose-gc test/all.js",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.js": "eslint --cache --fix",
+    "*.{js,css,md}": "prettier --write",
+    "*.{cc,h}": "clang-format -i"
+  }
+}

package/runtime/node_modules/@roamhq/wrtc/types/index.d.ts

@@ -0,0 +1,32 @@
+/* Copyright (c) 2023 The node-webrtc project authors. All rights reserved.
+ *
+ * Use of this source code is governed by a BSD-style license that can be found
+ * in the LICENSE.md file in the root of the source tree. All contributing
+ * project authors may be found in the AUTHORS file in the root of the source
+ * tree.
+ */
+
+// Re-export most types to have the same signature as builtin ones
+// (the signatures actually are slightly different, but we are meant to be
+// a polyfill library so we'll ignore that for now)
+export {
+  MediaStream,
+  MediaStreamTrack,
+  RTCDataChannel,
+  RTCDataChannelEvent,
+  RTCDtlsTransport,
+  RTCIceCandidate,
+  RTCIceTransport,
+  RTCPeerConnection,
+  RTCPeerConnectionIceEvent,
+  RTCRtpReceiver,
+  RTCRtpSender,
+  RTCRtpTransceiver,
+  RTCSctpTransport,
+  RTCSessionDescription,
+  getUserMedia,
+  mediaDevices,
+};
+
+// Include the non-standard APIs too
+export * as nonstandard from "./nonstandard";

package/runtime/node_modules/@roamhq/wrtc/types/nonstandard.d.ts

@@ -0,0 +1,81 @@
+/* Copyright (c) 2023 The node-webrtc project authors. All rights reserved.
+ *
+ * Use of this source code is governed by a BSD-style license that can be found
+ * in the LICENSE.md file in the root of the source tree. All contributing
+ * project authors may be found in the AUTHORS file in the root of the source
+ * tree.
+ */
+
+export interface RTCVideoFrame {
+  width: number;
+  height: number;
+  data: Uint8Array;
+}
+
+export const i420ToRgba: (i420: RTCVideoFrame, rgba: RTCVideoFrame) => void;
+export const rgbaToI420: (rgba: RTCVideoFrame, i420: RTCVideoFrame) => void;
+
+export interface RTCAudioSink extends EventTarget {
+  stop(): void;
+  readonly stopped: boolean;
+  ondata: EventHandler;
+};
+
+export const RTCAudioSink: {
+  prototype: RTCAudioSink;
+  new (track: MediaStreamTrack): RTCAudioSink;
+}
+
+export interface RTCAudioData {
+  samples: Int16Array;
+  sampleRate: number;
+  bitsPerSample?: number; // default = 16
+  channelCount?: number; // default = 1
+  numberOfFrames?: number; // default = 10ms of audio at the given sampleRate
+}
+
+export interface RTCAudioSource {
+  createTrack(): MediaStreamTrack;
+  onData(data: RTCAudioData): void;
+}
+
+export const RTCAudioSource: {
+  prototype: RTCAudioSource;
+  new (): RTCAudioSource;
+}
+
+export interface RTCVideoSink extends EventTarget {
+  stop(): void;
+  readonly stopped: boolean;
+  onframe: EventHandler;
+};
+
+export const RTCVideoSink: {
+  prototype: RTCVideoSink;
+  new (track: MediaStreamTrack): RTCVideoSink;
+}
+
+export interface RTCVideoData {
+  samples: Int16Array;
+  sampleRate: number;
+  bitsPerSample?: number; // default = 16
+  channelCount?: number; // default = 1
+  numberOfFrames?: number; // default = 10ms of audio at the given sampleRate
+}
+
+export interface RTCVideoSourceInit {
+  isScreencast?: boolean; // default = false
+  needsDenoising?: boolean;
+}
+
+export interface RTCVideoSource {
+  readonly isScreencast: boolean;
+  readonly needsDenoising?: boolean;
+  createTrack(): MediaStreamTrack;
+  onFrame(data: RTCVideoFrame): void;
+}
+
+export const RTCVideoSource: {
+  prototype: RTCVideoSource;
+  new (init?: RTCVideoSourceInit): RTCVideoSource;
+}

package/runtime/node_modules/@roamhq/wrtc-win32-x64/index.js

@@ -0,0 +1 @@
+module.exports = require('./wrtc.node');

package/runtime/node_modules/@roamhq/wrtc-win32-x64/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@roamhq/wrtc-win32-x64",
+  "version": "0.10.0",
+  "description": "The Windows 64-bit binary for @roamhq/wrtc.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WonderInventions/node-webrtc.git"
+  },
+  "license": "BSD-2-Clause",
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ]
+}

package/runtime/node_modules/node-pty/LICENSE

@@ -0,0 +1,69 @@
+Copyright (c) 2012-2015, Christopher Jeffrey (https://github.com/chjj/)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+
+
+The MIT License (MIT)
+
+Copyright (c) 2016, Daniel Imms (http://www.growingwiththeweb.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+
+MIT License
+
+Copyright (c) 2018 - present Microsoft Corporation
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.