@banou/ripple 0.0.4 → 0.0.8

package/package.json

@@ -1,81 +1,14 @@
-{
-  "name": "@banou/ripple",
-  "version": "0.0.4",
-  "type": "module",
-  "main": "build/index.js",
-  "keywords": [
-    "fkn",
-    "fkn-type:app"
-  ],
-  "files": [
-    "build"
-  ],
-  "scripts": {
-    "___dev": "vite --port 5678",
-    "dev": "vite --port 4560",
-    "__dev": "shx rm -rf ./build && shx mkdir ./build && npm run copy-libav && npm run copy-libass && concurrently \"vite --port 4560\" \"vite build --mode development --watch\"",
-    "_dev": "shx rm -rf ./build && shx mkdir ./build && npm run copy-libav && npm run copy-html && npm run copy-libass && concurrently \"serve -s -C -p 4560 build\" \"vite build --mode development --watch\"",
-    "serve": "serve -s -C -p 4560 build",
-    "build": "shx rm -rf build/ && vite build && npm run copy-libav && npm run copy-libass && npm run copy-html",
-    "copy-libav": "shx cp node_modules/libav-wasm/build/worker.js build/libav-worker.js && shx cp node_modules/libav-wasm/build/libav.wasm build/libav.wasm",
-    "copy-libass": "shx cp node_modules/jassub/dist/jassub-worker.js build/jassub-worker.js && shx cp node_modules/jassub/dist/jassub-worker-modern.wasm build/jassub-worker-modern.wasm",
-    "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
-    "preview": "vite preview",
-    "copy-html": "shx cp src/index.html build/index.html && shx cp src/app.webmanifest build/app.webmanifest && copyfiles -u 2 ./src/assets/* build/assets",
-    "copy-media-player": "copyfiles -u 4 ./node_modules/@banou/media-player/build/* build/tmp && shx rm build/tmp/index.js && shx mv build/tmp/* build && shx rm -rf build/tmp",
-    "build-deps": "npm run build-deps-media-player && npm run build-deps-fkn-lib",
-    "build-deps-local": "npm run build-deps-media-player && npm run build-deps-fkn-lib-local",
-    "build-deps-media-player": "cd node_modules/@banou/media-player && npm i && npm run build && cd ../../..",
-    "build-deps-fkn-lib": "cd node_modules/@fkn/lib && npm i && npm run build && cd ../../..",
-    "build-deps-fkn-lib-local": "cd node_modules/@fkn/lib && npm i && npm run build-dev && cd ../../..",
-    "remove-build-deps": "shx rm -rf node_modules/@banou/media-player"
-  },
-  "dependencies": {
-    "@banou/media-player": "^0.0.1",
-    "@emotion/react": "^11.11.1",
-    "@fkn/lib": "^0.0.2",
-    "@hookform/resolvers": "^3.3.2",
-    "@radix-ui/react-hover-card": "^1.0.7",
-    "@vitejs/plugin-react": "^4.0.4",
-    "chart.js": "^4.4.0",
-    "dexie": "^4.0.0-alpha.4",
-    "idb-keyval": "^6.2.1",
-    "osra": "^0.0.12",
-    "parse-torrent": "^11.0.14",
-    "queue-utils": "^0.0.0",
-    "react": "^18.2.0",
-    "react-chartjs-2": "^5.2.0",
-    "react-dom": "^18.2.0",
-    "react-dropzone": "^14.2.3",
-    "react-feather": "^2.0.10",
-    "react-hook-form": "^7.48.2",
-    "react-router": "^6.16.0",
-    "react-router-dom": "^6.16.0",
-    "rxdb": "^14.17.1",
-    "rxjs": "^7.8.1",
-    "webtorrent": "^2.1.25",
-    "xstate": "^5.0.0-beta.47",
-    "zod": "^3.22.4"
-  },
-  "devDependencies": {
-    "@rollup/plugin-inject": "^5.0.3",
-    "@types/react": "^18.2.15",
-    "@types/react-dom": "^18.2.7",
-    "@types/webtorrent": "^0.109.3",
-    "@types/wicg-file-system-access": "^2023.10.1",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "concurrently": "^8.2.2",
-    "copyfiles": "^2.4.1",
-    "eslint": "^8.45.0",
-    "eslint-plugin-react-hooks": "^4.6.0",
-    "eslint-plugin-react-refresh": "^0.4.3",
-    "node-stdlib-browser": "^1.2.0",
-    "rollup-plugin-polyfill-node": "^0.13.0",
-    "serve": "^14.2.1",
-    "shx": "^0.3.4",
-    "typescript": "^5.2.2",
-    "vite": "^4.4.5",
-    "vite-plugin-top-level-await": "^1.3.0"
-  }
-}
+{
+  "name": "@banou/ripple",
+  "version": "0.0.8",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/banou26/ripple.git"
+  },
+  "keywords": [
+    "fkn",
+    "fkn-type:app"
+  ],
+  "main": "index.js"
+}

