@mercuryworkshop/epoxy-transport 1.0.0

package/dist/main.d.ts

@@ -0,0 +1,15 @@
+import { BareHeaders, TransferrableResponse, type BareTransport } from "@mercuryworkshop/bare-mux";
+export declare class TLSClient implements BareTransport {
+    canstart: boolean;
+    epxclient: Awaited<ReturnType<any>>["EpoxyClient"]["prototype"];
+    wsproxy: string | null;
+    constructor({ wsproxy, mux }: {
+        wsproxy: any;
+        mux: any;
+    });
+    init(): Promise<void>;
+    ready: boolean;
+    meta(): Promise<void>;
+    request(remote: URL, method: string, body: BodyInit | null, headers: BareHeaders, signal: AbortSignal | undefined): Promise<TransferrableResponse>;
+    connect(url: URL, origin: string, protocols: string[], requestHeaders: BareHeaders, onopen: (protocol: string) => void, onmessage: (data: Blob | ArrayBuffer | string) => void, onclose: (code: number, reason: string) => void, onerror: (error: string) => void): (data: Blob | ArrayBuffer | string) => void;
+}

package/esbuild.bundle.mjs

@@ -0,0 +1,94 @@
+// import { dtsPlugin } from "esbuild-plugin-d.ts";
+import { build } from "esbuild";
+import path from 'node:path'
+import fs from 'node:fs'
+import { umdWrapper } from "esbuild-plugin-umd-wrapper";
+
+const umdWrapperOptions = {
+  libraryName: "EpxMod", // default is unset
+  external: "inherit", // <= default
+  amdLoaderName: "define" // <= default
+}
+
+let wasmPlugin = {
+  name: 'wasm',
+  setup(build) {
+    // Resolve ".wasm" files to a path with a namespace
+    build.onResolve({ filter: /\.wasm$/ }, args => {
+      // If this is the import inside the stub module, import the
+      // binary itself. Put the path in the "wasm-binary" namespace
+      // to tell our binary load callback to load the binary file.
+      if (args.namespace === 'wasm-stub') {
+        return {
+          path: args.path,
+          namespace: 'wasm-binary',
+        }
+      }
+
+      // Otherwise, generate the JavaScript stub module for this
+      // ".wasm" file. Put it in the "wasm-stub" namespace to tell
+      // our stub load callback to fill it with JavaScript.
+      //
+      // Resolve relative paths to absolute paths here since this
+      // resolve callback is given "resolveDir", the directory to
+      // resolve imports against.
+      if (args.resolveDir === '') {
+        return // Ignore unresolvable paths
+      }
+      return {
+        path: path.isAbsolute(args.path) ? args.path : path.join(args.resolveDir, args.path),
+        namespace: 'wasm-stub',
+      }
+    })
+
+    // Virtual modules in the "wasm-stub" namespace are filled with
+    // the JavaScript code for compiling the WebAssembly binary. The
+    // binary itself is imported from a second virtual module.
+    build.onLoad({ filter: /.*/, namespace: 'wasm-stub' }, async (args) => ({
+      contents: `import wasm from ${JSON.stringify(args.path)}
+        export default (imports) =>
+          WebAssembly.instantiate(wasm, imports).then(
+            result => result.instance.exports)`,
+    }))
+
+    // Virtual modules in the "wasm-binary" namespace contain the
+    // actual bytes of the WebAssembly file. This uses esbuild's
+    // built-in "binary" loader instead of manually embedding the
+    // binary data inside JavaScript code ourselves.
+    build.onLoad({ filter: /.*/, namespace: 'wasm-binary' }, async (args) => ({
+      contents: await fs.promises.readFile(args.path),
+      loader: 'binary',
+    }))
+  },
+}
+let makeAllPackagesExternalPlugin = {
+  name: 'make-all-packages-external',
+  setup(build) {
+
+    // build.onResolve({ filter: /protocol/ }, args => ({ external: false }))
+    let filter = /^[^.\/]|^\.[^.\/]|^\.\.[^\/]/ // Must not start with "/" or "./" or "../"
+    build.onResolve({ filter }, args => ({ path: args.path, external: true }))
+  },
+}
+
+build({
+  bundle: true,
+  format: "esm",
+  entryPoints: [`./src/main.ts`],
+  outfile: `./dist/index.mjs`,
+  plugins: [wasmPlugin],
+  external: ["fs", "ws", "path"],
+})
+
+build({
+  bundle: true,
+  format: "cjs",
+  entryPoints: [`./src/main.ts`],
+  outfile: `./dist/index.cjs`,
+  external: ["fs", "ws", "path"],
+  plugins: [wasmPlugin, umdWrapper(umdWrapperOptions)]
+  // plugins: [dtsPlugin({
+  //   outDir: `./dist/`,
+  //   tsconfig: "tsconfig.json"
+  // })]
+})

