@chrisjowen/wheelhouse 0.1.0 → 0.2.0

package/build/server/chunks/chunks/index2.js-Bxt1T6_K.js

@@ -0,0 +1,46 @@
+import { a3 as getContext, W as noop } from './index.js-B0NFhRTN.js';
+import './exports.js-BZBK1HC9.js';
+import './utils.js-BJgm9WbO.js';
+import './root.js-60iebdW4.js';
+import './utils2.js-BQzn9ikS.js';
+
+const is_legacy = noop.toString().includes("$$") || /function \w+\(\) \{\}/.test(noop.toString());
+const placeholder_url = "a:";
+if (is_legacy) {
+  ({
+    url: new URL(placeholder_url)
+  });
+}
+function context() {
+  return getContext("__request__");
+}
+const page$1 = {
+  get data() {
+    return context().page.data;
+  },
+  get error() {
+    return context().page.error;
+  },
+  get form() {
+    return context().page.form;
+  },
+  get params() {
+    return context().page.params;
+  },
+  get route() {
+    return context().page.route;
+  },
+  get state() {
+    return context().page.state;
+  },
+  get status() {
+    return context().page.status;
+  },
+  get url() {
+    return context().page.url;
+  }
+};
+const page = page$1;
+
+export { page as p };
+//# sourceMappingURL=index2.js-Bxt1T6_K.js.map

package/build/server/chunks/chunks/internal.js-BlgsFxfY.js

