smoke
1.0.0
Execute servidores da Web em navegadores da Web por meio de WebRTC
Smoke permite que navegadores executem micro servidores Web através de WebRTC
import { Network } from '@sinclair/smoke'
// ------------------------------------------------------------------
//
// Create a Virtual Network
//
// ------------------------------------------------------------------
const { Http } = new Network ( )
// ------------------------------------------------------------------
//
// Create a Http Listener on a Virtual Port
//
// ------------------------------------------------------------------
Http . listen ( { port : 5000 } , request => new Response ( 'hello webrtc' ) )
// ------------------------------------------------------------------
//
// Fetch data over WebRTC
//
// ------------------------------------------------------------------
const text = Http . fetch ( 'http://localhost:5000' ) . then ( r => r . text ( ) ) $ npm install @sinclair/smokeSmoke é uma estrutura experimental de rede e armazenamento de navegador que fornece emulação Http, Tcp e WebSocket sobre WebRTC e armazenamento de arquivos grandes via IndexedDB. Ele é construído como base para o desenvolvimento de serviços da Web ponto a ponto no navegador, com cada navegador acessível por meio de uma rede virtual controlada por aplicativo.
Smoke remodela WebRTC em interfaces compatíveis com WinterCG, permitindo que aplicativos de servidor web tradicionais se tornem portáteis entre ambientes de servidor e navegador. Ele foi desenvolvido para oferecer suporte a arquiteturas de software alternativas onde os serviços centrados no usuário podem ser retirados da nuvem e executados ponto a ponto no navegador.
Licença MIT
As APIs de rede do Smoke são fornecidas por meio de objetos de rede. Um objeto Rede representa uma conexão ativa com um Hub de sinalização compartilhado e expõe as funcionalidades Http, Net e Media usadas para se comunicar com outros objetos de Rede conectados ao mesmo Hub.
import { Network , Hubs } from '@sinclair/smoke'
const { Http , Net , Media , Hub } = new Network ( { hub : new Hubs . Private ( ) } )
const address = await Hub . address ( ) // The address of this Network object.Um hub privado é uma retransmissão na memória que encaminha mensagens WebRTC ICE por meio da API BroadcastChannel do navegador. Um hub privado só pode retransmitir mensagens para a página e outras guias em execução no mesmo processo do navegador. Como os hubs privados não podem facilitar conexões feitas fora da página atual, ela é considerada privada. Este Hub é o padrão.
import { Network , Hubs } from '@sinclair/smoke'
const { Http } = new Network ( { hub : new Hubs . Private ( ) } )A implementação deste hub está atualmente pendente.
import { Network , Hubs } from '@sinclair/smoke'
const { Http } = new Network ( { hub : new Hubs . Public ( 'ws://server/hub' ) } ) A API Http suporta escuta e busca HTTP por meio de WebRTC. Ele também fornece emulação de WebSocket.
const { Http } = new Network ( )Use a função listen para receber solicitações HTTP de peers remotos.
Http . listen ( { port : 5000 } , request => new Response ( 'hello' ) )Use a função fetch para fazer uma solicitação HTTP para pares remotos.
const response = await Http . fetch ( 'http://localhost:5000' )
const message = await response . text ( )Use a função de atualização para converter uma solicitação HTTP em um WebSocket
Http . listen ( { port : 5000 } , request => Http . upgrade ( request , ( socket ) => socket . send ( 'hello' ) ) )Use a função connect para conectar-se a um servidor WebSocket remoto.
const socket = await Http . connect ( 'ws://localhost:5000' )
socket . on ( 'message' , ( event ) => console . log ( event . data ) )
socket . on ( 'error' , ( event ) => console . log ( event ) )
socket . on ( 'close' , ( event ) => console . log ( event ) ) A API Net fornece emulação TCP sobre RTCDataChannel
const { Net } = new Network ( )Use a função listen para aceitar um soquete de entrada.
Net . listen ( { port : 5000 } , async socket => {
const data = await socket . read ( )
await socket . write ( data )
await socket . close ( )
} )Use a função connect para estabelecer uma conexão de rede com um ouvinte remoto.
const socket = await Net . connect ( { hostname : 'localhost' , port : 5000 } )
await socket . write ( new Uint8Array ( 1000 ) )
const data = await socket . read ( ) // Uint8Array()
const end = await socket . read ( ) // null A API Media fornece funcionalidade para enviar e receber objetos MediaStream por WebRTC.
const { Media } = new Network ( )Use a função listen para escutar objetos MediaStream recebidos
Media . listen ( { port : 6000 } , ( receiver ) => {
const video = document . createElement ( 'video' )
video . srcObject = receiver . mediastream
video . play ( )
document . body . appendChild ( video )
receiver . on ( 'close' , ( ) => document . removeChild ( video ) )
} )Use a função send para enviar um MediaStream para um ouvinte
const sender = await Media . send ( { hostname : 'localhost' , port : 6000 } , new MediaStream ( [ ... ] ) )
sender . close ( ) // stop sending live mediaUse a função de áudio para criar um AudioSource transmitível.
const audio = Media . audio ( { src : './audio.mp3' } )
const sender = Media . send ( { hostname : 'localhost' , port : 6000 } , audio . mediastream )Use a função de vídeo para criar um VideoSource transmitível.
const video = Media . video ( { src : './video.mp4' } )
const sender = Media . send ( { hostname : 'localhost' , port : 6000 } , video . mediastream )Use a função padrão para gerar um padrão de teste MediaStream. Esta função pode ser útil para testar streaming de mídia ao vivo sem câmeras da web ou outras fontes de mídia.
const pattern = Media . pattern ( )
const sender = Media . send ( { port : 5000 } , pattern . mediastream ) Smoke fornece um sistema de arquivos hierárquico capaz de armazenar arquivos grandes dentro do navegador. O sistema de arquivos é apoiado por IndexedDB e tem suporte para leitura e gravação de streaming, enumeração de diretório, cópia, movimentação, renomeação, bem como eventos de observação de arquivos e diretórios. Ele foi projetado para atuar como um armazenamento de arquivos estáticos para serviços de rede, mas pode ser usado como um sistema de arquivos de uso geral para aplicativos que precisam armazenar arquivos grandes no navegador.
Use a função open para abrir um sistema de arquivos com o nome de banco de dados fornecido. Se o banco de dados não existir, ele será criado.
import { FileSystem } from '@sinclair/smoke'
const Fs = await FileSystem . open ( '<database-name>' )Use a função stat para retornar informações sobre um arquivo ou diretório.
const stat = await Fs . write ( '/path/file.txt' )Use a função existe para verificar a existência de um caminho.
const exists = await Fs . exists ( '/path/file.txt' )Use a função mkdir para criar um diretório.
await Fs . mkdir ( '/media/videos' )Use a função readdir para retornar objetos stat para o caminho de diretório fornecido.
const stats = await Fs . readdir ( '/media/videos' )Use a função blob para retornar um objeto Blob para um caminho de arquivo.
const blob = await Fs . readdir ( '/video.mp4' )
const url = URL . createObjectUrl ( blob )Use as funções write e writeText para gravar o conteúdo do arquivo.
await Fs . write ( '/path/file.dat' , new Uint8Array ( [ 1 , 2 , 3 , 4 ] ) )
await Fs . writeText ( '/path/file.txt' , 'hello world' )Use as funções read e readText para ler o conteúdo de um arquivo.
const buffer = await fs . read ( '/path/file.dat' )
const content = await Fs . readText ( '/path/file.txt' )Use a função delete para excluir um arquivo ou diretório.
await Fs . delete ( '/path/file.txt' )Use a função renomear para renomear um arquivo ou diretório.
await Fs . writeText ( '/path/fileA.txt' , '...' )
await Fs . rename ( '/path/fileA.txt' , 'fileB.txt' )Use a função copy para copiar um arquivo ou diretório em um diretório de destino.
await Fs . writeText ( '/path/fileA.txt' , '...' )
await Fs . copy ( '/path/fileA.txt' , '/backup' )Use a função move para mover um arquivo ou diretório para um diretório de destino.
await Fs . writeText ( '/path/fileA.txt' , '...' )
await Fs . move ( '/path/fileA.txt' , '/backup' )Use a função watch para observar eventos de arquivos e diretórios.
Fs . watch ( '/dir' , event => console . log ( event ) ) Smoke está aberto à contribuição da comunidade. Certifique-se de enviar um problema aberto antes de enviar sua solicitação pull. O projeto Smoke prefere discussões abertas na comunidade antes de aceitar novos recursos.
