1673 lines
57 KiB
JavaScript
1673 lines
57 KiB
JavaScript
// modules are defined as an array
|
||
// [ module function, map of requires ]
|
||
//
|
||
// map of requires is short require name -> numeric require
|
||
//
|
||
// anything defined in a previous bundle is accessed via the
|
||
// orig method which is the require for previous bundles
|
||
|
||
(function (
|
||
modules,
|
||
entry,
|
||
mainEntry,
|
||
parcelRequireName,
|
||
externals,
|
||
distDir,
|
||
publicUrl,
|
||
devServer
|
||
) {
|
||
/* eslint-disable no-undef */
|
||
var globalObject =
|
||
typeof globalThis !== 'undefined'
|
||
? globalThis
|
||
: typeof self !== 'undefined'
|
||
? self
|
||
: typeof window !== 'undefined'
|
||
? window
|
||
: typeof global !== 'undefined'
|
||
? global
|
||
: {};
|
||
/* eslint-enable no-undef */
|
||
|
||
// Save the require from previous bundle to this closure if any
|
||
var previousRequire =
|
||
typeof globalObject[parcelRequireName] === 'function' &&
|
||
globalObject[parcelRequireName];
|
||
|
||
var importMap = previousRequire.i || {};
|
||
var cache = previousRequire.cache || {};
|
||
// Do not use `require` to prevent Webpack from trying to bundle this call
|
||
var nodeRequire =
|
||
typeof module !== 'undefined' &&
|
||
typeof module.require === 'function' &&
|
||
module.require.bind(module);
|
||
|
||
function newRequire(name, jumped) {
|
||
if (!cache[name]) {
|
||
if (!modules[name]) {
|
||
if (externals[name]) {
|
||
return externals[name];
|
||
}
|
||
// if we cannot find the module within our internal map or
|
||
// cache jump to the current global require ie. the last bundle
|
||
// that was added to the page.
|
||
var currentRequire =
|
||
typeof globalObject[parcelRequireName] === 'function' &&
|
||
globalObject[parcelRequireName];
|
||
if (!jumped && currentRequire) {
|
||
return currentRequire(name, true);
|
||
}
|
||
|
||
// If there are other bundles on this page the require from the
|
||
// previous one is saved to 'previousRequire'. Repeat this as
|
||
// many times as there are bundles until the module is found or
|
||
// we exhaust the require chain.
|
||
if (previousRequire) {
|
||
return previousRequire(name, true);
|
||
}
|
||
|
||
// Try the node require function if it exists.
|
||
if (nodeRequire && typeof name === 'string') {
|
||
return nodeRequire(name);
|
||
}
|
||
|
||
var err = new Error("Cannot find module '" + name + "'");
|
||
err.code = 'MODULE_NOT_FOUND';
|
||
throw err;
|
||
}
|
||
|
||
localRequire.resolve = resolve;
|
||
localRequire.cache = {};
|
||
|
||
var module = (cache[name] = new newRequire.Module(name));
|
||
|
||
modules[name][0].call(
|
||
module.exports,
|
||
localRequire,
|
||
module,
|
||
module.exports,
|
||
globalObject
|
||
);
|
||
}
|
||
|
||
return cache[name].exports;
|
||
|
||
function localRequire(x) {
|
||
var res = localRequire.resolve(x);
|
||
return res === false ? {} : newRequire(res);
|
||
}
|
||
|
||
function resolve(x) {
|
||
var id = modules[name][1][x];
|
||
return id != null ? id : x;
|
||
}
|
||
}
|
||
|
||
function Module(moduleName) {
|
||
this.id = moduleName;
|
||
this.bundle = newRequire;
|
||
this.require = nodeRequire;
|
||
this.exports = {};
|
||
}
|
||
|
||
newRequire.isParcelRequire = true;
|
||
newRequire.Module = Module;
|
||
newRequire.modules = modules;
|
||
newRequire.cache = cache;
|
||
newRequire.parent = previousRequire;
|
||
newRequire.distDir = distDir;
|
||
newRequire.publicUrl = publicUrl;
|
||
newRequire.devServer = devServer;
|
||
newRequire.i = importMap;
|
||
newRequire.register = function (id, exports) {
|
||
modules[id] = [
|
||
function (require, module) {
|
||
module.exports = exports;
|
||
},
|
||
{},
|
||
];
|
||
};
|
||
|
||
// Only insert newRequire.load when it is actually used.
|
||
// The code in this file is linted against ES5, so dynamic import is not allowed.
|
||
// INSERT_LOAD_HERE
|
||
|
||
Object.defineProperty(newRequire, 'root', {
|
||
get: function () {
|
||
return globalObject[parcelRequireName];
|
||
},
|
||
});
|
||
|
||
globalObject[parcelRequireName] = newRequire;
|
||
|
||
for (var i = 0; i < entry.length; i++) {
|
||
newRequire(entry[i]);
|
||
}
|
||
|
||
if (mainEntry) {
|
||
// Expose entry point to Node, AMD or browser globals
|
||
// Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
|
||
var mainExports = newRequire(mainEntry);
|
||
|
||
// CommonJS
|
||
if (typeof exports === 'object' && typeof module !== 'undefined') {
|
||
module.exports = mainExports;
|
||
|
||
// RequireJS
|
||
} else if (typeof define === 'function' && define.amd) {
|
||
define(function () {
|
||
return mainExports;
|
||
});
|
||
}
|
||
}
|
||
})({"3FuxY":[function(require,module,exports,__globalThis) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
var _connection = require("./Connection");
|
||
var _eventPool = require("./EventPool");
|
||
var _eventPoolDefault = parcelHelpers.interopDefault(_eventPool);
|
||
var _eventTarget = require("./EventTarget");
|
||
var _eventTargetDefault = parcelHelpers.interopDefault(_eventTarget);
|
||
var _ippressure = require("./IPPressure");
|
||
var _peer = require("./Peer");
|
||
var _peerDefault = parcelHelpers.interopDefault(_peer);
|
||
var _room = require("./Room");
|
||
var _roomDefault = parcelHelpers.interopDefault(_room);
|
||
var _wstsprotocol = require("./WSTSProtocol");
|
||
var _wstsprotocolDefault = parcelHelpers.interopDefault(_wstsprotocol);
|
||
class MWSE extends (0, _eventTargetDefault.default) {
|
||
/*public static compress(message:string, callback:(e:any) => any)
|
||
{
|
||
let u : any= [];
|
||
let C = new Gzip({
|
||
level: 9,
|
||
mem: 12
|
||
},(stream,isLast) => {
|
||
u.push(stream);
|
||
if(isLast)
|
||
{
|
||
callback(u);
|
||
}
|
||
});
|
||
C.push(new TextEncoder().encode(message), true);
|
||
}*/ constructor(options){
|
||
super(), this.rooms = new Map(), this.pairs = new Map(), this.peers = new Map(), this.writable = 1, this.readable = 1;
|
||
MWSE.rtc = MWSE;
|
||
this.server = new (0, _connection.Connection)(this, options);
|
||
this.WSTSProtocol = new (0, _wstsprotocolDefault.default)(this);
|
||
this.EventPooling = new (0, _eventPoolDefault.default)(this);
|
||
this.virtualPressure = new (0, _ippressure.IPPressure)(this);
|
||
this.server.connect();
|
||
this.me = new (0, _peerDefault.default)(this);
|
||
this.me.scope(()=>{
|
||
this.peers.set('me', this.me);
|
||
this.peers.set(this.me.socketId, this.me);
|
||
});
|
||
this.server.onActive(async ()=>{
|
||
this.me.setSocketId('me');
|
||
await this.me.metadata();
|
||
this.emit('scope');
|
||
this.activeScope = true;
|
||
});
|
||
this.server.onPassive(async ()=>{
|
||
this.emit('close');
|
||
});
|
||
this.packMessagingSystem();
|
||
}
|
||
destroy() {
|
||
this.server.disconnect();
|
||
}
|
||
enableRecaiveData() {
|
||
this.WSTSProtocol.SendOnly({
|
||
type: 'connection/packrecaive',
|
||
value: 1
|
||
});
|
||
this.readable = 1;
|
||
}
|
||
disableRecaiveData() {
|
||
this.WSTSProtocol.SendOnly({
|
||
type: 'connection/packrecaive',
|
||
value: 0
|
||
});
|
||
this.readable = 0;
|
||
}
|
||
enableSendData() {
|
||
this.WSTSProtocol.SendOnly({
|
||
type: 'connection/packsending',
|
||
value: 1
|
||
});
|
||
this.writable = 1;
|
||
}
|
||
disableSendData() {
|
||
this.WSTSProtocol.SendOnly({
|
||
type: 'connection/packsending',
|
||
value: 0
|
||
});
|
||
this.writable = 0;
|
||
}
|
||
enableNotifyRoomInfo() {
|
||
this.WSTSProtocol.SendOnly({
|
||
type: 'connection/roominfo',
|
||
value: 1
|
||
});
|
||
}
|
||
disableNotifyRoomInfo() {
|
||
this.WSTSProtocol.SendOnly({
|
||
type: 'connection/roominfo',
|
||
value: 0
|
||
});
|
||
}
|
||
async request(peerId, pack) {
|
||
let { pack: answer } = await this.EventPooling.request({
|
||
type: 'request/to',
|
||
to: peerId,
|
||
pack
|
||
});
|
||
return answer;
|
||
}
|
||
async response(peerId, requestId, pack) {
|
||
this.WSTSProtocol.SendOnly({
|
||
type: 'response/to',
|
||
to: peerId,
|
||
pack,
|
||
id: requestId
|
||
});
|
||
}
|
||
packMessagingSystem() {
|
||
this.EventPooling.signal('pack', (payload)=>{
|
||
if (this.readable) {
|
||
let { from, pack } = payload;
|
||
this.peer(from, true).emit('pack', pack);
|
||
}
|
||
});
|
||
this.EventPooling.signal('request', (payload)=>{
|
||
let { from, pack, id } = payload;
|
||
let scope = {
|
||
body: pack,
|
||
response: (pack)=>{
|
||
this.response(from, id, pack);
|
||
},
|
||
peer: this.peer(from, true)
|
||
};
|
||
this.peer(from, true).emit('request', scope);
|
||
this.peer('me').emit('request', scope);
|
||
});
|
||
this.EventPooling.signal('pack/room', (payload)=>{
|
||
if (this.readable) {
|
||
let { from, pack, sender } = payload;
|
||
this.room(from).emit('message', pack, this.peer(sender));
|
||
}
|
||
});
|
||
this.EventPooling.signal('room/joined', (payload)=>{
|
||
let { id, roomid } = payload;
|
||
let room = this.room(roomid);
|
||
let peer = this.peer(id, true);
|
||
room.peers.set(peer.socketId, peer);
|
||
room.emit('join', peer);
|
||
});
|
||
this.EventPooling.signal('room/info', (payload)=>{
|
||
let { roomId, name, value } = payload;
|
||
this.room(roomId).emit('updateinfo', name, value);
|
||
});
|
||
this.EventPooling.signal('room/ejected', (payload)=>{
|
||
let { id, roomid } = payload;
|
||
let room = this.room(roomid);
|
||
let peer = this.peer(id, true);
|
||
room.peers.delete(peer.socketId);
|
||
room.emit('eject', peer);
|
||
});
|
||
this.EventPooling.signal('room/closed', (payload)=>{
|
||
let { roomid } = payload;
|
||
let room = this.room(roomid);
|
||
room.peers.clear();
|
||
room.emit('close');
|
||
this.rooms.delete(roomid);
|
||
});
|
||
this.EventPooling.signal("pair/info", (payload)=>{
|
||
let { from, name, value } = payload;
|
||
let peer = this.peer(from, true);
|
||
peer.info.info[name] = value;
|
||
peer.emit("info", name, value);
|
||
});
|
||
this.EventPooling.signal("request/pair", (payload)=>{
|
||
let { from, info } = payload;
|
||
let peer = this.peer(from, true);
|
||
peer.info.info = info;
|
||
peer.emit("request/pair", peer);
|
||
this.peer('me').emit('request/pair', peer);
|
||
});
|
||
this.EventPooling.signal("peer/disconnect", (payload)=>{
|
||
let { id } = payload;
|
||
let peer = this.peer(id, true);
|
||
peer.emit("disconnect", peer);
|
||
});
|
||
this.EventPooling.signal("accepted/pair", (payload)=>{
|
||
let { from, info } = payload;
|
||
let peer = this.peer(from, true);
|
||
peer.info.info = info;
|
||
peer.emit("accepted/pair", peer);
|
||
this.peer('me').emit('accepted/pairr', peer);
|
||
});
|
||
this.EventPooling.signal("end/pair", (payload)=>{
|
||
let { from, info } = payload;
|
||
let peer = this.peer(from, true);
|
||
peer.emit("endPair", info);
|
||
this.peer('me').emit('endPair', from, info);
|
||
});
|
||
}
|
||
room(options) {
|
||
if (typeof options == "string") {
|
||
if (this.rooms.has(options)) return this.rooms.get(options);
|
||
}
|
||
let room = new (0, _roomDefault.default)(this);
|
||
room.setRoomOptions(options);
|
||
this.emit('room');
|
||
return room;
|
||
}
|
||
peer(options, isActive = false) {
|
||
if (typeof options == "string") {
|
||
if (this.peers.has(options)) return this.peers.get(options);
|
||
if (this.pairs.has(options)) return this.pairs.get(options);
|
||
}
|
||
let peer = new (0, _peerDefault.default)(this);
|
||
peer.setPeerOptions(options);
|
||
peer.active = isActive;
|
||
this.peers.set(peer.socketId, peer);
|
||
this.emit('peer', peer);
|
||
return peer;
|
||
}
|
||
}
|
||
exports.default = MWSE;
|
||
window.MWSE = MWSE;
|
||
|
||
},{"./Connection":"1vUh4","./EventPool":"602qx","./EventTarget":"faGYI","./IPPressure":"l0Hru","./Peer":"imPsO","./Room":"7JoU4","./WSTSProtocol":"i9gBw","@parcel/transformer-js/src/esmodule-helpers.js":"4KC4J"}],"1vUh4":[function(require,module,exports,__globalThis) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
parcelHelpers.export(exports, "Connection", ()=>Connection);
|
||
class Connection {
|
||
constructor(mwse, options){
|
||
this.autoPair = false;
|
||
this.connected = false;
|
||
this.autoReconnect = true;
|
||
this.autoReconnectTimeout = 3000;
|
||
this.recaivePackEvent = [];
|
||
this.activeConnectionEvent = [];
|
||
this.passiveConnectionEvent = [];
|
||
if (options.endpoint == "auto") {
|
||
const RootURL = document.currentScript.src;
|
||
let scriptPath = new URL(RootURL);
|
||
let isSecurity = scriptPath.protocol == "https:";
|
||
let dumeUrl = scriptPath.pathname.split('/').slice(0, -1).join('/') + '/';
|
||
let wsSocket = new URL(dumeUrl, scriptPath);
|
||
wsSocket.protocol = isSecurity ? 'wss:' : 'ws:';
|
||
this.endpoint = new URL(wsSocket.href);
|
||
} else try {
|
||
// Testing
|
||
this.endpoint = new URL(options.endpoint);
|
||
} catch {
|
||
throw new Error("endpoint is required");
|
||
}
|
||
if (typeof options.autoReconnect == "boolean") this.autoReconnect = true;
|
||
else if (options.autoReconnect) {
|
||
this.autoReconnect = true;
|
||
this.autoReconnectTimeout = options.autoReconnect.timeout;
|
||
}
|
||
}
|
||
connect() {
|
||
if (this.autoReconnectTimer) clearTimeout(this.autoReconnectTimer);
|
||
this.ws = new WebSocket(this.endpoint.href);
|
||
this.addWSEvents();
|
||
}
|
||
disconnect() {
|
||
/**
|
||
* Eğer bilinerek elle kapatıldıysa otomatik tekrar bağlanmasının
|
||
* önüne geçmek için autoReconnect bayrağını her zaman kapalı tutmak gerekir
|
||
*/ this.autoReconnect = false;
|
||
this.ws.close();
|
||
}
|
||
addWSEvents() {
|
||
this.ws.addEventListener("open", ()=>this.eventOpen());
|
||
this.ws.addEventListener("close", ()=>this.eventClose());
|
||
this.ws.addEventListener("error", ()=>this.eventError());
|
||
this.ws.addEventListener("message", ({ data })=>this.eventMessage(data));
|
||
}
|
||
eventOpen() {
|
||
this.connected = true;
|
||
for (const callback of this.activeConnectionEvent)callback(void 0);
|
||
}
|
||
eventClose() {
|
||
for (const callback of this.passiveConnectionEvent)callback(void 0);
|
||
this.connected = false;
|
||
if (this.autoReconnect) this.autoReconnectTimer = setTimeout(()=>this.connect(), this.autoReconnectTimeout);
|
||
}
|
||
eventError() {
|
||
this.connected = false;
|
||
}
|
||
onRecaivePack(func) {
|
||
this.recaivePackEvent.push(func);
|
||
}
|
||
onActive(func) {
|
||
if (this.connected) func();
|
||
else this.activeConnectionEvent.push(func);
|
||
}
|
||
onPassive(func) {
|
||
if (!this.connected) func();
|
||
else this.passiveConnectionEvent.push(func);
|
||
}
|
||
eventMessage(data) {
|
||
if (typeof data == "string") {
|
||
let $data = JSON.parse(data);
|
||
for (const callback of this.recaivePackEvent)callback($data);
|
||
}
|
||
}
|
||
tranferToServer(data) {
|
||
if (this.connected) this.ws.send(JSON.stringify(data));
|
||
}
|
||
}
|
||
|
||
},{"@parcel/transformer-js/src/esmodule-helpers.js":"4KC4J"}],"4KC4J":[function(require,module,exports,__globalThis) {
|
||
exports.interopDefault = function(a) {
|
||
return a && a.__esModule ? a : {
|
||
default: a
|
||
};
|
||
};
|
||
exports.defineInteropFlag = function(a) {
|
||
Object.defineProperty(a, '__esModule', {
|
||
value: true
|
||
});
|
||
};
|
||
exports.exportAll = function(source, dest) {
|
||
Object.keys(source).forEach(function(key) {
|
||
if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) return;
|
||
Object.defineProperty(dest, key, {
|
||
enumerable: true,
|
||
get: function() {
|
||
return source[key];
|
||
}
|
||
});
|
||
});
|
||
return dest;
|
||
};
|
||
exports.export = function(dest, destName, get) {
|
||
Object.defineProperty(dest, destName, {
|
||
enumerable: true,
|
||
get: get
|
||
});
|
||
};
|
||
|
||
},{}],"602qx":[function(require,module,exports,__globalThis) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
class EventPool {
|
||
constructor(wsts){
|
||
this.events = new Map();
|
||
this.signals = new Map();
|
||
this.requests = new Map();
|
||
this.count = 0;
|
||
this.wsts = wsts;
|
||
}
|
||
request(msg) {
|
||
return new Promise((ok, rej)=>{
|
||
let id = ++this.count;
|
||
this.events.set(id, [
|
||
(data)=>{
|
||
ok(data);
|
||
},
|
||
(data)=>{
|
||
rej(data);
|
||
}
|
||
]);
|
||
this.wsts.WSTSProtocol.SendRequest(msg, id);
|
||
});
|
||
}
|
||
stream(msg, callback) {
|
||
let id = ++this.count;
|
||
this.wsts.WSTSProtocol.StartStream(msg, id);
|
||
this.events.set(id, [
|
||
(data)=>{
|
||
callback(data);
|
||
},
|
||
()=>{}
|
||
]);
|
||
}
|
||
signal(event, callback) {
|
||
let T = this.signals.get(event);
|
||
if (!T) this.signals.set(event, [
|
||
callback
|
||
]);
|
||
else T.push(callback);
|
||
}
|
||
}
|
||
exports.default = EventPool;
|
||
|
||
},{"@parcel/transformer-js/src/esmodule-helpers.js":"4KC4J"}],"faGYI":[function(require,module,exports,__globalThis) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
class EventTarget {
|
||
emit(eventName, ...args) {
|
||
if (this.events[eventName]) for (const callback of this.events[eventName])callback(...args);
|
||
}
|
||
on(eventName, callback) {
|
||
if (this.events[eventName]) this.events[eventName].push(callback);
|
||
else this.events[eventName] = [
|
||
callback
|
||
];
|
||
}
|
||
scope(f) {
|
||
if (this.activeScope) f();
|
||
else this.on('scope', f);
|
||
}
|
||
constructor(){
|
||
this.events = {};
|
||
this.activeScope = false;
|
||
}
|
||
}
|
||
exports.default = EventTarget;
|
||
|
||
},{"@parcel/transformer-js/src/esmodule-helpers.js":"4KC4J"}],"l0Hru":[function(require,module,exports,__globalThis) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
parcelHelpers.export(exports, "IPPressure", ()=>IPPressure);
|
||
class IPPressure {
|
||
constructor(mwse){
|
||
this.mwse = mwse;
|
||
}
|
||
async allocAPIPAddress() {
|
||
let { status, ip } = await this.mwse.EventPooling.request({
|
||
type: 'alloc/APIPAddress'
|
||
});
|
||
if (status == 'success') {
|
||
this.APIPAddress = ip;
|
||
return ip;
|
||
} else throw new Error("Error Allocated Access Point IP Address");
|
||
}
|
||
async allocAPNumber() {
|
||
let { status, number } = await this.mwse.EventPooling.request({
|
||
type: 'alloc/APNumber'
|
||
});
|
||
if (status == 'success') {
|
||
this.APNumber = number;
|
||
return number;
|
||
} else throw new Error("Error Allocated Access Point Number");
|
||
}
|
||
async allocAPShortCode() {
|
||
let { status, code } = await this.mwse.EventPooling.request({
|
||
type: 'alloc/APShortCode'
|
||
});
|
||
if (status == 'success') {
|
||
this.APShortCode = code;
|
||
return code;
|
||
} else throw new Error("Error Allocated Access Point Short Code");
|
||
}
|
||
async reallocAPIPAddress() {
|
||
let { status, ip } = await this.mwse.EventPooling.request({
|
||
type: 'realloc/APIPAddress'
|
||
});
|
||
if (status == 'success') {
|
||
this.APIPAddress = ip;
|
||
return ip;
|
||
} else throw new Error("Error Reallocated Access Point IP Address");
|
||
}
|
||
async reallocAPNumber() {
|
||
let { status, number } = await this.mwse.EventPooling.request({
|
||
type: 'realloc/APNumber'
|
||
});
|
||
if (status == 'success') {
|
||
this.APNumber = number;
|
||
return number;
|
||
} else throw new Error("Error Reallocated Access Point Number");
|
||
}
|
||
async reallocAPShortCode() {
|
||
let { status, code } = await this.mwse.EventPooling.request({
|
||
type: 'realloc/APShortCode'
|
||
});
|
||
if (status == 'success') {
|
||
this.APShortCode = code;
|
||
return code;
|
||
} else throw new Error("Error Reallocated Access Point Short Code");
|
||
}
|
||
async releaseAPIPAddress() {
|
||
let { status } = await this.mwse.EventPooling.request({
|
||
type: 'release/APIPAddress'
|
||
});
|
||
if (status == 'success') this.APIPAddress = undefined;
|
||
else throw new Error("Error release Access Point IP Address");
|
||
}
|
||
async releaseAPNumber() {
|
||
let { status } = await this.mwse.EventPooling.request({
|
||
type: 'release/APNumber'
|
||
});
|
||
if (status == 'success') this.APNumber = undefined;
|
||
else throw new Error("Error release Access Point Number");
|
||
}
|
||
async releaseAPShortCode() {
|
||
let { status } = await this.mwse.EventPooling.request({
|
||
type: 'release/APShortCode'
|
||
});
|
||
if (status == 'success') this.APShortCode = undefined;
|
||
else throw new Error("Error release Access Point Short Code");
|
||
}
|
||
async queryAPIPAddress(ip) {
|
||
let { status, socket } = await this.mwse.EventPooling.request({
|
||
type: 'whois/APIPAddress',
|
||
whois: ip
|
||
});
|
||
if (status == "success") return socket;
|
||
else return null;
|
||
}
|
||
async queryAPNumber(number) {
|
||
let { status, socket } = await this.mwse.EventPooling.request({
|
||
type: 'whois/APNumber',
|
||
whois: number
|
||
});
|
||
if (status == "success") return socket;
|
||
else return null;
|
||
}
|
||
async queryAPShortCode(code) {
|
||
let { status, socket } = await this.mwse.EventPooling.request({
|
||
type: 'whois/APShortCode',
|
||
whois: code
|
||
});
|
||
if (status == "success") return socket;
|
||
else return null;
|
||
}
|
||
}
|
||
|
||
},{"@parcel/transformer-js/src/esmodule-helpers.js":"4KC4J"}],"imPsO":[function(require,module,exports,__globalThis) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
var _eventTarget = require("./EventTarget");
|
||
var _eventTargetDefault = parcelHelpers.interopDefault(_eventTarget);
|
||
var _peerInfo = require("./PeerInfo");
|
||
var _webRTC = require("./WebRTC");
|
||
var _webRTCDefault = parcelHelpers.interopDefault(_webRTC);
|
||
var IMessageSymbase = /*#__PURE__*/ function(IMessageSymbase) {
|
||
IMessageSymbase[IMessageSymbase["PayloadMessagePack"] = -12873.54] = "PayloadMessagePack";
|
||
IMessageSymbase[IMessageSymbase["PayloadRTCBasePack"] = -12884.54] = "PayloadRTCBasePack";
|
||
return IMessageSymbase;
|
||
}(IMessageSymbase || {});
|
||
class Peer extends (0, _eventTargetDefault.default) {
|
||
constructor(wsts){
|
||
super(), this.options = {}, this.selfSocket = false, this.active = false, this.peerConnection = false, this.primaryChannel = "datachannel";
|
||
this.mwse = wsts;
|
||
this.rtc = this.createRTC();
|
||
this.info = new (0, _peerInfo.PeerInfo)(this);
|
||
this.on('pack', (data)=>{
|
||
if (data.type == ':rtcpack:') return this.rtc.emit("input", data.payload);
|
||
this.emit("message", data);
|
||
});
|
||
}
|
||
createRTC(rtcConfig, rtcServers) {
|
||
this.rtc = new (0, _webRTCDefault.default)(rtcConfig, rtcServers);
|
||
this.rtc.peer = this;
|
||
this.rtc.on("connected", ()=>{
|
||
this.peerConnection = true;
|
||
});
|
||
this.rtc.on('disconnected', ()=>{
|
||
this.peerConnection = false;
|
||
});
|
||
this.rtc.on("output", (payload)=>{
|
||
this.send({
|
||
type: ':rtcpack:',
|
||
payload: payload
|
||
});
|
||
});
|
||
this.rtc.on("message", (payload)=>{
|
||
this.emit("pack", payload);
|
||
});
|
||
return this.rtc;
|
||
}
|
||
setPeerOptions(options) {
|
||
if (typeof options == "string") this.setSocketId(options);
|
||
else this.options = options;
|
||
}
|
||
setSocketId(uuid) {
|
||
this.socketId = uuid;
|
||
}
|
||
async metadata() {
|
||
if (this.socketId == 'me') {
|
||
let result = await this.mwse.EventPooling.request({
|
||
type: 'my/socketid'
|
||
});
|
||
this.selfSocket = true;
|
||
this.active ||= true;
|
||
this.socketId = result;
|
||
this.emit('scope');
|
||
this.activeScope = true;
|
||
return result;
|
||
}
|
||
}
|
||
async request(pack) {
|
||
if (this.active) return await this.mwse.request(this.socketId, pack);
|
||
}
|
||
equalTo(peer) {
|
||
return this.socketId == peer.socketId;
|
||
}
|
||
async isReachable() {
|
||
return await this.mwse.EventPooling.request({
|
||
type: 'is/reachable',
|
||
to: this.socketId
|
||
});
|
||
}
|
||
async enablePairAuth() {
|
||
await this.mwse.EventPooling.request({
|
||
type: 'auth/pair-system',
|
||
value: 'everybody'
|
||
});
|
||
}
|
||
async disablePairAuth() {
|
||
await this.mwse.EventPooling.request({
|
||
type: 'auth/pair-system',
|
||
value: 'disable'
|
||
});
|
||
}
|
||
async enablePairInfo() {
|
||
await this.mwse.EventPooling.request({
|
||
type: 'connection/pairinfo',
|
||
value: true
|
||
});
|
||
}
|
||
async disablePairInfo() {
|
||
await this.mwse.EventPooling.request({
|
||
type: 'connection/pairinfo',
|
||
value: false
|
||
});
|
||
}
|
||
async requestPair() {
|
||
let { message, status } = await this.mwse.EventPooling.request({
|
||
type: 'request/pair',
|
||
to: this.socketId
|
||
});
|
||
if (message == "ALREADY-PAIRED" || message == "ALREADY-REQUESTED") console.warn("Already paired or pair requested");
|
||
if (status == "fail") {
|
||
console.error("Request Pair Error", status, message);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
async endPair() {
|
||
await this.mwse.EventPooling.request({
|
||
type: 'end/pair',
|
||
to: this.socketId
|
||
});
|
||
this.forget();
|
||
}
|
||
async acceptPair() {
|
||
let { message, status } = await this.mwse.EventPooling.request({
|
||
type: 'accept/pair',
|
||
to: this.socketId
|
||
});
|
||
if (status == "fail") {
|
||
console.error("Pair Error", status, message);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
async rejectPair() {
|
||
let { message, status } = await this.mwse.EventPooling.request({
|
||
type: 'reject/pair',
|
||
to: this.socketId
|
||
});
|
||
if (status == "fail") {
|
||
console.error("Pair Error", status, message);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
async getPairedList() {
|
||
let { value } = await this.mwse.EventPooling.request({
|
||
type: 'pair/list',
|
||
to: this.socketId
|
||
});
|
||
return value;
|
||
}
|
||
async send(pack) {
|
||
let isOpenedP2P = this.peerConnection && this.rtc?.active;
|
||
let isOpenedServer = this.mwse.server.connected;
|
||
let sendChannel;
|
||
if (isOpenedP2P && isOpenedServer) {
|
||
if (this.primaryChannel == "websocket") sendChannel = "websocket";
|
||
else sendChannel = "datachannel";
|
||
} else if (isOpenedServer) sendChannel = "websocket";
|
||
else sendChannel = "datachannel";
|
||
if (sendChannel == "websocket") {
|
||
if (!this.mwse.writable) return console.warn("Socket is not writable");
|
||
await this.mwse.EventPooling.request({
|
||
type: 'pack/to',
|
||
pack,
|
||
to: this.socketId
|
||
});
|
||
} else {
|
||
if (pack.type != ':rtcpack:') this.rtc?.sendMessage(pack);
|
||
else return console.warn("Socket is not writable");
|
||
}
|
||
}
|
||
async forget() {
|
||
this.mwse.peers.delete(this.socketId);
|
||
this.mwse.pairs.delete(this.socketId);
|
||
}
|
||
}
|
||
exports.default = Peer;
|
||
|
||
},{"./EventTarget":"faGYI","./PeerInfo":"4gWZ7","./WebRTC":"buLge","@parcel/transformer-js/src/esmodule-helpers.js":"4KC4J"}],"4gWZ7":[function(require,module,exports,__globalThis) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
parcelHelpers.export(exports, "PeerInfo", ()=>PeerInfo);
|
||
class PeerInfo {
|
||
constructor(mwse){
|
||
this.info = {};
|
||
this.peer = mwse;
|
||
}
|
||
async fetch(name) {
|
||
if (name) {
|
||
let rinfo = await this.peer.mwse.EventPooling.request({
|
||
type: "peer/info",
|
||
peer: this.peer.socketId,
|
||
name
|
||
});
|
||
if (rinfo.status == "success") this.info = rinfo.info;
|
||
else console.warn(rinfo.message);
|
||
} else {
|
||
let rinfo = await this.peer.mwse.EventPooling.request({
|
||
type: "peer/info",
|
||
peer: this.peer.socketId
|
||
});
|
||
if (rinfo.status == "success") this.info = rinfo.info;
|
||
else console.warn(rinfo.message);
|
||
}
|
||
return this.info;
|
||
}
|
||
set(name, value) {
|
||
this.info[name] = value;
|
||
this.peer.mwse.WSTSProtocol.SendOnly({
|
||
type: "auth/info",
|
||
name,
|
||
value
|
||
});
|
||
}
|
||
get(name) {
|
||
return name ? this.info[name] : this.info;
|
||
}
|
||
}
|
||
|
||
},{"@parcel/transformer-js/src/esmodule-helpers.js":"4KC4J"}],"buLge":[function(require,module,exports,__globalThis) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
var _p2PfileSender = require("./P2PFileSender");
|
||
var _p2PfileSenderDefault = parcelHelpers.interopDefault(_p2PfileSender);
|
||
class WebRTC {
|
||
static{
|
||
this.channels = new Map();
|
||
}
|
||
static{
|
||
this.requireGC = false;
|
||
}
|
||
static{
|
||
this.defaultRTCConfig = {
|
||
iceCandidatePoolSize: 0,
|
||
iceTransportPolicy: "all",
|
||
rtcpMuxPolicy: "require"
|
||
};
|
||
}
|
||
isPolite() {
|
||
let myId = this.peer?.mwse.peer('me').socketId;
|
||
let peerId = this.peer?.socketId;
|
||
return myId < peerId;
|
||
}
|
||
static{
|
||
this.defaultICEServers = [
|
||
{
|
||
urls: "stun:stun.l.google.com:19302"
|
||
},
|
||
{
|
||
urls: "stun:stun1.l.google.com:19302"
|
||
},
|
||
{
|
||
urls: "stun:stun2.l.google.com:19302"
|
||
},
|
||
{
|
||
urls: "stun:stun3.l.google.com:19302"
|
||
},
|
||
{
|
||
urls: "stun:stun4.l.google.com:19302"
|
||
}
|
||
];
|
||
}
|
||
constructor(rtcConfig, rtcServers){
|
||
this.active = false;
|
||
this.connectionStatus = "new";
|
||
this.iceStatus = "new";
|
||
this.gatheringStatus = "new";
|
||
this.signalingStatus = "";
|
||
this.recaivingStream = new Map();
|
||
this.sendingStream = new Map();
|
||
this.events = {};
|
||
this.makingOffer = false;
|
||
this.ignoreOffer = false;
|
||
this.isSettingRemoteAnswerPending = false;
|
||
this.candicatePack = [];
|
||
let config = {};
|
||
if (rtcConfig) Object.assign(config, WebRTC.defaultRTCConfig, rtcConfig);
|
||
else Object.assign(config, WebRTC.defaultRTCConfig);
|
||
config.iceServers = rtcServers || WebRTC.defaultICEServers;
|
||
this.rtc = new RTCPeerConnection(config);
|
||
this.rtc.addEventListener("connectionstatechange", ()=>{
|
||
this.eventConnectionState();
|
||
});
|
||
this.rtc.addEventListener("icecandidate", (...args)=>{
|
||
this.eventIcecandidate(...args);
|
||
});
|
||
this.rtc.addEventListener("iceconnectionstatechange", ()=>{
|
||
this.eventICEConnectionState();
|
||
});
|
||
this.rtc.addEventListener("icegatheringstatechange", ()=>{
|
||
this.eventICEGatherinState();
|
||
});
|
||
this.rtc.addEventListener("negotiationneeded", ()=>{
|
||
this.eventNogationNeeded();
|
||
});
|
||
this.rtc.addEventListener("signalingstatechange", ()=>{
|
||
this.eventSignalingState();
|
||
});
|
||
this.rtc.addEventListener("track", (...args)=>{
|
||
this.eventTrack(...args);
|
||
});
|
||
this.rtc.addEventListener("datachannel", (...args)=>{
|
||
this.eventDatachannel(...args);
|
||
});
|
||
this.on('input', async (data)=>{
|
||
switch(data.type){
|
||
case "icecandidate":
|
||
try {
|
||
if (this.rtc.remoteDescription) await this.rtc.addIceCandidate(new RTCIceCandidate(data.value));
|
||
else this.candicatePack.push(new RTCIceCandidate(data.value));
|
||
} catch (error) {
|
||
debugger;
|
||
} finally{
|
||
console.log("ICE Canbet");
|
||
}
|
||
break;
|
||
case "offer":
|
||
{
|
||
let readyForOffer = !this.makingOffer && (this.rtc.signalingState == "stable" || this.isSettingRemoteAnswerPending);
|
||
const offerCollision = !readyForOffer;
|
||
this.ignoreOffer = !this.isPolite() && offerCollision;
|
||
if (this.ignoreOffer) return;
|
||
this.isSettingRemoteAnswerPending = false;
|
||
await this.rtc.setRemoteDescription(new RTCSessionDescription(data.value));
|
||
this.isSettingRemoteAnswerPending = false;
|
||
for (const candidate of this.candicatePack)await this.rtc.addIceCandidate(candidate);
|
||
let answer = await this.rtc.createAnswer({
|
||
offerToReceiveAudio: true,
|
||
offerToReceiveVideo: true
|
||
});
|
||
await this.rtc.setLocalDescription(answer);
|
||
this.send({
|
||
type: 'answer',
|
||
value: answer
|
||
});
|
||
break;
|
||
}
|
||
case "answer":
|
||
await this.rtc.setRemoteDescription(new RTCSessionDescription(data.value));
|
||
for (const candidate of this.candicatePack)await this.rtc.addIceCandidate(candidate);
|
||
break;
|
||
case "streamInfo":
|
||
{
|
||
let { id, value } = data;
|
||
let streamInfo = this.recaivingStream.get(id);
|
||
if (!streamInfo) this.recaivingStream.set(id, value);
|
||
else this.recaivingStream.set(id, {
|
||
...streamInfo,
|
||
...value
|
||
});
|
||
this.send({
|
||
type: 'streamAccept',
|
||
id
|
||
});
|
||
break;
|
||
}
|
||
case "streamRemoved":
|
||
{
|
||
let { id } = data;
|
||
this.emit('stream:stopped', this.recaivingStream.get(id));
|
||
this.recaivingStream.delete(id);
|
||
break;
|
||
}
|
||
case "streamAccept":
|
||
{
|
||
let { id } = data;
|
||
let sendingStream = this.sendingStream.get(id);
|
||
let senders = [];
|
||
if (sendingStream && sendingStream.stream) {
|
||
for (const track of sendingStream.stream.getTracks())senders.push(this.rtc.addTrack(track, sendingStream.stream));
|
||
sendingStream.senders = senders;
|
||
}
|
||
this.emit('stream:accepted', sendingStream);
|
||
break;
|
||
}
|
||
case "message":
|
||
this.emit('message', data.payload);
|
||
break;
|
||
}
|
||
});
|
||
}
|
||
addEventListener(event, callback) {
|
||
(this.events[event] || (this.events[event] = [])).push(callback);
|
||
}
|
||
on(event, callback) {
|
||
this.addEventListener(event, callback);
|
||
}
|
||
async dispatch(event, ...args) {
|
||
if (this.events[event]) for (const callback of this.events[event])await callback(...args);
|
||
}
|
||
async emit(event, ...args) {
|
||
await this.dispatch(event, ...args);
|
||
}
|
||
connect() {
|
||
if (!this.channel) this.createDefaultDataChannel();
|
||
}
|
||
sendMessage(data) {
|
||
if (data.type == ':rtcpack:') throw "WebRTC Kanal\u0131nda S\u0131zma";
|
||
this.send({
|
||
type: 'message',
|
||
payload: data
|
||
});
|
||
}
|
||
createDefaultDataChannel() {
|
||
let dt = this.rtc.createDataChannel(':default:', {
|
||
ordered: true
|
||
});
|
||
dt.addEventListener("open", ()=>{
|
||
this.channel = dt;
|
||
WebRTC.channels.set(this.id, this);
|
||
this.active = true;
|
||
});
|
||
dt.addEventListener("message", ({ data })=>{
|
||
let pack = JSON.parse(data);
|
||
this.emit('input', pack);
|
||
});
|
||
dt.addEventListener("close", ()=>{
|
||
this.channel = undefined;
|
||
this.active = false;
|
||
});
|
||
}
|
||
destroy() {
|
||
this.active = false;
|
||
if (this.channel) {
|
||
this.channel.close();
|
||
this.channel = undefined;
|
||
}
|
||
if (this.rtc) this.rtc.close();
|
||
this.emit('disconnected');
|
||
WebRTC.channels.delete(this.id);
|
||
}
|
||
eventDatachannel(event) {
|
||
if (event.channel.label == ':default:') {
|
||
WebRTC.channels.set(this.id, this);
|
||
this.channel = event.channel;
|
||
this.active = true;
|
||
event.channel.addEventListener("message", ({ data })=>{
|
||
let pack = JSON.parse(data);
|
||
this.emit('input', pack);
|
||
});
|
||
event.channel.addEventListener("close", ()=>{
|
||
this.channel = undefined;
|
||
WebRTC.channels.delete(this.id);
|
||
WebRTC.requireGC = true;
|
||
this.active = false;
|
||
});
|
||
} else this.emit('datachannel', event.channel);
|
||
}
|
||
send(data) {
|
||
if (this.channel?.readyState == "open") this.channel.send(JSON.stringify(data));
|
||
else this.emit('output', data);
|
||
}
|
||
eventConnectionState() {
|
||
this.connectionStatus = this.rtc.connectionState;
|
||
if (this.connectionStatus == 'connected') {
|
||
if (this.active == false) this.emit('connected');
|
||
}
|
||
if (this.connectionStatus == 'failed') this.rtc.restartIce();
|
||
if (this.connectionStatus == "closed") {
|
||
if (this.active) this.destroy();
|
||
}
|
||
}
|
||
eventIcecandidate(event) {
|
||
if (event.candidate) this.send({
|
||
type: 'icecandidate',
|
||
value: event.candidate
|
||
});
|
||
}
|
||
eventICEConnectionState() {
|
||
this.iceStatus = this.rtc.iceConnectionState;
|
||
}
|
||
eventICEGatherinState() {
|
||
this.gatheringStatus = this.rtc.iceGatheringState;
|
||
}
|
||
async eventNogationNeeded() {
|
||
try {
|
||
this.makingOffer = true;
|
||
let offer = await this.rtc.createOffer({
|
||
iceRestart: true,
|
||
offerToReceiveAudio: true,
|
||
offerToReceiveVideo: true
|
||
});
|
||
await this.rtc.setLocalDescription(offer);
|
||
this.send({
|
||
type: 'offer',
|
||
value: offer
|
||
});
|
||
} catch (error) {
|
||
console.error(`Nogation Error:`, error);
|
||
} finally{
|
||
this.makingOffer = false;
|
||
}
|
||
}
|
||
eventSignalingState() {
|
||
this.signalingStatus = this.rtc.signalingState;
|
||
}
|
||
eventTrack(event) {
|
||
let rtpRecaiver = event.receiver;
|
||
if (event.streams.length) for (const stream of event.streams){
|
||
let streamInfo = this.recaivingStream.get(stream.id);
|
||
(streamInfo.recaivers || (streamInfo.recaivers = [])).push(rtpRecaiver);
|
||
if (this.recaivingStream.get(stream.id).stream == null) {
|
||
streamInfo.stream = stream;
|
||
this.emit('stream:added', this.recaivingStream.get(stream.id));
|
||
} else streamInfo.stream = stream;
|
||
}
|
||
}
|
||
sendStream(stream, name, info) {
|
||
this.send({
|
||
type: 'streamInfo',
|
||
id: stream.id,
|
||
value: {
|
||
...info,
|
||
name: name
|
||
}
|
||
});
|
||
this.sendingStream.set(stream.id, {
|
||
...info,
|
||
id: stream.id,
|
||
name: name,
|
||
stream
|
||
});
|
||
}
|
||
stopStream(_stream) {
|
||
if (this.connectionStatus != 'connected') return;
|
||
if (this.sendingStream.has(_stream.id)) {
|
||
let { stream } = this.sendingStream.get(_stream.id);
|
||
for (const track of stream.getTracks()){
|
||
for (const RTCPSender of this.rtc.getSenders())if (RTCPSender.track?.id == track.id) this.rtc.removeTrack(RTCPSender);
|
||
}
|
||
this.send({
|
||
type: 'streamRemoved',
|
||
id: stream.id
|
||
});
|
||
this.sendingStream.delete(_stream.id);
|
||
}
|
||
}
|
||
stopAllStreams() {
|
||
if (this.connectionStatus != 'connected') return;
|
||
for (const [, { stream }] of this.sendingStream){
|
||
if (stream == undefined) continue;
|
||
for (const track of stream.getTracks()){
|
||
for (const RTCPSender of this.rtc.getSenders())if (RTCPSender.track?.id == track.id) this.rtc.removeTrack(RTCPSender);
|
||
}
|
||
this.send({
|
||
type: 'streamRemoved',
|
||
id: stream.id
|
||
});
|
||
}
|
||
this.sendingStream.clear();
|
||
}
|
||
async SendFile(file, meta) {
|
||
if (!this.peer) throw new Error("Peer is not ready");
|
||
this.FileTransportChannel = new (0, _p2PfileSenderDefault.default)(this, this.peer);
|
||
await this.FileTransportChannel.SendFile(file, meta);
|
||
}
|
||
async RecaiveFile(chnlCount, filemeta, totalSize) {
|
||
if (!this.peer) throw new Error("Peer is not ready");
|
||
this.FileTransportChannel = new (0, _p2PfileSenderDefault.default)(this, this.peer);
|
||
return await new Promise((recaivedFile)=>{
|
||
if (this.FileTransportChannel) this.FileTransportChannel.RecaiveFile(this.rtc, filemeta, chnlCount, totalSize, (file)=>{
|
||
recaivedFile(file);
|
||
});
|
||
});
|
||
}
|
||
}
|
||
exports.default = WebRTC;
|
||
WebRTC.requireGC = false;
|
||
setInterval(()=>{
|
||
if (WebRTC.requireGC == false) return;
|
||
let img = document.createElement("img");
|
||
img.src = window.URL.createObjectURL(new Blob([
|
||
new ArrayBuffer(5e+7)
|
||
]));
|
||
img.onerror = function() {
|
||
window.URL.revokeObjectURL(this.src);
|
||
};
|
||
WebRTC.requireGC = false;
|
||
}, 3000);
|
||
|
||
},{"./P2PFileSender":"ga16E","@parcel/transformer-js/src/esmodule-helpers.js":"4KC4J"}],"ga16E":[function(require,module,exports,__globalThis) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
class P2PFileSender {
|
||
constructor(webrtc, peer){
|
||
this.totalSize = 0;
|
||
this.isReady = false;
|
||
this.isStarted = false;
|
||
this.isSending = false;
|
||
this.isRecaiving = false;
|
||
this.processedSize = 0;
|
||
this.bufferSizePerChannel = 10e6;
|
||
this.bufferSizePerPack = 10e3;
|
||
this.safeBufferSizePerPack = 9999;
|
||
this.webrtc = webrtc;
|
||
this.rtc = webrtc.rtc;
|
||
this.peer = peer;
|
||
}
|
||
async RecaiveFile(_rtc, fileMetadata, channelCount, _totalSize, onEnded) {
|
||
//let totals = {};
|
||
// let index = 0;
|
||
/*setChannelStatus(Array.from({length:channelCount}).map((e, index) => {
|
||
return {
|
||
name: `${index+1}. Kanal`,
|
||
current: 0,
|
||
currentTotal: 0,
|
||
total: 0
|
||
}
|
||
}));*/ let parts = [];
|
||
this.webrtc.on('datachannel', (datachannel)=>{
|
||
//let channelIndex = index++;
|
||
let current = 0;
|
||
let totalSize = 0;
|
||
let currentPart = 0;
|
||
let bufferAmount = [];
|
||
datachannel.onmessage = function({ data }) {
|
||
if (totalSize == 0) {
|
||
let { size, part } = JSON.parse(data);
|
||
totalSize = size;
|
||
currentPart = part;
|
||
/*updateChannelStatus(channelIndex, n => {
|
||
return {
|
||
...n,
|
||
total: totalSize,
|
||
current: 0
|
||
}
|
||
});*/ datachannel.send("READY");
|
||
} else {
|
||
current += data.byteLength;
|
||
bufferAmount.push(data);
|
||
/*updateChannelStatus(channelIndex, n => {
|
||
return {
|
||
...n,
|
||
current: data.byteLength + n.current,
|
||
currentTotal: data.byteLength + n.currentTotal,
|
||
}
|
||
});
|
||
setProcessedSize(n => n + data.byteLength);*/ if (current == totalSize) {
|
||
parts[currentPart] = new Blob(bufferAmount);
|
||
bufferAmount = [];
|
||
//totals[datachannel.label] += totalSize;
|
||
totalSize = 0;
|
||
currentPart = 0;
|
||
current = 0;
|
||
datachannel.send("TOTAL_RECAIVED");
|
||
}
|
||
}
|
||
};
|
||
datachannel.onclose = ()=>{
|
||
channelCount--;
|
||
if (channelCount == 0) {
|
||
let file = new File(parts, fileMetadata.name, {
|
||
type: fileMetadata.type,
|
||
lastModified: +new Date
|
||
});
|
||
onEnded(file);
|
||
}
|
||
};
|
||
});
|
||
}
|
||
async SendFile(file, metadata) {
|
||
this.isSending = true;
|
||
this.isStarted = true;
|
||
let buffer = await file.arrayBuffer();
|
||
let partCount = Math.ceil(buffer.byteLength / 10e6);
|
||
let channelCount = Math.min(5, partCount);
|
||
if (this.webrtc.iceStatus != "connected") throw new Error("WebRTC is a not ready");
|
||
this.peer.send({
|
||
type: 'file',
|
||
name: file.name,
|
||
size: file.size,
|
||
mimetype: file.type,
|
||
partCount,
|
||
channelCount,
|
||
metadata: metadata
|
||
});
|
||
let channels = [];
|
||
for(let channelIndex = 0; channelIndex < channelCount; channelIndex++){
|
||
let channel = this.rtc.createDataChannel("\\?\\file_" + channelIndex);
|
||
channel.binaryType = "arraybuffer";
|
||
await new Promise((ok)=>{
|
||
channel.onopen = ()=>{
|
||
ok(void 0);
|
||
};
|
||
});
|
||
channels.push(channel);
|
||
}
|
||
let currentPart = 0;
|
||
let next = ()=>{
|
||
if (currentPart < partCount) {
|
||
let bufferPart = buffer.slice(currentPart * 10e6, currentPart * 10e6 + 10e6);
|
||
currentPart++;
|
||
return [
|
||
bufferPart,
|
||
currentPart - 1
|
||
];
|
||
}
|
||
return [
|
||
false,
|
||
0
|
||
];
|
||
};
|
||
let spyChannelIndex = channels.length;
|
||
await new Promise((ok)=>{
|
||
for(let channelIndex = 0; channelIndex < channels.length; channelIndex++)this.sendPartition(channels[channelIndex], next, channelIndex, ()=>{
|
||
spyChannelIndex--;
|
||
if (spyChannelIndex == 0) {
|
||
this.isSending = false;
|
||
this.isStarted = false;
|
||
ok(undefined);
|
||
}
|
||
});
|
||
});
|
||
}
|
||
sendPartition(channel, nextblob10mb, _channelIndex, onEnded) {
|
||
let [currentBuffer, currentPartition] = nextblob10mb();
|
||
let currentPart = 0;
|
||
let next = ()=>{
|
||
if (!(currentBuffer instanceof ArrayBuffer)) return;
|
||
let bufferPart = currentBuffer.slice(currentPart * 16e3, currentPart * 16e3 + 16e3);
|
||
currentPart++;
|
||
if (bufferPart.byteLength != 0) /*
|
||
updateChannelStatus(channelIndex, n => {
|
||
return {
|
||
...n,
|
||
current: bufferPart.byteLength + n.current,
|
||
currentTotal: bufferPart.byteLength + n.currentTotal
|
||
}
|
||
});
|
||
setProcessedSize(n => n + bufferPart.byteLength);
|
||
*/ return bufferPart;
|
||
};
|
||
channel.addEventListener("message", ({ data })=>{
|
||
if (data == "READY") this.sendFileChannel(channel, next);
|
||
if (data == "TOTAL_RECAIVED") {
|
||
[currentBuffer, currentPartition] = nextblob10mb();
|
||
currentPart = 0;
|
||
if (currentBuffer != false) /*updateChannelStatus(channelIndex, n => {
|
||
return {
|
||
...n,
|
||
total: currentBuffer.byteLength,
|
||
current: 0,
|
||
}
|
||
});*/ channel.send(JSON.stringify({
|
||
size: currentBuffer.byteLength,
|
||
part: currentPartition
|
||
}));
|
||
else {
|
||
channel.close();
|
||
onEnded();
|
||
}
|
||
}
|
||
});
|
||
channel.send(JSON.stringify({
|
||
size: currentBuffer.byteLength,
|
||
part: currentPartition
|
||
}));
|
||
}
|
||
sendFileChannel(channel, getNextBlob) {
|
||
channel.addEventListener("bufferedamountlow", function() {
|
||
let buffer = getNextBlob();
|
||
if (buffer) channel.send(buffer);
|
||
});
|
||
channel.bufferedAmountLowThreshold = 15999;
|
||
let c = getNextBlob();
|
||
c && channel.send(c);
|
||
}
|
||
}
|
||
exports.default = P2PFileSender;
|
||
|
||
},{"@parcel/transformer-js/src/esmodule-helpers.js":"4KC4J"}],"7JoU4":[function(require,module,exports,__globalThis) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
var _eventTarget = require("./EventTarget");
|
||
var _eventTargetDefault = parcelHelpers.interopDefault(_eventTarget);
|
||
var _roomInfo = require("./RoomInfo");
|
||
class Room extends (0, _eventTargetDefault.default) {
|
||
constructor(wsts){
|
||
super(), this.peers = new Map();
|
||
this.mwse = wsts;
|
||
this.info = new (0, _roomInfo.RoomInfo)(this);
|
||
}
|
||
setRoomOptions(options) {
|
||
if (typeof options == "string") this.roomId = options;
|
||
else {
|
||
let defaultOptions = {
|
||
joinType: "free",
|
||
ifexistsJoin: true,
|
||
accessType: "private",
|
||
notifyActionInvite: true,
|
||
notifyActionJoined: true,
|
||
notifyActionEjected: true,
|
||
autoFetchInfo: true
|
||
};
|
||
Object.assign(defaultOptions, options);
|
||
this.config = defaultOptions;
|
||
}
|
||
}
|
||
setRoomId(uuid) {
|
||
this.roomId = uuid;
|
||
}
|
||
async createRoom(roomOptions) {
|
||
let config = this.config || roomOptions;
|
||
let result = await this.mwse.EventPooling.request({
|
||
type: 'create-room',
|
||
...config
|
||
});
|
||
if (result.status == 'fail') {
|
||
if (result.message == "ALREADY-EXISTS" && this.config.ifexistsJoin) return this.join();
|
||
throw new Error(result.message || result.messages);
|
||
} else {
|
||
this.options = {
|
||
...this.config,
|
||
...result.room
|
||
};
|
||
this.roomId = result.room.id;
|
||
this.mwse.rooms.set(this.roomId, this);
|
||
}
|
||
}
|
||
async join() {
|
||
let result = await this.mwse.EventPooling.request({
|
||
type: 'joinroom',
|
||
name: this.config.name,
|
||
credential: this.config.credential,
|
||
autoFetchInfo: this.config.autoFetchInfo || false
|
||
});
|
||
if (result.status == 'fail') throw new Error(result.message);
|
||
else {
|
||
this.options = {
|
||
...this.config,
|
||
...result.room
|
||
};
|
||
if (result.info) this.info.info = result.info;
|
||
this.roomId = result.room.id;
|
||
this.mwse.rooms.set(this.roomId, this);
|
||
}
|
||
}
|
||
async eject() {
|
||
let { type } = await this.mwse.EventPooling.request({
|
||
type: 'ejectroom',
|
||
roomId: this.roomId
|
||
});
|
||
this.peers.clear();
|
||
if (type == 'success') this.mwse.rooms.delete(this.roomId);
|
||
}
|
||
async send(pack, wom = false, handshake = false) {
|
||
if (!this.mwse.writable) return console.warn("Socket is not writable");
|
||
if (handshake) {
|
||
let { type } = await this.mwse.EventPooling.request({
|
||
type: 'pack/room',
|
||
pack,
|
||
to: this.roomId,
|
||
wom,
|
||
handshake
|
||
});
|
||
if (type == "fail") throw new Error("Cant send message to room");
|
||
} else await this.mwse.EventPooling.request({
|
||
type: 'pack/room',
|
||
pack,
|
||
to: this.roomId,
|
||
wom,
|
||
handshake
|
||
});
|
||
}
|
||
async fetchPeers(filter, onlyNumber = false) {
|
||
if (onlyNumber) {
|
||
let { count } = await this.mwse.EventPooling.request({
|
||
type: 'room/peer-count',
|
||
roomId: this.roomId,
|
||
filter: filter || {}
|
||
});
|
||
return count;
|
||
} else {
|
||
let { status, peers } = await this.mwse.EventPooling.request({
|
||
type: 'room-peers',
|
||
roomId: this.roomId,
|
||
filter: filter || {}
|
||
});
|
||
let cup = [];
|
||
if (status == 'fail') throw new Error("Cant using peers on room");
|
||
else if (status == 'success') for (const peerid of peers){
|
||
let peer = this.mwse.peer(peerid, true);
|
||
cup.push(peer);
|
||
this.peers.set(peerid, peer);
|
||
}
|
||
return cup;
|
||
}
|
||
}
|
||
}
|
||
exports.default = Room;
|
||
|
||
},{"./EventTarget":"faGYI","./RoomInfo":"5x1BB","@parcel/transformer-js/src/esmodule-helpers.js":"4KC4J"}],"5x1BB":[function(require,module,exports,__globalThis) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
parcelHelpers.export(exports, "RoomInfo", ()=>RoomInfo);
|
||
class RoomInfo {
|
||
constructor(room){
|
||
this.info = {};
|
||
this.room = room;
|
||
this.room.on('updateinfo', (name, value)=>{
|
||
this.info[name] = value;
|
||
});
|
||
}
|
||
async fetch(name) {
|
||
if (name) {
|
||
let rinfo = await this.room.mwse.EventPooling.request({
|
||
type: "room/getinfo",
|
||
roomId: this.room.roomId,
|
||
name
|
||
});
|
||
if (rinfo.status == "success") this.info = rinfo.value;
|
||
else console.warn(rinfo.message);
|
||
} else {
|
||
let rinfo = await this.room.mwse.EventPooling.request({
|
||
type: "room/info",
|
||
roomId: this.room.roomId
|
||
});
|
||
if (rinfo.status == "success") this.info = rinfo.value;
|
||
else console.warn(rinfo.message);
|
||
}
|
||
return this.info;
|
||
}
|
||
set(name, value) {
|
||
this.info[name] = value;
|
||
this.room.mwse.WSTSProtocol.SendOnly({
|
||
type: "room/setinfo",
|
||
roomId: this.room.roomId,
|
||
name,
|
||
value
|
||
});
|
||
}
|
||
get(name) {
|
||
return name ? this.info[name] : this.info;
|
||
}
|
||
}
|
||
|
||
},{"@parcel/transformer-js/src/esmodule-helpers.js":"4KC4J"}],"i9gBw":[function(require,module,exports,__globalThis) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
class WSTSProtocol {
|
||
constructor(wsts){
|
||
this.mwse = wsts;
|
||
this.addListener();
|
||
}
|
||
addListener() {
|
||
this.mwse.server?.onRecaivePack((pack)=>{
|
||
this.PackAnalyze(pack);
|
||
});
|
||
}
|
||
SendRaw(pack) {
|
||
this.mwse.server.tranferToServer(pack);
|
||
}
|
||
SendOnly(pack) {
|
||
this.mwse.server.tranferToServer([
|
||
pack,
|
||
'R'
|
||
]);
|
||
}
|
||
SendRequest(pack, id) {
|
||
this.mwse.server.tranferToServer([
|
||
pack,
|
||
id,
|
||
'R'
|
||
]);
|
||
}
|
||
StartStream(pack, id) {
|
||
this.mwse.server.tranferToServer([
|
||
pack,
|
||
id,
|
||
'S'
|
||
]);
|
||
}
|
||
PackAnalyze(data) {
|
||
let [payload, id, action] = data;
|
||
if (typeof id === 'number') {
|
||
let callback = this.mwse.EventPooling.events.get(id);
|
||
if (callback) {
|
||
callback[0](payload, action);
|
||
switch(action){
|
||
case 'E':
|
||
this.mwse.EventPooling.events.delete(id);
|
||
break;
|
||
case 'S':
|
||
default:
|
||
break;
|
||
}
|
||
} else console.warn("Missing event sended from server");
|
||
} else {
|
||
let signals = this.mwse.EventPooling.signals.get(id);
|
||
if (signals) for (const callback of signals)callback(payload);
|
||
else console.warn("Missing event sended from server");
|
||
}
|
||
}
|
||
}
|
||
exports.default = WSTSProtocol;
|
||
|
||
},{"@parcel/transformer-js/src/esmodule-helpers.js":"4KC4J"}]},["3FuxY"], "3FuxY", "parcelRequiref9d4", {})
|
||
|
||
//# sourceMappingURL=index.js.map
|