@@ -0,0 +1,146 @@
+import { r as root } from './root.js-60iebdW4.js';
+
+let read_implementation = null;
+function set_read_implementation(fn) {
+  read_implementation = fn;
+}
+let public_env = {};
+function set_private_env(environment) {
+}
+function set_public_env(environment) {
+  public_env = environment;
+}
+const error = ({ status, message }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<title>' + message + `</title>
+
+		<style>
+			body {
+				--bg: white;
+				--fg: #222;
+				--divider: #ccc;
+				background: var(--bg);
+				color: var(--fg);
+				font-family:
+					system-ui,
+					-apple-system,
+					BlinkMacSystemFont,
+					'Segoe UI',
+					Roboto,
+					Oxygen,
+					Ubuntu,
+					Cantarell,
+					'Open Sans',
+					'Helvetica Neue',
+					sans-serif;
+				display: flex;
+				align-items: center;
+				justify-content: center;
+				height: 100vh;
+				margin: 0;
+			}
+
+			.error {
+				display: flex;
+				align-items: center;
+				max-width: 32rem;
+				margin: 0 1rem;
+			}
+
+			.status {
+				font-weight: 200;
+				font-size: 3rem;
+				line-height: 1;
+				position: relative;
+				top: -0.05rem;
+			}
+
+			.message {
+				border-left: 1px solid var(--divider);
+				padding: 0 0 0 1rem;
+				margin: 0 0 0 1rem;
+				min-height: 2.5rem;
+				display: flex;
+				align-items: center;
+			}
+
+			.message h1 {
+				font-weight: 400;
+				font-size: 1em;
+				margin: 0;
+			}
+
+			@media (prefers-color-scheme: dark) {
+				body {
+					--bg: #222;
+					--fg: #ddd;
+					--divider: #666;
+				}
+			}
+		</style>
+	</head>
+	<body>
+		<div class="error">
+			<span class="status">` + status + '</span>\n			<div class="message">\n				<h1>' + message + "</h1>\n			</div>\n		</div>\n	</body>\n</html>\n";
+const options = {
+  app_template_contains_nonce: false,
+  async: false,
+  csp: { "mode": "auto", "directives": { "upgrade-insecure-requests": false, "block-all-mixed-content": false }, "reportOnly": { "upgrade-insecure-requests": false, "block-all-mixed-content": false } },
+  csrf_check_origin: true,
+  csrf_trusted_origins: [],
+  embedded: false,
+  env_public_prefix: "PUBLIC_",
+  env_private_prefix: "",
+  hash_routing: false,
+  hooks: null,
+  // added lazily, via `get_hooks`
+  preload_strategy: "modulepreload",
+  root,
+  service_worker: false,
+  service_worker_options: void 0,
+  server_error_boundaries: false,
+  templates: {
+    app: ({ head, body, assets, nonce, env }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<meta name="viewport" content="width=device-width, initial-scale=1" />\n		<link rel="icon" href="' + assets + `/favicon.svg" />
+		<script>
+			// Apply the theme before first paint: ?theme=, then the saved choice, then the OS.
+			(function () {
+				var q = new URLSearchParams(location.search).get('theme');
+				var saved = null;
+				try {
+					saved = localStorage.getItem('wheelhouse-theme');
+				} catch (e) {}
+				var t = q === 'dark' || q === 'light' ? q : saved;
+				var dark = t ? t === 'dark' : matchMedia('(prefers-color-scheme: dark)').matches;
+				document.documentElement.classList.toggle('dark', dark);
+				// The left-hand menu folded to its icon rail, as last chosen.
+				try {
+					if (localStorage.getItem('wheelhouse-nav') === 'rail')
+						document.documentElement.dataset.nav = 'rail';
+				} catch (e) {}
+			})();
+		<\/script>
+		` + head + '\n	</head>\n	<body data-sveltekit-preload-data="hover">\n		<div style="display: contents">' + body + "</div>\n	</body>\n</html>\n",
+    error
+  },
+  version_hash: "xhuyji"
+};
+async function get_hooks() {
+  let handle;
+  let handleFetch;
+  let handleError;
+  let handleValidationError;
+  let init;
+  ({ handle, handleFetch, handleError, handleValidationError, init } = await import('../entries/hooks.server.js-FjSdw_QS.js'));
+  let reroute;
+  let transport;
+  return {
+    handle,
+    handleFetch,
+    handleError,
+    handleValidationError,
+    init,
+    reroute,
+    transport
+  };
+}
+
+export { set_public_env as a, set_read_implementation as b, get_hooks as g, options as o, public_env as p, read_implementation as r, set_private_env as s };
+//# sourceMappingURL=internal.js-BlgsFxfY.js.map

package/build/server/chunks/chunks/live.svelte.js-By2dseJB.js

@@ -0,0 +1,253 @@
+import { p as page } from './index2.js-Bxt1T6_K.js';
+
+const LOST_AFTER_MS = 5e3;
+const REOPEN_MS = 3e3;
+function watchedStream(url, listen, report) {
+  let state = "connecting";
+  let es = null;
+  let lostTimer = null;
+  let reopenTimer = null;
+  const set = (s) => {
+    state = s;
+    report(s);
+  };
+  const lost = () => {
+    if (lostTimer) clearTimeout(lostTimer);
+    lostTimer = null;
+    set("lost");
+  };
+  const open = () => {
+    reopenTimer = null;
+    const source = new EventSource(url);
+    es = source;
+    source.addEventListener("open", () => {
+      if (lostTimer) clearTimeout(lostTimer);
+      lostTimer = null;
+      set("open");
+    });
+    source.addEventListener("error", () => {
+      if (source.readyState === EventSource.CLOSED) {
+        source.close();
+        lost();
+        reopenTimer ??= setTimeout(open, REOPEN_MS);
+        return;
+      }
+      if (state !== "lost") set("connecting");
+      lostTimer ??= setTimeout(lost, LOST_AFTER_MS);
+    });
+    listen(source);
+  };
+  open();
+  return () => {
+    if (lostTimer) clearTimeout(lostTimer);
+    if (reopenTimer) clearTimeout(reopenTimer);
+    es?.close();
+    es = null;
+  };
+}
+const CHANNEL = "wheelhouse-live";
+const LOCK = "wheelhouse-live-leader";
+const CATCH_UP_MS = 2 * 6e4;
+class Live {
+  fleet = null;
+  health = null;
+  messages = null;
+  /** Our own connection to the Wheelhouse server (not Firstmate's state). */
+  connection = "connecting";
+  /** Ticks every 15 s so relative times stay current. */
+  now = Date.now();
+  /** Bumps on every fleet event, for pages that refetch detail. */
+  revision = 0;
+  /** This tab holds the browser's one stream. */
+  leader = false;
+  /**
+   * Set by the ship's bell: called once, in the leader, for each alert the
+   * stream delivers; true when this browser has not rung it before.
+   */
+  claim = () => true;
+  // Plumbing, not page state: nothing renders from these.
+  // eslint-disable-next-line svelte/prefer-svelte-reactivity
+  alertListeners = /* @__PURE__ */ new Set();
+  // eslint-disable-next-line svelte/prefer-svelte-reactivity
+  reviewers = /* @__PURE__ */ new Set();
+  // eslint-disable-next-line svelte/prefer-svelte-reactivity
+  restartListeners = /* @__PURE__ */ new Set();
+  /** The server process this page has been talking to. */
+  serverId = null;
+  /** The leader's latest of each event, for tabs that open later. */
+  latest = {};
+  // eslint-disable-next-line svelte/prefer-svelte-reactivity
+  recentAlerts = /* @__PURE__ */ new Map();
+  channel = null;
+  stop = null;
+  /** Alerts as they arrive, in every tab. */
+  onAlert(fn) {
+    this.alertListeners.add(fn);
+    return () => this.alertListeners.delete(fn);
+  }
+  /**
+   * PR review updates (`review` events) on this same connection: a feature
+   * that needs live updates listens here rather than opening its own stream.
+   */
+  onReview(fn) {
+    this.reviewers.add(fn);
+    return () => this.reviewers.delete(fn);
+  }
+  /** Called in every tab when the stream comes back from a restarted server. */
+  onRestart(fn) {
+    this.restartListeners.add(fn);
+    return () => this.restartListeners.delete(fn);
+  }
+  connect() {
+    if (this.stop) return () => {
+    };
+    const clock = setInterval(() => this.now = Date.now(), 15e3);
+    const shared = typeof BroadcastChannel !== "undefined" && !!globalThis.navigator?.locks;
+    const end = shared ? this.share() : this.lead();
+    this.stop = () => {
+      clearInterval(clock);
+      end();
+      this.stop = null;
+    };
+    return this.stop;
+  }
+  /** Join the browser's shared stream: lead when this tab gets the lock, else follow. */
+  share() {
+    const channel = new BroadcastChannel(CHANNEL);
+    this.channel = channel;
+    channel.onmessage = (m) => {
+      const msg = m.data;
+      if (msg.t === "hello") {
+        if (this.leader) this.replay();
+      } else if (msg.t === "connection") {
+        if (!this.leader) this.connection = msg.state;
+      } else if (!this.leader) {
+        this.apply(msg.e);
+      }
+    };
+    const abort = new AbortController();
+    let release = () => {
+    };
+    navigator.locks.request(LOCK, { signal: abort.signal }, () => {
+      const stopStream = this.lead();
+      return new Promise((resolve) => {
+        release = () => {
+          stopStream();
+          resolve();
+        };
+      });
+    }).catch(() => {
+    });
+    channel.postMessage({ t: "hello" });
+    return () => {
+      abort.abort();
+      release();
+      channel.close();
+      this.channel = null;
+    };
+  }
+  /** Hold the stream: apply each event here and pass it to the other tabs. */
+  lead() {
+    this.leader = true;
+    const state = (s) => {
+      this.connection = s;
+      this.post({ t: "connection", state: s });
+    };
+    const listen = (es) => {
+      const on = (type, make) => es.addEventListener(type, (e) => {
+        const ev = make(JSON.parse(e.data));
+        this.remember(ev);
+        this.apply(ev);
+        this.post({ t: "event", e: ev });
+        if (ev.type === "fleet") state("open");
+      });
+      on("server", (data) => ({ type: "server", data }));
+      on("fleet", (data) => ({ type: "fleet", data }));
+      on("health", (data) => ({ type: "health", data }));
+      on("messages", (data) => ({ type: "messages", data }));
+      on("review", (data) => ({ type: "review", data }));
+      on("alert", (data) => ({ type: "alert", data, fresh: this.claim(data) }));
+      on("settled", (data) => ({ type: "settled", data }));
+      on("alerts", (data) => ({
+        type: "alerts",
+        data: data.map((alert) => {
+          const claimed = this.claim(alert);
+          return {
+            alert,
+            fresh: claimed && Date.now() - Date.parse(alert.at) <= CATCH_UP_MS
+          };
+        })
+      }));
+    };
+    const close = watchedStream("/api/events", listen, state);
+    return () => {
+      close();
+      this.leader = false;
+    };
+  }
+  remember(ev) {
+    if (ev.type === "alert") this.recentAlerts.set(ev.data.id, ev.data);
+    else if (ev.type === "settled") this.recentAlerts.delete(ev.data);
+    else if (ev.type === "alerts") for (const a of ev.data) this.recentAlerts.set(a.alert.id, a.alert);
+    else if (ev.type === "review") return;
+    else this.latest[ev.type] = ev.data;
+    for (const id of [...this.recentAlerts.keys()].slice(0, -40)) {
+      this.recentAlerts.delete(id);
+    }
+  }
+  /** A tab has just opened: send it what the leader has (alerts as old news). */
+  replay() {
+    this.post({ t: "connection", state: this.connection });
+    if (this.latest.fleet) this.post({ t: "event", e: { type: "fleet", data: this.latest.fleet } });
+    if (this.latest.health) this.post({ t: "event", e: { type: "health", data: this.latest.health } });
+    if (this.latest.messages) this.post({
+      t: "event",
+      e: { type: "messages", data: this.latest.messages }
+    });
+    if (this.latest.server) this.post({ t: "event", e: { type: "server", data: this.latest.server } });
+    const alerts = [...this.recentAlerts.values()].map((alert) => ({ alert, fresh: false }));
+    this.post({ t: "event", e: { type: "alerts", data: alerts } });
+  }
+  apply(ev) {
+    switch (ev.type) {
+      case "fleet":
+        this.fleet = ev.data;
+        this.revision++;
+        this.connection = "open";
+        break;
+      case "health":
+        this.health = ev.data;
+        break;
+      case "messages":
+        this.messages = ev.data;
+        break;
+      case "review":
+        for (const fn of this.reviewers) fn(ev.data);
+        break;
+      case "server": {
+        const restarted = this.serverId !== null && this.serverId !== ev.data.id;
+        this.serverId = ev.data.id;
+        if (restarted) for (const fn of this.restartListeners) fn();
+        break;
+      }
+      default:
+        for (const fn of this.alertListeners) fn(ev);
+    }
+  }
+  post(msg) {
+    try {
+      this.channel?.postMessage(msg);
+    } catch {
+    }
+  }
+}
+const live = new Live();
+function currentFleet() {
+  return live.fleet ?? page.data.fleet ?? null;
+}
+function currentHealth() {
+  return live.health ?? page.data.health ?? null;
+}
+
+export { currentFleet as a, currentHealth as c, live as l, watchedStream as w };
+//# sourceMappingURL=live.svelte.js-By2dseJB.js.map

package/build/server/chunks/chunks/loader-circle.js-rQHvIWN7.js

@@ -0,0 +1,16 @@
+import { ac as spread_props } from './index.js-B0NFhRTN.js';
+import { I as Icon } from './Icon.js-CVZZ-yuB.js';
+
+function Loader_circle($$renderer, $$props) {
+  let { $$slots, $$events, ...props } = $$props;
+  const iconData = {
+    "name": "loader-circle",
+    "size": 24,
+    "node": [["path", { "d": "M21 12a9 9 0 1 1-6.219-8.56" }]],
+    "aliases": ["loader-2"]
+  };
+  Icon($$renderer, spread_props([props, { icon: iconData }]));
+}
+
+export { Loader_circle as L };
+//# sourceMappingURL=loader-circle.js-rQHvIWN7.js.map