Starchik1 commited on
Commit
8e84096
·
verified ·
1 Parent(s): 96162e6

Update index.html

Browse files
Files changed (1) hide show
  1. index.html +150 -53
index.html CHANGED
@@ -12608,7 +12608,25 @@ function findAlignmentPattern(matrix, alignmentPatternQuads, topRight, topLeft,
12608
  });
12609
  </script>
12610
  <script>
12611
- const CHUNK_SIZE = 64 * 1024;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
12612
  const ICE_SERVERS = [
12613
  { urls: 'stun:stun.l.google.com:19302' },
12614
  { urls: 'stun:stun1.l.google.com:19302' },
@@ -12990,6 +13008,27 @@ function generateRoomCode() {
12990
  return Math.random().toString(36).replace(/[^a-z0-9]/gi, '').slice(2, 8).toUpperCase().padEnd(6, 'X');
12991
  }
12992
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
12993
  function badge() {
12994
  const labels = {
12995
  idle: t('badgeIdle'),
@@ -13085,6 +13124,8 @@ function renderAggregateProgress() {
13085
  </div>`;
13086
  }
13087
 
 
 
13088
  // ---------------------------------------------------------------------
13089
  // QR code (vendored qrcode-generator, no external network dependency)
13090
  // ---------------------------------------------------------------------
@@ -13391,8 +13432,10 @@ function reset() {
13391
  signaling?.close();
13392
  deviceListener?.close();
13393
  channel?.close();
 
 
13394
  pc?.close();
13395
- senderPeers.forEach((peer) => { peer.channel?.close(); peer.pc?.close(); });
13396
  senderPeers = new Map();
13397
  signaling = null;
13398
  deviceListener = null;
@@ -13474,16 +13517,30 @@ function createPeerConnection() {
13474
  return pc;
13475
  }
13476
 
 
 
 
 
 
 
 
13477
  function setupDataChannel(nextChannel) {
 
13478
  channel = nextChannel;
13479
- channel.binaryType = 'arraybuffer';
13480
- channel.onopen = () => {
13481
- setConnectionState('connected');
13482
- channel.send(JSON.stringify({ kind: 'peer-info', ...localPeerInfo() }));
13483
- reportConnectionPath(pc, (label) => { const el = $('#connPath'); if (el) el.textContent = label; });
 
 
13484
  };
13485
- channel.onclose = () => setConnectionState(allTransfersDone() ? 'done' : 'disconnected');
13486
- channel.onmessage = (event) => handleDataMessage(event.data);
 
 
 
 
13487
  }
13488
 
13489
  function allTransfersDone() {
@@ -13529,10 +13586,13 @@ async function handleFileRequest(dataChannel, pathSegments, requestId) {
13529
  const fileHandle = await dir.getFileHandle(pathSegments[pathSegments.length - 1]);
13530
  const file = await fileHandle.getFile();
13531
  dataChannel.send(JSON.stringify({ kind: 'meta', id: requestId, name: file.name, size: file.size, type: file.type }));
 
13532
  for (let offset = 0; offset < file.size; offset += CHUNK_SIZE) {
13533
- while (dataChannel.bufferedAmount > 8 * 1024 * 1024) await new Promise((resolve) => setTimeout(resolve, 20));
13534
- const chunk = await file.slice(offset, offset + CHUNK_SIZE).arrayBuffer();
13535
- dataChannel.send(chunk);
 
 
13536
  }
13537
  dataChannel.send(JSON.stringify({ kind: 'done', id: requestId }));
13538
  } catch (error) {
@@ -13566,9 +13626,11 @@ function setupSenderDataChannel(clientId, dataChannel) {
13566
  dataChannel.onopen = () => {
13567
  const entry = senderPeers.get(clientId);
13568
  if (!entry) return;
 
 
13569
  entry.state = 'connected';
13570
- dataChannel.send(JSON.stringify({ kind: 'peer-info', ...localPeerInfo() }));
13571
- if (sharedDirHandle) dataChannel.send(JSON.stringify({ kind: 'folder-shared', name: sharedDirHandle.name }));
13572
  renderReceiversList();
13573
  updateSendButtonState();
13574
  reportConnectionPath(entry.pc, (label) => { entry.path = label; renderReceiversList(); });
@@ -13629,9 +13691,9 @@ async function handleSignal(type, payload, fromClientId) {
13629
  if (type === 'receiver-ready') {
13630
  if (senderPeers.has(fromClientId)) return;
13631
  const peerConnection = createSenderPeerConnection(fromClientId);
13632
- const dataChannel = peerConnection.createDataChannel('files', { ordered: true });
13633
- senderPeers.set(fromClientId, { pc: peerConnection, channel: dataChannel, name: null, path: '', state: 'connecting' });
13634
- setupSenderDataChannel(fromClientId, dataChannel);
13635
  renderReceiversList();
13636
  await peerConnection.setLocalDescription(await peerConnection.createOffer());
13637
  await waitForIceGathering(peerConnection);
@@ -14073,6 +14135,18 @@ function renderQueue() {
14073
  });
14074
  }
14075
 
 
 
 
 
 
 
 
 
 
 
 
 
14076
  async function sendFiles() {
14077
  const activePeers = [...senderPeers.values()].filter((peer) => peer.state === 'connected' && peer.channel?.readyState === 'open');
14078
  if (!activePeers.length || !queued.length) return;
@@ -14088,15 +14162,24 @@ async function sendFiles() {
14088
  transfers.set(file.id, { ...file, status: 'transferring' });
14089
  renderTransfers(false);
14090
 
 
 
 
 
14091
  await Promise.all(activePeers.map(async (peer) => {
14092
  peer.channel.send(JSON.stringify({ kind: 'meta', id: file.id, name: file.name, size: file.size, type: file.type }));
14093
- for (let offset = 0; offset < file.size; offset += CHUNK_SIZE) {
14094
- while (peer.channel.bufferedAmount > 8 * 1024 * 1024) await new Promise((resolve) => setTimeout(resolve, 20));
14095
- const chunk = await file.file.slice(offset, offset + CHUNK_SIZE).arrayBuffer();
14096
- peer.channel.send(chunk);
14097
- aggregateState.sentBytes += chunk.byteLength;
14098
- renderAggregateProgress();
14099
- }
 
 
 
 
 
14100
  peer.channel.send(JSON.stringify({ kind: 'done', id: file.id }));
14101
  }));
14102
 
@@ -14105,6 +14188,7 @@ async function sendFiles() {
14105
  renderTransfers(false);
14106
  }
14107
 
 
14108
  updateSendButtonState();
14109
  notifyTransferComplete('notifyTransferSentBody');
14110
  }
@@ -14125,7 +14209,7 @@ function renderFolderShareBanner() {
14125
  $('#openBrowser').onclick = () => {
14126
  browseState = { path: [], entries: [], loading: true };
14127
  renderFileBrowser();
14128
- channel?.send(JSON.stringify({ kind: 'browse-request', path: [] }));
14129
  };
14130
  }
14131
 
@@ -14167,7 +14251,7 @@ function renderFileBrowser() {
14167
  const path = row.dataset.open.split('/');
14168
  browseState = { path, entries: [], loading: true };
14169
  renderFileBrowser();
14170
- channel?.send(JSON.stringify({ kind: 'browse-request', path }));
14171
  };
14172
  });
14173
 
@@ -14177,7 +14261,7 @@ function renderFileBrowser() {
14177
  const path = browseState.path.slice(0, depth);
14178
  browseState = { path, entries: [], loading: true };
14179
  renderFileBrowser();
14180
- channel?.send(JSON.stringify({ kind: 'browse-request', path }));
14181
  };
14182
  });
14183
 
@@ -14196,7 +14280,7 @@ function renderFileBrowser() {
14196
  const pathSegments = pathKey.split('/');
14197
  const requestId = crypto.randomUUID();
14198
  transfers.set(requestId, { id: requestId, name: pathSegments[pathSegments.length - 1], size: 0, transferred: 0, status: 'transferring' });
14199
- channel?.send(JSON.stringify({ kind: 'file-request', path: pathSegments, id: requestId }));
14200
  });
14201
  selectedBrowsePicks.clear();
14202
  renderTransfers(true);
@@ -14224,6 +14308,8 @@ function renderTransfers(showDownloads = true) {
14224
  }).join('');
14225
  }
14226
 
 
 
14227
  function handleDataMessage(data) {
14228
  if (typeof data === 'string') {
14229
  const message = JSON.parse(data);
@@ -14261,45 +14347,56 @@ function handleDataMessage(data) {
14261
  }
14262
 
14263
  if (message.kind === 'meta') {
14264
- receiveBuffers.set(message.id, { ...message, chunks: [], received: 0 });
14265
  transfers.set(message.id, { id: message.id, name: message.name, size: message.size, type: message.type, transferred: 0, status: 'transferring' });
14266
  renderTransfers(true);
14267
  }
14268
 
14269
  if (message.kind === 'done') {
14270
  const received = receiveBuffers.get(message.id);
14271
- const blob = new Blob(received.chunks, { type: received.type || 'application/octet-stream' });
14272
- const url = URL.createObjectURL(blob);
14273
- transfers.set(message.id, { ...transfers.get(message.id), transferred: received.size, status: 'done', url });
14274
- renderTransfers(true);
14275
- if (loadSettings().autoDownload) {
14276
- const link = document.createElement('a');
14277
- link.href = url;
14278
- link.download = received.name;
14279
- link.click();
14280
- }
14281
- if (aggregateState) {
14282
- aggregateState.filesDone = (aggregateState.filesDone || 0) + 1;
14283
- renderAggregateProgress();
14284
- if (aggregateState.totalFiles && aggregateState.filesDone >= aggregateState.totalFiles) {
14285
- notifyTransferComplete('notifyTransferReceivedBody');
14286
- }
14287
- }
14288
  }
14289
 
14290
  return;
14291
  }
14292
 
14293
- const active = [...receiveBuffers.values()].find((file) => file.received < file.size);
14294
- if (!active) return;
14295
- active.chunks.push(data);
14296
- active.received += data.byteLength;
14297
- const transfer = transfers.get(active.id);
14298
- transfer.transferred = Math.min(active.received, active.size);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
14299
  renderTransfers(true);
 
 
 
 
 
 
14300
  if (aggregateState) {
14301
- aggregateState.sentBytes += data.byteLength;
14302
  renderAggregateProgress();
 
 
 
14303
  }
14304
  }
14305
 
 
12608
  });
12609
  </script>
12610
  <script>
12611
+ const CHUNK_SIZE = 256 * 1024;
12612
+ const WHOLE_FILE_READ_LIMIT = 500 * 1024 * 1024; // 500MB — above this, stream from disk instead of buffering in memory
12613
+ const PARALLEL_CHANNELS = 3; // multiple data channels per receiver to work around per-channel SCTP throughput limits
12614
+ const CHUNK_ID_BYTES = 36; // length of a crypto.randomUUID() string
12615
+ const CHUNK_HEADER_BYTES = CHUNK_ID_BYTES + 8; // + 8-byte float64 offset
12616
+
12617
+ function packChunk(id, offset, arrayBuffer) {
12618
+ const combined = new Uint8Array(CHUNK_HEADER_BYTES + arrayBuffer.byteLength);
12619
+ combined.set(new TextEncoder().encode(id), 0);
12620
+ new DataView(combined.buffer).setFloat64(CHUNK_ID_BYTES, offset, true);
12621
+ combined.set(new Uint8Array(arrayBuffer), CHUNK_HEADER_BYTES);
12622
+ return combined.buffer;
12623
+ }
12624
+
12625
+ function unpackChunk(buffer) {
12626
+ const id = new TextDecoder().decode(buffer.slice(0, CHUNK_ID_BYTES));
12627
+ const offset = new DataView(buffer).getFloat64(CHUNK_ID_BYTES, true);
12628
+ return { id, offset, data: buffer.slice(CHUNK_HEADER_BYTES) };
12629
+ }
12630
  const ICE_SERVERS = [
12631
  { urls: 'stun:stun.l.google.com:19302' },
12632
  { urls: 'stun:stun1.l.google.com:19302' },
 
13008
  return Math.random().toString(36).replace(/[^a-z0-9]/gi, '').slice(2, 8).toUpperCase().padEnd(6, 'X');
13009
  }
13010
 
13011
+ function throttle(fn, wait) {
13012
+ let last = 0;
13013
+ let timer = null;
13014
+ return (...args) => {
13015
+ const now = Date.now();
13016
+ const remaining = wait - (now - last);
13017
+ if (remaining <= 0) {
13018
+ clearTimeout(timer);
13019
+ timer = null;
13020
+ last = now;
13021
+ fn(...args);
13022
+ } else if (!timer) {
13023
+ timer = setTimeout(() => {
13024
+ last = Date.now();
13025
+ timer = null;
13026
+ fn(...args);
13027
+ }, remaining);
13028
+ }
13029
+ };
13030
+ }
13031
+
13032
  function badge() {
13033
  const labels = {
13034
  idle: t('badgeIdle'),
 
13124
  </div>`;
13125
  }
13126
 
13127
+ const throttledRenderAggregateProgress = throttle(renderAggregateProgress, 150);
13128
+
13129
  // ---------------------------------------------------------------------
13130
  // QR code (vendored qrcode-generator, no external network dependency)
13131
  // ---------------------------------------------------------------------
 
13432
  signaling?.close();
13433
  deviceListener?.close();
13434
  channel?.close();
13435
+ receiverChannels.forEach((ch) => ch.close());
13436
+ receiverChannels = [];
13437
  pc?.close();
13438
+ senderPeers.forEach((peer) => { peer.channels?.forEach((ch) => ch.close()); peer.pc?.close(); });
13439
  senderPeers = new Map();
13440
  signaling = null;
13441
  deviceListener = null;
 
13517
  return pc;
13518
  }
13519
 
13520
+ let receiverChannels = [];
13521
+
13522
+ function sendControl(message) {
13523
+ const target = receiverChannels.find((ch) => ch.readyState === 'open') || channel;
13524
+ target?.send(JSON.stringify(message));
13525
+ }
13526
+
13527
  function setupDataChannel(nextChannel) {
13528
+ receiverChannels.push(nextChannel);
13529
  channel = nextChannel;
13530
+ nextChannel.binaryType = 'arraybuffer';
13531
+ nextChannel.onopen = () => {
13532
+ if (receiverChannels.filter((ch) => ch.readyState === 'open').length === 1) {
13533
+ setConnectionState('connected');
13534
+ sendControl({ kind: 'peer-info', ...localPeerInfo() });
13535
+ reportConnectionPath(pc, (label) => { const el = $('#connPath'); if (el) el.textContent = label; });
13536
+ }
13537
  };
13538
+ nextChannel.onclose = () => {
13539
+ if (!receiverChannels.some((ch) => ch.readyState === 'open')) {
13540
+ setConnectionState(allTransfersDone() ? 'done' : 'disconnected');
13541
+ }
13542
+ };
13543
+ nextChannel.onmessage = (event) => handleDataMessage(event.data);
13544
  }
13545
 
13546
  function allTransfersDone() {
 
13586
  const fileHandle = await dir.getFileHandle(pathSegments[pathSegments.length - 1]);
13587
  const file = await fileHandle.getFile();
13588
  dataChannel.send(JSON.stringify({ kind: 'meta', id: requestId, name: file.name, size: file.size, type: file.type }));
13589
+ const wholeBuffer = file.size <= WHOLE_FILE_READ_LIMIT ? await file.arrayBuffer() : null;
13590
  for (let offset = 0; offset < file.size; offset += CHUNK_SIZE) {
13591
+ await waitForBufferedAmountLow(dataChannel);
13592
+ const rawChunk = wholeBuffer
13593
+ ? wholeBuffer.slice(offset, offset + CHUNK_SIZE)
13594
+ : await file.slice(offset, offset + CHUNK_SIZE).arrayBuffer();
13595
+ dataChannel.send(packChunk(requestId, offset, rawChunk));
13596
  }
13597
  dataChannel.send(JSON.stringify({ kind: 'done', id: requestId }));
13598
  } catch (error) {
 
13626
  dataChannel.onopen = () => {
13627
  const entry = senderPeers.get(clientId);
13628
  if (!entry) return;
13629
+ entry.openChannels = (entry.openChannels || 0) + 1;
13630
+ if (entry.openChannels < entry.channels.length) return; // wait until every parallel channel is up
13631
  entry.state = 'connected';
13632
+ entry.channel.send(JSON.stringify({ kind: 'peer-info', ...localPeerInfo() }));
13633
+ if (sharedDirHandle) entry.channel.send(JSON.stringify({ kind: 'folder-shared', name: sharedDirHandle.name }));
13634
  renderReceiversList();
13635
  updateSendButtonState();
13636
  reportConnectionPath(entry.pc, (label) => { entry.path = label; renderReceiversList(); });
 
13691
  if (type === 'receiver-ready') {
13692
  if (senderPeers.has(fromClientId)) return;
13693
  const peerConnection = createSenderPeerConnection(fromClientId);
13694
+ const channels = Array.from({ length: PARALLEL_CHANNELS }, (_, i) => peerConnection.createDataChannel(`files-${i}`, { ordered: true }));
13695
+ senderPeers.set(fromClientId, { pc: peerConnection, channels, channel: channels[0], openChannels: 0, name: null, path: '', state: 'connecting' });
13696
+ channels.forEach((ch) => setupSenderDataChannel(fromClientId, ch));
13697
  renderReceiversList();
13698
  await peerConnection.setLocalDescription(await peerConnection.createOffer());
13699
  await waitForIceGathering(peerConnection);
 
14135
  });
14136
  }
14137
 
14138
+ function waitForBufferedAmountLow(dataChannel, threshold = 8 * 1024 * 1024) {
14139
+ if (dataChannel.bufferedAmount <= threshold) return Promise.resolve();
14140
+ return new Promise((resolve) => {
14141
+ dataChannel.bufferedAmountLowThreshold = threshold;
14142
+ const onLow = () => {
14143
+ dataChannel.removeEventListener('bufferedamountlow', onLow);
14144
+ resolve();
14145
+ };
14146
+ dataChannel.addEventListener('bufferedamountlow', onLow);
14147
+ });
14148
+ }
14149
+
14150
  async function sendFiles() {
14151
  const activePeers = [...senderPeers.values()].filter((peer) => peer.state === 'connected' && peer.channel?.readyState === 'open');
14152
  if (!activePeers.length || !queued.length) return;
 
14162
  transfers.set(file.id, { ...file, status: 'transferring' });
14163
  renderTransfers(false);
14164
 
14165
+ // Read once and share the buffer across every receiver instead of re-reading
14166
+ // the same bytes from disk per chunk, per peer — this was the main bottleneck.
14167
+ const wholeBuffer = file.size <= WHOLE_FILE_READ_LIMIT ? await file.file.arrayBuffer() : null;
14168
+
14169
  await Promise.all(activePeers.map(async (peer) => {
14170
  peer.channel.send(JSON.stringify({ kind: 'meta', id: file.id, name: file.name, size: file.size, type: file.type }));
14171
+ const channels = peer.channels && peer.channels.length ? peer.channels : [peer.channel];
14172
+ await Promise.all(channels.map(async (ch, channelIndex) => {
14173
+ for (let offset = channelIndex * CHUNK_SIZE; offset < file.size; offset += CHUNK_SIZE * channels.length) {
14174
+ await waitForBufferedAmountLow(ch);
14175
+ const rawChunk = wholeBuffer
14176
+ ? wholeBuffer.slice(offset, offset + CHUNK_SIZE)
14177
+ : await file.file.slice(offset, offset + CHUNK_SIZE).arrayBuffer();
14178
+ ch.send(packChunk(file.id, offset, rawChunk));
14179
+ aggregateState.sentBytes += rawChunk.byteLength;
14180
+ throttledRenderAggregateProgress();
14181
+ }
14182
+ }));
14183
  peer.channel.send(JSON.stringify({ kind: 'done', id: file.id }));
14184
  }));
14185
 
 
14188
  renderTransfers(false);
14189
  }
14190
 
14191
+ renderAggregateProgress();
14192
  updateSendButtonState();
14193
  notifyTransferComplete('notifyTransferSentBody');
14194
  }
 
14209
  $('#openBrowser').onclick = () => {
14210
  browseState = { path: [], entries: [], loading: true };
14211
  renderFileBrowser();
14212
+ sendControl({ kind: 'browse-request', path: [] });
14213
  };
14214
  }