package/lib/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+const { resolve } = require('node:path');
+
+const epoxyPath = resolve(__dirname, '..', 'dist');
+
+exports.epoxyPath = epoxyPath;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@mercuryworkshop/epoxy-transport",
+  "version": "1.0.0",
+  "description": "a bare transport that implements end-to-end encryption with epoxy-tls and wisp",
+  "main": "./dist/index.mjs",
+  "keywords": [],
+  "author": "",
+  "type": "module",
+  "license": "LGPL",
+  "scripts": {
+    "build": "node esbuild.bundle.mjs"
+  },
+  "dependencies": {
+    "@mercuryworkshop/epoxy-tls": "^1.1.1",
+    "esbuild-plugin-umd-wrapper": "^2.0.0",
+    "rollup": "^4.12.0",
+    "rollup-plugin-node-resolve": "^5.2.0",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "ws": "8.16.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.19.11",
+    "esbuild-plugin-d.ts": "^1.2.2"
+  },
+  "exports": {
+    ".": {
+      "browser": {
+        "import": "./dist/index.mjs",
+        "require": "./dist/index.cjs"
+      },
+      "node": {
+        "require": "./lib/index.cjs"
+      }
+    }
+  }
+}

package/src/main.ts

@@ -0,0 +1,63 @@
+import { BareHeaders, BareResponse, TransferrableResponse, type BareTransport } from "@mercuryworkshop/bare-mux";
+import epoxy from "@mercuryworkshop/epoxy-tls";
+export class EpoxyClient implements BareTransport {
+  canstart = true;
+  epxclient: Awaited<ReturnType<any>>["EpoxyClient"]["prototype"] = null!;
+  wisp: string;
+
+  constructor({ wisp }) {
+    this.wisp = wisp;
+  }
+  async init() {
+    let { EpoxyClient } = await epoxy();
+    this.epxclient = await new EpoxyClient(this.wisp, navigator.userAgent, 10);
+
+    this.ready = true;
+  }
+  ready = false;
+  async meta() { }
+
+  async request(
+    remote: URL,
+    method: string,
+    body: BodyInit | null,
+    headers: BareHeaders,
+    signal: AbortSignal | undefined
+  ): Promise<TransferrableResponse> {
+    if (body instanceof Blob)
+      body = await body.arrayBuffer();
+    let payload = await this.epxclient.fetch(remote.href, { method, body, headers, redirect: "manual" });
+
+    return {
+      body: payload.body!,
+      headers: (payload as any).rawHeaders,
+      status: payload.status,
+      statusText: payload.statusText,
+    };
+  }
+
+  connect(
+    url: URL,
+    origin: string,
+    protocols: string[],
+    requestHeaders: BareHeaders,
+    onopen: (protocol: string) => void,
+    onmessage: (data: Blob | ArrayBuffer | string) => void,
+    onclose: (code: number, reason: string) => void,
+    onerror: (error: string) => void,
+  ): (data: Blob | ArrayBuffer | string) => void {
+    let epsocket = this.epxclient.connect_ws(
+      onopen,
+      onclose,
+      onerror,
+      (data: Uint8Array | string) => data instanceof Uint8Array ? onmessage(data.buffer) : onmessage(data),
+      url.href,
+      protocols,
+      origin,
+    );
+
+    return async (data) => {
+      (await epsocket).send(data);
+    };
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+	"compilerOptions": {
+		"outDir": "build",
+		"sourceMap": true,
+		"target": "ES2022",
+		"lib": ["DOM", "DOM.Iterable", "ES2019"],
+		"strict": true,
+		"stripInternal": true,
+		"module": "ES6",
+		"moduleResolution": "node",
+		"allowSyntheticDefaultImports": true,
+		"declaration": true,
+		"noImplicitAny": false
+	},
+	"include": ["src"]
+}