From a16c2ab0c193ddfd172d453349f0efd4e28a4583 Mon Sep 17 00:00:00 2001 From: Derrick Hammer Date: Sat, 8 Apr 2023 20:42:32 -0400 Subject: [PATCH] *Add dist --- dist/index.d.ts | 56 ++++++++++++++++ dist/index.js | 175 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 231 insertions(+) create mode 100644 dist/index.d.ts create mode 100644 dist/index.js diff --git a/dist/index.d.ts b/dist/index.d.ts new file mode 100644 index 0000000..f22acbd --- /dev/null +++ b/dist/index.d.ts @@ -0,0 +1,56 @@ +import { Client } from "@lumeweb/libkernel-universal"; +export default class Protomux { + private isProtomux; + constructor(stream: any); + private _stream; + get stream(): any; + static from(stream: any): any; + createChannel({ protocol, id, handshake, onopen, onclose, ondestroy, }: { + protocol: string; + id: any; + handshake: any; + onopen?: Function; + onclose?: Function; + ondestroy?: Function; + }): Promise; +} +declare class Channel extends Client { + private protocol; + private id; + private handshake; + private onopen?; + private onclose?; + private ondestroy?; + private _created; + private _send?; + private _queue; + private _inited; + constructor(mux: Protomux, protocol: string, id: any, handshake: any, onopen?: Function, onclose?: Function, ondestroy?: Function); + private _ready; + get ready(): Promise; + private _mux; + get mux(): Protomux; + private _channelId; + get channelId(): number; + open(): Promise; + addMessage({ encoding, onmessage, }: { + encoding?: any; + onmessage: Function; + }): Message; + queueMessage(message: Message): Promise; + private init; +} +declare class Message extends Client { + private encoding; + private onmessage; + private channel; + private _send?; + constructor({ channel, encoding, onmessage, }: { + channel: Channel; + encoding?: any; + onmessage: Function; + }); + init(): Promise; + send(data: any): void; +} +export {}; diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 0000000..2439dc9 --- /dev/null +++ b/dist/index.js @@ -0,0 +1,175 @@ +import { Client, factory } from "@lumeweb/libkernel-universal"; +import { MODULE } from "@lumeweb/kernel-swarm-client"; +import defer from "p-defer"; +import b4a from "b4a"; +export default class Protomux { + isProtomux = true; + constructor(stream) { + this._stream = stream; + if (!stream.userData) { + stream.userData = this; + } + } + _stream; + get stream() { + return this._stream; + } + static from(stream) { + if (stream.userData && stream.userData.isProtomux) + return stream.userData; + if (stream.isProtomux) + return stream; + return new this(stream); + } + async createChannel({ protocol, id = null, handshake = null, onopen = undefined, onclose = undefined, ondestroy = undefined, }) { + return createChannel(this, protocol, id, handshake, onopen, onclose, ondestroy); + } +} +class Channel extends Client { + protocol; + id; + handshake; + onopen; + onclose; + ondestroy; + _created = defer(); + _send; + _queue = []; + _inited = false; + constructor(mux, protocol, id, handshake, onopen, onclose, ondestroy) { + super(); + this._mux = mux; + this.protocol = protocol; + this.id = id; + this.handshake = handshake; + this.onopen = onopen; + this.onclose = onclose; + this.ondestroy = ondestroy; + } + _ready = defer(); + get ready() { + return this._ready.promise; + } + _mux; + get mux() { + return this._mux; + } + _channelId = -1; + get channelId() { + return this._channelId; + } + async open() { + await this.init(); + await this._created; + while (this._queue.length) { + await this._queue.shift()?.init(); + } + this._ready.resolve(); + } + addMessage({ encoding = undefined, onmessage, }) { + return createMessage({ channel: this, encoding, onmessage }); + } + async queueMessage(message) { + this._queue.push(message); + } + async init() { + if (this._inited) { + return; + } + this._inited = true; + const [update, ret] = this.connectModule("createProtomuxChannel", { + id: this._mux.stream.id, + data: { + protocol: this.protocol, + id: this.id, + handshake: this.handshake, + onopen: !!this.onopen, + onclose: !!this.onclose, + ondestroy: !!this.ondestroy, + }, + }, (data) => { + switch (data.action) { + case "onopen": + this.onopen?.(...data.args); + break; + case "onclose": + this.onclose?.(...data.args); + break; + case "ondestroy": + this.ondestroy?.(...data.args); + break; + default: + this._channelId = data; + this._created.resolve(); + } + }); + this._send = update; + ret.catch((e) => this._created.reject(e)); + return this._created.promise; + } +} +class Message extends Client { + encoding; + onmessage; + channel; + _send; + constructor({ channel, encoding = undefined, onmessage = () => { }, }) { + super(); + this.channel = channel; + this.encoding = encoding; + this.onmessage = onmessage; + this.channel.queueMessage(this); + } + async init() { + const created = defer(); + await this.loadLibs(MODULE); + const [update] = this.connectModule("createProtomuxMessage", { + id: this.channel.mux.stream.id, + channelId: this.channel.channelId, + data: { + encoding: !!this.encoding, + onmessage: !!this.onmessage, + }, + }, async (data) => { + if (data?.args && data?.args[0] instanceof Uint8Array) { + data.args[0] = b4a.from(data.args[0]); + } + switch (data.action) { + case "encode": + update({ + action: "encode", + args: [await this.encoding.encode?.(...data.args), data.args[0]], + }); + break; + case "decode": + update({ + action: "decode", + args: [await this.encoding.decode?.(...data.args), data.args[0]], + }); + break; + case "preencode": + update({ + action: "preencode", + args: [ + await this.encoding.preencode?.(...data.args), + data.args[0], + ], + }); + break; + case "onmessage": + this.onmessage?.(...data.args); + break; + case "created": + created.resolve(); + break; + } + }); + this._send = update; + return created.promise; + } + send(data) { + this._send?.({ action: "send", args: [data] }); + } +} +const createChannel = factory(Channel, MODULE); +const createMessage = factory(Message, MODULE);