14215
 
 
14251
  const path = row.dataset.open.split('/');
14252
  browseState = { path, entries: [], loading: true };
14253
  renderFileBrowser();
14254
+ sendControl({ kind: 'browse-request', path });
14255
  };
14256
  });
14257
 
 
14261
  const path = browseState.path.slice(0, depth);
14262
  browseState = { path, entries: [], loading: true };
14263
  renderFileBrowser();
14264
+ sendControl({ kind: 'browse-request', path });
14265
  };
14266
  });
14267
 
 
14280
  const pathSegments = pathKey.split('/');
14281
  const requestId = crypto.randomUUID();
14282
  transfers.set(requestId, { id: requestId, name: pathSegments[pathSegments.length - 1], size: 0, transferred: 0, status: 'transferring' });
14283
+ sendControl({ kind: 'file-request', path: pathSegments, id: requestId });
14284
  });
14285
  selectedBrowsePicks.clear();
14286
  renderTransfers(true);
 
14308
  }).join('');
14309
  }
14310
 
14311
+ const throttledRenderTransfers = throttle(() => renderTransfers(true), 150);
14312
+
14313
  function handleDataMessage(data) {
14314
  if (typeof data === 'string') {
14315
  const message = JSON.parse(data);
 
14347
  }
14348
 
14349
  if (message.kind === 'meta') {
14350
+ receiveBuffers.set(message.id, { ...message, buffer: new Uint8Array(message.size), received: 0, doneSignaled: false });
14351
  transfers.set(message.id, { id: message.id, name: message.name, size: message.size, type: message.type, transferred: 0, status: 'transferring' });
14352
  renderTransfers(true);
14353
  }
14354
 
14355
  if (message.kind === 'done') {
14356
  const received = receiveBuffers.get(message.id);
14357
+ if (!received) return;
14358
+ received.doneSignaled = true;
14359
+ if (received.received >= received.size) finalizeReceivedFile(message.id);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
14360
  }
14361
 
14362
  return;
14363
  }