package/remote-BLaEXLm6.js

@@ -0,0 +1,209 @@
+import { a as e } from "./build-DEOZ3A7n.js";
+//#region node_modules/@banou/media-player/dist/remote/index.js
+var t = [
+	"loadstart",
+	"loadedmetadata",
+	"loadeddata",
+	"durationchange",
+	"timeupdate",
+	"play",
+	"playing",
+	"pause",
+	"seeking",
+	"seeked",
+	"progress",
+	"ratechange",
+	"volumechange",
+	"ended",
+	"waiting",
+	"stalled",
+	"suspend",
+	"canplay",
+	"canplaythrough",
+	"emptied",
+	"resize",
+	"error"
+], n = [
+	"currentTime",
+	"volume",
+	"muted",
+	"playbackRate"
+], r = [
+	"play",
+	"pause",
+	"load"
+], i = (e) => [
+	"loadstart",
+	...e.readyState >= 1 ? ["loadedmetadata", "durationchange"] : [],
+	...e.readyState >= 2 ? ["loadeddata"] : [],
+	...e.readyState >= 3 ? ["canplay"] : [],
+	"volumechange",
+	"ratechange",
+	"progress",
+	"resize",
+	e.paused ? "pause" : "playing",
+	...e.ended ? ["ended"] : [],
+	...e.error ? ["error"] : []
+], a = (e) => {
+	if (!e) return [];
+	let t = [];
+	for (let n = 0; n < e.length; n++) t.push([e.start(n), e.end(n)]);
+	return t;
+}, o = (e) => ({
+	currentTime: s(e.currentTime),
+	duration: s(e.duration),
+	paused: e.paused,
+	ended: e.ended ?? !1,
+	seeking: e.seeking,
+	readyState: e.readyState,
+	volume: e.volume ?? 1,
+	muted: e.muted ?? !1,
+	playbackRate: e.playbackRate ?? 1,
+	src: e.src ?? "",
+	currentSrc: e.currentSrc ?? "",
+	buffered: a(e.buffered),
+	seekable: a(e.seekable),
+	error: e.error ? {
+		code: e.error.code,
+		message: e.error.message
+	} : null,
+	videoWidth: e.videoWidth ?? 0,
+	videoHeight: e.videoHeight ?? 0
+}), s = (e) => Number.isNaN(e) ? 0 : e, c = {
+	currentTime: 0,
+	duration: 0,
+	paused: !0,
+	ended: !1,
+	seeking: !1,
+	readyState: 0,
+	volume: 1,
+	muted: !1,
+	playbackRate: 1,
+	src: "",
+	currentSrc: "",
+	buffered: [],
+	seekable: [],
+	error: null,
+	videoWidth: 0,
+	videoHeight: 0
+}, l = 8, u = 32, d = (e, t = {}) => {
+	h(t.origin);
+	let n = typeof window < "u" && window.parent !== window;
+	return !t.transport && !n ? () => {} : m(t).serve(e, t);
+}, f = /* @__PURE__ */ new WeakMap(), p = /* @__PURE__ */ new Map(), m = (a) => {
+	let s = a.channel ?? "banou-media-player", d = a.transport, m = `${s}|${a.origin ?? "*"}`, h = d ? f.get(d) ?? (f.set(d, /* @__PURE__ */ new Map()), f.get(d)) : p, g = h.get(m);
+	if (g) return g;
+	let v = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), b = (e) => y.get(e) ?? y.set(e, /* @__PURE__ */ new Set()).get(e), x = (e, t) => {
+		y.get(e)?.delete(t);
+		try {
+			t.onmessage = null, t.close();
+		} catch {}
+	}, S = (e, t, n) => {
+		for (let r of n ? [n] : [...b(e)]) try {
+			r.postMessage(t);
+		} catch {
+			x(e, r);
+		}
+	}, C = (e) => {
+		let t = v.get(e);
+		return t ? o(t) : void 0;
+	}, w = (e, t) => {
+		if (!y.get(e)?.size) return;
+		let n = C(e);
+		n && S(e, {
+			event: t,
+			snapshot: n
+		});
+	}, T = {
+		subscribe: (e, t) => {
+			if (typeof e != "string") throw TypeError("a player id must be a string");
+			if (typeof MessagePort < "u" && !(t instanceof MessagePort)) throw TypeError("subscribe takes a MessagePort");
+			if (!y.has(e) && y.size >= u) throw RangeError("too many players on this channel");
+			let n = b(e);
+			if (n.size >= l) throw RangeError("too many embedders for this player");
+			n.add(t), t.onmessage = () => x(e, t), t.start?.();
+			let r = C(e);
+			r && S(e, {
+				event: "loadstart",
+				snapshot: r
+			}, t);
+		},
+		set: (e, t, r) => {
+			let i = v.get(e);
+			if (!(!i || !n.includes(t))) try {
+				i[t] = r;
+			} catch {}
+		},
+		call: async (e, t) => {
+			let n = v.get(e);
+			if (!(!n || !r.includes(t))) try {
+				t === "play" ? await n.play() : t === "pause" ? n.pause() : n.load?.();
+			} finally {
+				w(e, "timeupdate");
+			}
+		}
+	}, E = new AbortController();
+	E.signal.addEventListener("abort", () => {
+		h.delete(m);
+		for (let [e, t] of y) for (let n of [...t]) x(e, n);
+		y.clear(), v.clear();
+	}, { once: !0 }), e(T, {
+		transport: a.transport ?? {
+			emit: window.parent,
+			receive: _(() => window.parent, a.origin)
+		},
+		origin: a.origin,
+		key: s,
+		unregisterSignal: E.signal
+	});
+	let D = { serve: (e, n) => {
+		let r = n.id ?? "default", a = t.map((t) => [t, () => {
+			v.get(r) === e && w(r, t);
+		}]);
+		for (let [t, n] of a) e.addEventListener(t, n);
+		let s = v.has(r);
+		v.set(r, e), s && S(r, {
+			event: "emptied",
+			snapshot: { ...c }
+		});
+		for (let t of i(o(e))) w(r, t);
+		let l = () => {
+			for (let [t, n] of a) e.removeEventListener(t, n);
+			v.get(r) === e && (v.delete(r), S(r, {
+				event: "emptied",
+				snapshot: { ...c }
+			}));
+		}, u = () => {
+			l(), E.abort();
+		};
+		return n.signal && (n.signal.aborted ? u() : n.signal.addEventListener("abort", u, { once: !0 })), l;
+	} };
+	return h.set(m, D), D;
+}, h = (e) => {
+	if (e === void 0 || e === "*") return;
+	if (e === "null") throw TypeError("an opaque origin (\"null\") cannot be spoken to; leave `origin` unset and the sender check stands alone");
+	let t;
+	try {
+		t = new URL(e);
+	} catch {
+		throw TypeError(`\`origin\` must be an origin like https://example.com, not ${e}`);
+	}
+	if (t.origin !== e) throw TypeError(`\`origin\` must be an origin like ${t.origin}, not ${e}`);
+}, g = (e) => {
+	let t = e && e !== "*" ? e : void 0;
+	return {
+		target: () => t && t !== "null" ? t : "*",
+		admits: (e) => t ? e === t : (e && (t = e), !0)
+	};
+}, _ = (e, t, n = g(t)) => (t) => {
+	let r = (r) => {
+		r.source === e() && n.admits(r.origin) && t(r.data, {
+			source: r.source,
+			origin: r.origin,
+			receiveTransport: window
+		});
+	};
+	return window.addEventListener("message", r), () => window.removeEventListener("message", r);
+};
+//#endregion
+export { d as exposePlayer };