14364
 
14365
+ const { id, offset, data: payload } = unpackChunk(data);
14366
+ const received = receiveBuffers.get(id);
14367
+ if (!received) return;
14368
+ received.buffer.set(new Uint8Array(payload), offset);
14369
+ received.received += payload.byteLength;
14370
+ const transfer = transfers.get(id);
14371
+ if (transfer) transfer.transferred = Math.min(received.received, received.size);
14372
+ throttledRenderTransfers();
14373
+ if (aggregateState) {
14374
+ aggregateState.sentBytes += payload.byteLength;
14375
+ throttledRenderAggregateProgress();
14376
+ }
14377
+ if (received.doneSignaled && received.received >= received.size) finalizeReceivedFile(id);
14378
+ }
14379
+
14380
+ function finalizeReceivedFile(id) {
14381
+ const received = receiveBuffers.get(id);
14382
+ if (!received || received.finalized) return;
14383
+ received.finalized = true;
14384
+ const blob = new Blob([received.buffer], { type: received.type || 'application/octet-stream' });
14385
+ const url = URL.createObjectURL(blob);
14386
+ transfers.set(id, { ...transfers.get(id), transferred: received.size, status: 'done', url });
14387
  renderTransfers(true);
14388
+ if (loadSettings().autoDownload) {
14389
+ const link = document.createElement('a');
14390
+ link.href = url;
14391
+ link.download = received.name;
14392
+ link.click();
14393
+ }
14394
  if (aggregateState) {
14395
+ aggregateState.filesDone = (aggregateState.filesDone || 0) + 1;
14396
  renderAggregateProgress();
14397
+ if (aggregateState.totalFiles && aggregateState.filesDone >= aggregateState.totalFiles) {
14398
+ notifyTransferComplete('notifyTransferReceivedBody');
14399
+ }
14400
  }
14401
  }
14402