package/sw.js

@@ -0,0 +1,192 @@
+// Copied by the build rather than bundled, so it cannot import. `scripts/build-sw.mjs` replaces the
+// three @stamp lines below and refuses to ship a worker where any of them is still a placeholder.
+
+const PREFIX = new URL('/__ripple-stream/', self.location.href).href
+
+const live = new Map()
+
+/* Stamped at build time. These are the dev defaults and must never reach production: a worker whose
+   BUILD never changes is never reinstalled, so the update this feature announces would never fire. */
+const MODE = "cache"    // @stamp:mode
+const BUILD = "bb553bfd251c2ac2"   // @stamp:build
+const MANIFEST = [["/api-Jq4OSTp1-B4uxQLLk.js","c10b405839d5d665"],["/assets/empty-BvRk9kiK.js","e3b0c44298fc1c14"],["/assets/libtorrent-DS_9Yo8M.js","9cdbeb18165a6fa6"],["/assets/worker-SJZDGuG-.js","5d60edb0c4b932c0"],["/build-DEOZ3A7n.js","ed3b894978c81b60"],["/remote-BLaEXLm6.js","23f487ac31e13c9f"]] // @stamp:manifest
+
+const CACHE = 'ripple-assets-' + BUILD
+
+/**
+ * Which requests this worker may answer from its cache, and the whole of it.
+ *
+ * ONLY hash-named JavaScript chunks. Never the document, never /index.js, never /sw.js. That
+ * narrowness is the design, not a shortcut:
+ *
+ *  - A hashed path names its BYTES, so a hit from any build is correct by construction. There is no
+ *    stale-content failure available here, only a hit or a miss.
+ *  - Everything else stays on the network, which means a bad build is always replaceable by the next
+ *    deploy. A worker that served the document from cache could pin somebody to a broken build with
+ *    no page JavaScript left to run the update check, and nothing short of clearing site data would
+ *    get them out.
+ *
+ * It exists because a deploy rotates these filenames and Cloudflare answers the old path with the
+ * SPA fallback: 200, text/html, which the browser then runs as a module worker. Measured against
+ * production, an earlier build's chunk is byte-identical to one that never existed.
+ */
+const HASHED = /^\/(?:assets\/)?[A-Za-z0-9_.$-]+-[A-Za-z0-9_-]{8,}\.js$/
+
+self.addEventListener('install', (event) => {
+  // PURGE is the remote kill switch: ship src/sw.mode as `purge` and the next deploy's worker takes
+  // over at once, deletes every cache, and answers nothing. It needs no cooperation from the page.
+  if (MODE === 'purge') { self.skipWaiting(); return }
+  /*
+   * No skipWaiting. A new worker installs and WAITS, so a page keeps the build it loaded with until
+   * somebody presses Update. That is the opposite of what this worker used to do, and it is the
+   * point: taking over immediately is what would swap the chunk set under a running engine.
+   */
+  event.waitUntil(
+    caches.open(CACHE)
+      .then((cache) => cache.addAll(MANIFEST.map(([path]) => path)))
+      // A failed precache must not fail the install. The worker still routes and still fills the
+      // cache on demand; a rejected install would leave the origin with no worker at all, which is
+      // strictly worse than one with a cold cache.
+      .catch(() => undefined),
+  )
+})
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil((async () => {
+    if (MODE === 'purge') {
+      for (const key of await caches.keys()) await caches.delete(key)
+      await self.clients.claim()
+      return
+    }
+    // every generation but this one: a hashed chunk is immutable, so old generations are only ever
+    // wasted room, never wrong answers
+    for (const key of await caches.keys()) {
+      if (key.startsWith('ripple-assets-') && key !== CACHE) await caches.delete(key)
+    }
+    await self.clients.claim()
+  })())
+})
+
+self.addEventListener('message', (event) => {
+  const data = event.data
+  if (!data) return
+  if (data.type === 'stream-open') {
+    const port = event.ports[0]
+    if (!port) return
+    live.set(data.id, { name: data.name, size: data.size, port, resolvePull: null })
+    port.postMessage({ type: 'stream-ready' })
+    return
+  }
+  // Answered only while the download is still live: a worker killed mid-download comes back with an empty map.
+  if (data.type === 'ping' && live.has(data.id) && event.source) {
+    event.source.postMessage({ type: 'pong', id: data.id })
+    return
+  }
+  // Pressed Update. Only a WAITING worker ever receives this, and taking over fires controllerchange
+  // in every open page, which is what reloads them all together.
+  if (data.type === 'take-over') self.skipWaiting()
+  if (data.type === 'which-build' && event.source) {
+    event.source.postMessage({ type: 'build', build: BUILD, mode: MODE })
+  }
+})
+
+const disposition = (name) => {
+  const safe = String(name || 'download').replace(/[\r\n"\\]/g, '_')
+  return `attachment; filename="${safe}"; filename*=UTF-8''${encodeURIComponent(name || 'download')}`
+}
+
+self.addEventListener('fetch', (event) => {
+  const url = event.request.url
+
+  /*
+   * The cache route. Checked BEFORE the stream prefix bails out, and deliberately after nothing:
+   * the two never overlap, since a stream URL is under /__ripple-stream/ and can never match a
+   * hashed .js path.
+   *
+   * Cache first, network second, and a miss simply proxies, which is byte-identical to not
+   * intercepting at all. Only same-origin GETs, so a request to any other host is untouched.
+   */
+  if (MODE !== 'purge' && event.request.method === 'GET' && !url.startsWith(PREFIX)) {
+    const path = new URL(url).pathname
+    if (new URL(url).origin === self.location.origin && HASHED.test(path)) {
+      event.respondWith((async () => {
+        const cache = await caches.open(CACHE)
+        const hit = await cache.match(path)
+        if (hit) return hit
+        const fresh = await fetch(event.request)
+        // An HTML answer here IS the bug this worker exists for: the chunk is gone and Cloudflare
+        // served the SPA fallback with a 200. Never store that, or the cache would preserve the
+        // failure across the very reload meant to cure it.
+        const type = fresh.headers.get('content-type') || ''
+        if (fresh.ok && type.includes('javascript')) await cache.put(path, fresh.clone())
+        return fresh
+      })())
+      return
+    }
+  }
+
+  if (!url.startsWith(PREFIX)) return
+
+  const id = url.slice(PREFIX.length).split('/')[0]
+  const entry = live.get(id)
+  // Answered rather than left to fall through: an unclaimed synthetic URL would be served the app's own HTML.
+  if (!entry) {
+    event.respondWith(new Response('Unknown download', { status: 404 }))
+    return
+  }
+
+  const finish = () => {
+    if (entry.done) return
+    entry.done = true
+    live.delete(id)
+    const resolve = entry.resolvePull
+    entry.resolvePull = null
+    if (resolve) resolve()
+  }
+
+  const body = new ReadableStream({
+    start(controller) {
+      entry.port.onmessage = (e) => {
+        const msg = e.data
+        if (!msg || entry.done) return
+        if (msg.type === 'chunk') {
+          controller.enqueue(msg.data)
+          const resolve = entry.resolvePull
+          entry.resolvePull = null
+          if (resolve) resolve()
+          return
+        }
+        if (msg.type === 'end') {
+          controller.close()
+          finish()
+          return
+        }
+        if (msg.type === 'abort') {
+          controller.error(new Error(msg.reason || 'aborted'))
+          finish()
+        }
+      }
+    },
+    // Returning a promise that only settles once the chunk arrives is what creates the backpressure.
+    pull() {
+      return new Promise((resolve) => {
+        entry.resolvePull = resolve
+        entry.port.postMessage({ type: 'pull' })
+      })
+    },
+    cancel(reason) {
+      entry.port.postMessage({ type: 'cancel', reason: String(reason) })
+      finish()
+    },
+  })
+
+  const headers = {
+    'Content-Type': 'application/octet-stream',
+    'Content-Disposition': disposition(entry.name),
+    'Cache-Control': 'no-store',
+  }
+  // Only when it is known exactly: a zip's length is not known until it has been written.
+  if (entry.size > 0) headers['Content-Length'] = String(entry.size)
+
+  event.respondWith(new Response(body, { headers }))
+})

package/build/app.webmanifest

@@ -1,65 +0,0 @@
-{
-  "short_name": "Ripple",
-  "name": "Ripple - A torrent web app",
-  "description": "A torrent app on the web",
-  "icons": [
-    {
-      "src": "./assets/logo.png",
-      "sizes": "512x512",
-      "type": "image/png"
-    }
-  ],
-  "id": "/?source=pwa",
-  "start_url": "/?source=pwa",
-  "background_color": "#3367D6",
-  "display": "standalone",
-  "scope": "/",
-  "theme_color": "#3367D6",
-  "shortcuts": [
-    {
-      "name": "Pause all torrents",
-      "short_name": "Pause all",
-      "description": "Pause all currently downloading torrents",
-      "url": "/?source=pwa&pauseAll=true"
-    }
-  ],
-  "protocol_handlers": [
-    {
-      "protocol": "magnet",
-      "url": "/protocol-handler?magnet=%s"
-    }
-  ],
-  "file_handlers": [
-    {
-      "action": "/file-handler",
-      "accept": {
-        "application/x-bittorrent": [".torrent"],
-        "x-scheme-handler/magnet": ["magnet:?xt=urn:btih:"]
-      },
-      "icons": [
-        {
-          "src": "csv-icon.png",
-          "sizes": "256x256",
-          "type": "image/png"
-        }
-      ]
-    }
-  ],
-  "share_target": {
-    "action": "/share-target",
-    "method": "POST",
-    "enctype": "multipart/form-data",
-    "params": {
-        "files": [
-            {
-                "name": "file",
-                "accept": [
-                    "application/vnd.ripple+json",
-                    "application/json",
-                    ".ripple"
-                ]
-            }
-        ]
-    }
-  }
-}