gitxp 0.0.1

package/.output/server/_ssr/notifications-DUoENv6E.mjs

@@ -0,0 +1,514 @@
+import { n as TSS_SERVER_FUNCTION, t as createServerFn } from "./ssr.mjs";
+import { t as emitChange } from "./events-BNrmOvgU.mjs";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { DatabaseSync } from "node:sqlite";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region node_modules/.nitro/vite/services/ssr/assets/notifications-DUoENv6E.js
+var createServerRpc = (serverFnMeta, splitImportFn) => {
+	const url = "/_serverFn/" + serverFnMeta.id;
+	return Object.assign(splitImportFn, {
+		url,
+		serverFnMeta,
+		[TSS_SERVER_FUNCTION]: true
+	});
+};
+var migrations = [{
+	id: 1,
+	up: (db) => {
+		db.exec(`
+        CREATE TABLE settings (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        ) STRICT;
+
+        CREATE TABLE mutation_queue (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          kind TEXT NOT NULL,
+          payload TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'pending',
+          attempts INTEGER NOT NULL DEFAULT 0,
+          last_error TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        ) STRICT;
+
+        CREATE INDEX mutation_queue_pending ON mutation_queue (status, id);
+
+        CREATE TABLE sync_state (
+          resource TEXT PRIMARY KEY,
+          etag TEXT,
+          last_modified TEXT,
+          poll_interval INTEGER,
+          last_polled_at TEXT,
+          last_status INTEGER
+        ) STRICT;
+
+        CREATE TABLE notifications (
+          thread_id TEXT PRIMARY KEY,
+          raw TEXT NOT NULL,
+          reason TEXT NOT NULL,
+          unread INTEGER NOT NULL,
+          updated_at TEXT NOT NULL,
+          last_read_at TEXT,
+          subject_title TEXT NOT NULL,
+          subject_type TEXT NOT NULL,
+          subject_url TEXT,
+          repo_full_name TEXT NOT NULL
+        ) STRICT;
+
+        CREATE INDEX notifications_recent ON notifications (updated_at DESC);
+      `);
+	}
+}, {
+	id: 2,
+	up: (db) => {
+		db.exec("ALTER TABLE sync_state ADD COLUMN request_url TEXT");
+	}
+}];
+function migrate(db) {
+	for (const migration of migrations) {
+		if (migration.id <= readVersion(db)) continue;
+		db.exec("BEGIN");
+		try {
+			migration.up(db);
+			db.exec(`PRAGMA user_version = ${migration.id}`);
+			db.exec("COMMIT");
+		} catch (error) {
+			db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+}
+function readVersion(db) {
+	return db.prepare("PRAGMA user_version").get().user_version;
+}
+var handle;
+function gitxpHome() {
+	return process.env.GITXP_HOME ?? join(homedir(), ".gitxp");
+}
+function getDb() {
+	if (handle) return handle;
+	const home = gitxpHome();
+	mkdirSync(home, { recursive: true });
+	const db = new DatabaseSync(join(home, "gitxp.db"));
+	db.exec("PRAGMA journal_mode = WAL");
+	db.exec("PRAGMA foreign_keys = ON");
+	db.exec("PRAGMA busy_timeout = 5000");
+	migrate(db);
+	handle = db;
+	return handle;
+}
+var upsert = `
+  INSERT INTO notifications (
+    thread_id, raw, reason, unread, updated_at, last_read_at,
+    subject_title, subject_type, subject_url, repo_full_name
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT (thread_id) DO UPDATE SET
+    raw = excluded.raw,
+    reason = excluded.reason,
+    unread = excluded.unread,
+    updated_at = excluded.updated_at,
+    last_read_at = excluded.last_read_at,
+    subject_title = excluded.subject_title,
+    subject_type = excluded.subject_type,
+    subject_url = excluded.subject_url,
+    repo_full_name = excluded.repo_full_name
+`;
+function upsertNotifications(threads) {
+	if (threads.length === 0) return [];
+	const db = getDb();
+	const statement = db.prepare(upsert);
+	const seen = [];
+	db.exec("BEGIN");
+	try {
+		for (const thread of threads) {
+			statement.run(thread.id, JSON.stringify(thread), thread.reason, thread.unread ? 1 : 0, thread.updated_at, thread.last_read_at, thread.subject.title, thread.subject.type, thread.subject.url, thread.repository.full_name);
+			seen.push(thread.id);
+		}
+		db.exec("COMMIT");
+	} catch (error) {
+		db.exec("ROLLBACK");
+		throw error;
+	}
+	return seen;
+}
+function listNotifications() {
+	return getDb().prepare(`SELECT thread_id, reason, unread, updated_at, last_read_at,
+              subject_title, subject_type, subject_url, repo_full_name
+       FROM notifications
+       ORDER BY updated_at DESC`).all();
+}
+function newestUpdatedAt() {
+	return getDb().prepare("SELECT max(updated_at) AS newest FROM notifications").get().newest;
+}
+function setNotificationRead(threadId) {
+	getDb().prepare(`UPDATE notifications SET unread = 0, last_read_at = ? WHERE thread_id = ?`).run((/* @__PURE__ */ new Date()).toISOString(), threadId);
+}
+function deleteNotification(threadId) {
+	getDb().prepare("DELETE FROM notifications WHERE thread_id = ?").run(threadId);
+}
+function readSyncState(resource) {
+	return getDb().prepare("SELECT * FROM sync_state WHERE resource = ?").get(resource);
+}
+function writeSyncState(state) {
+	getDb().prepare(`INSERT INTO sync_state
+         (resource, etag, last_modified, poll_interval, last_polled_at,
+          last_status, request_url)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT (resource) DO UPDATE SET
+         etag = coalesce(excluded.etag, sync_state.etag),
+         last_modified = coalesce(excluded.last_modified, sync_state.last_modified),
+         poll_interval = coalesce(excluded.poll_interval, sync_state.poll_interval),
+         last_polled_at = excluded.last_polled_at,
+         last_status = excluded.last_status,
+         request_url = excluded.request_url`).run(state.resource, state.etag ?? null, state.lastModified ?? null, state.pollInterval ?? null, (/* @__PURE__ */ new Date()).toISOString(), state.status, state.requestUrl);
+}
+var run = promisify(execFile);
+var pending;
+function getAuth() {
+	if (!pending) pending = readAuth().catch((error) => {
+		pending = void 0;
+		throw error;
+	});
+	return pending;
+}
+function forgetAuth() {
+	pending = void 0;
+}
+async function readAuth() {
+	const host = await readActiveHost();
+	const { stdout } = await run("gh", [
+		"auth",
+		"token",
+		"--hostname",
+		host
+	]);
+	const token = stdout.trim();
+	if (!token) throw new Error(`gh returned no token for ${host}. Run \`gh auth login\`.`);
+	return {
+		host,
+		token,
+		apiBase: apiBaseFor(host)
+	};
+}
+async function readActiveHost() {
+	if (process.env.GH_HOST) return process.env.GH_HOST;
+	const { stdout } = await run("gh", [
+		"auth",
+		"status",
+		"--json",
+		"hosts"
+	]);
+	const hosts = JSON.parse(stdout).hosts;
+	const active = Object.entries(hosts).find(([, accounts]) => accounts.some((account) => account.active));
+	if (!active) throw new Error("gh has no active account. Run `gh auth login`.");
+	return active[0];
+}
+function apiBaseFor(host) {
+	return host === "github.com" ? "https://api.github.com" : `https://${host}/api/v3`;
+}
+var apiVersion = "2022-11-28";
+var GithubError = class extends Error {
+	path;
+	status;
+	body;
+	constructor(path, status, body) {
+		super(`GitHub responded ${status} for ${path}`);
+		this.name = "GithubError";
+		this.path = path;
+		this.status = status;
+		this.body = body;
+	}
+};
+async function githubRequest(path, options = {}) {
+	let response = await send(path, options);
+	if (response.status === 401) {
+		forgetAuth();
+		response = await send(path, options);
+	}
+	recordRateLimit(response);
+	if (response.status === 304) return {
+		status: 304,
+		notModified: true,
+		data: void 0,
+		...cacheHeaders(response)
+	};
+	if (!response.ok) throw new GithubError(path, response.status, await response.text());
+	return {
+		status: response.status,
+		notModified: false,
+		data: hasBody(response) ? await response.json() : void 0,
+		...cacheHeaders(response)
+	};
+}
+async function send(path, options) {
+	const auth = await getAuth();
+	const headers = {
+		accept: "application/vnd.github+json",
+		authorization: `Bearer ${auth.token}`,
+		"user-agent": "gitxp",
+		"x-github-api-version": apiVersion,
+		...options.headers
+	};
+	if (options.etag) headers["if-none-match"] = options.etag;
+	if (options.lastModified) headers["if-modified-since"] = options.lastModified;
+	if (options.body !== void 0) headers["content-type"] = "application/json";
+	return fetch(resolve$1(auth.apiBase, path), {
+		method: options.method ?? "GET",
+		headers,
+		body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
+	});
+}
+function resolve$1(apiBase, path) {
+	if (path.startsWith("https://")) return path;
+	return `${apiBase.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+}
+function hasBody(response) {
+	if (response.status === 204 || response.status === 205) return false;
+	return response.headers.get("content-length") !== "0";
+}
+function cacheHeaders(response) {
+	const pollInterval = response.headers.get("x-poll-interval");
+	return {
+		etag: response.headers.get("etag") ?? void 0,
+		lastModified: response.headers.get("last-modified") ?? void 0,
+		pollInterval: pollInterval === null ? void 0 : Number(pollInterval),
+		nextPage: nextPageFrom(response.headers.get("link"))
+	};
+}
+function nextPageFrom(link) {
+	if (link === null) return void 0;
+	return /<([^>]+)>;\s*rel="next"/.exec(link)?.[1];
+}
+function recordRateLimit(response) {
+	const limit = response.headers.get("x-ratelimit-limit");
+	if (limit === null) return;
+	Number(limit), Number(response.headers.get("x-ratelimit-remaining")), Number(response.headers.get("x-ratelimit-used")), Number(response.headers.get("x-ratelimit-reset")), response.headers.get("x-ratelimit-resource");
+}
+var resource = "notifications";
+var maxPages = 10;
+async function syncNotifications() {
+	const state = readSyncState(resource);
+	const since = newestUpdatedAt();
+	const url = pathFor(since);
+	const first = await githubRequest(url, { etag: state?.request_url === url ? state.etag : void 0 });
+	writeSyncState({
+		resource,
+		etag: first.etag,
+		lastModified: first.lastModified,
+		pollInterval: first.pollInterval,
+		status: first.status,
+		requestUrl: url
+	});
+	if (first.notModified) return {
+		notModified: true,
+		written: 0,
+		pages: 0,
+		truncated: false,
+		incremental: since !== null,
+		pollInterval: first.pollInterval ?? state?.poll_interval ?? void 0
+	};
+	let written = upsertNotifications(first.data ?? []).length;
+	let next = first.nextPage;
+	let pages = 1;
+	while (next !== void 0 && pages < maxPages) {
+		const page = await githubRequest(next);
+		written += upsertNotifications(page.data ?? []).length;
+		next = page.nextPage;
+		pages += 1;
+	}
+	if (written > 0) emitChange(resource);
+	return {
+		notModified: false,
+		written,
+		pages,
+		truncated: next !== void 0,
+		incremental: since !== null,
+		pollInterval: first.pollInterval
+	};
+}
+function pathFor(since) {
+	const params = new URLSearchParams({
+		all: "true",
+		per_page: "50"
+	});
+	if (since !== null) params.set("since", since);
+	return `/notifications?${params.toString()}`;
+}
+function enqueueMutation(kind, payload) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const result = getDb().prepare(`INSERT INTO mutation_queue (kind, payload, status, attempts, created_at, updated_at)
+       VALUES (?, ?, 'pending', 0, ?, ?)`).run(kind, JSON.stringify(payload), now, now);
+	return Number(result.lastInsertRowid);
+}
+function pendingMutations(limit = 50) {
+	return getDb().prepare(`SELECT * FROM mutation_queue WHERE status = 'pending' ORDER BY id LIMIT ?`).all(limit);
+}
+function failedMutations() {
+	return getDb().prepare(`SELECT * FROM mutation_queue WHERE status = 'failed' ORDER BY id`).all();
+}
+function completeMutation(id) {
+	getDb().prepare(`UPDATE mutation_queue SET status = 'done', updated_at = ? WHERE id = ?`).run((/* @__PURE__ */ new Date()).toISOString(), id);
+}
+function failMutation(id, message) {
+	getDb().prepare(`UPDATE mutation_queue
+       SET status = 'failed', attempts = attempts + 1, last_error = ?, updated_at = ?
+       WHERE id = ?`).run(message, (/* @__PURE__ */ new Date()).toISOString(), id);
+}
+function retryMutation(id) {
+	getDb().prepare(`UPDATE mutation_queue SET status = 'pending', last_error = NULL, updated_at = ?
+       WHERE id = ? AND status = 'failed'`).run((/* @__PURE__ */ new Date()).toISOString(), id);
+}
+var handlers = {
+	"notification.done": async ({ threadId }) => {
+		await githubRequest(`/notifications/threads/${threadId}`, { method: "DELETE" });
+	},
+	"notification.read": async ({ threadId }) => {
+		await githubRequest(`/notifications/threads/${threadId}`, { method: "PATCH" });
+	}
+};
+async function runMutation(kind, payload) {
+	const id = enqueueMutation(kind, payload);
+	try {
+		await handlers[kind](payload);
+		completeMutation(id);
+	} catch (error) {
+		failMutation(id, error instanceof Error ? error.message : String(error));
+		throw error;
+	}
+}
+async function drainPendingMutations() {
+	const rows = pendingMutations();
+	if (rows.length === 0) return 0;
+	let applied = 0;
+	for (const row of rows) if (await applyRow(row)) applied += 1;
+	if (applied > 0) emitChange("notifications");
+	return applied;
+}
+async function applyRow(row) {
+	try {
+		await handlers[row.kind](JSON.parse(row.payload));
+		completeMutation(row.id);
+		return true;
+	} catch (error) {
+		failMutation(row.id, error instanceof Error ? error.message : String(error));
+		return false;
+	}
+}
+var jobs = [{
+	resource: "notifications",
+	defaultInterval: 60,
+	run: syncNotifications
+}];
+var timers = /* @__PURE__ */ new Map();
+var failures = /* @__PURE__ */ new Map();
+var running = false;
+function startSync() {
+	if (running) return;
+	running = true;
+	drainPendingMutations().catch((error) => {
+		console.error("could not drain pending mutations", error);
+	});
+	for (const job of jobs) schedule(job, 0);
+}
+function schedule(job, delayMs) {
+	if (!running) return;
+	const timer = setTimeout(() => {
+		tick(job);
+	}, delayMs);
+	timer.unref();
+	timers.set(job.resource, timer);
+}
+async function tick(job) {
+	try {
+		const result = await job.run();
+		failures.delete(job.resource);
+		schedule(job, (result.pollInterval ?? job.defaultInterval) * 1e3);
+	} catch (error) {
+		const attempts = (failures.get(job.resource) ?? 0) + 1;
+		failures.set(job.resource, attempts);
+		console.error(`sync failed for ${job.resource} (attempt ${attempts})`, error);
+		schedule(job, backoff(attempts));
+	}
+}
+function backoff(attempts) {
+	return Math.min(2 ** attempts * 1e3, 3e5);
+}
+var getNotifications_createServerFn_handler = createServerRpc({
+	id: "5cfec4c6dee804d3573d611211f1ac5f56628842c036a21f55c9ae92c73dfff0",
+	name: "getNotifications",
+	filename: "src/functions/notifications.ts"
+}, (opts) => getNotifications.__executeServer(opts));
+var getNotifications = createServerFn({ method: "GET" }).handler(getNotifications_createServerFn_handler, async () => {
+	startSync();
+	return listNotifications();
+});
+var syncNow_createServerFn_handler = createServerRpc({
+	id: "0babd28c77cb1e09ec4d58a288fb1a4e4ea676ad4fb655c65b2949da4de21e51",
+	name: "syncNow",
+	filename: "src/functions/notifications.ts"
+}, (opts) => syncNow.__executeServer(opts));
+var syncNow = createServerFn({ method: "POST" }).handler(syncNow_createServerFn_handler, async () => {
+	return syncNotifications();
+});
+var getSyncStatus_createServerFn_handler = createServerRpc({
+	id: "c037beb8cda5c53572baa3bcea8e77650282ca11237e45b8703f106284575801",
+	name: "getSyncStatus",
+	filename: "src/functions/notifications.ts"
+}, (opts) => getSyncStatus.__executeServer(opts));
+var getSyncStatus = createServerFn({ method: "GET" }).handler(getSyncStatus_createServerFn_handler, async () => {
+	const state = readSyncState("notifications");
+	return {
+		hasSynced: state?.last_polled_at != null,
+		lastPolledAt: state?.last_polled_at ?? null,
+		lastStatus: state?.last_status ?? null
+	};
+});
+var markNotificationDone_createServerFn_handler = createServerRpc({
+	id: "9c3c7c75152987d0c0eb6e93398f5ac49bc91adf254a6cb7e7582da1ab9c7b69",
+	name: "markNotificationDone",
+	filename: "src/functions/notifications.ts"
+}, (opts) => markNotificationDone.__executeServer(opts));
+var markNotificationDone = createServerFn({ method: "POST" }).validator((threadId) => threadId).handler(markNotificationDone_createServerFn_handler, async ({ data }) => {
+	await runMutation("notification.done", { threadId: data });
+	deleteNotification(data);
+	emitChange("notifications");
+});
+var markNotificationRead_createServerFn_handler = createServerRpc({
+	id: "ec7cb03fde2349fdcee3000ccfc2f527248df2b7c89c3db9ad0c3ce452363f15",
+	name: "markNotificationRead",
+	filename: "src/functions/notifications.ts"
+}, (opts) => markNotificationRead.__executeServer(opts));
+var markNotificationRead = createServerFn({ method: "POST" }).validator((threadId) => threadId).handler(markNotificationRead_createServerFn_handler, async ({ data }) => {
+	await runMutation("notification.read", { threadId: data });
+	setNotificationRead(data);
+	emitChange("notifications");
+});
+var getFailedMutations_createServerFn_handler = createServerRpc({
+	id: "2360b4abbe0e8d19207ee28b76c335507d4577387d16ff7c5e69d2d1ccf2900b",
+	name: "getFailedMutations",
+	filename: "src/functions/notifications.ts"
+}, (opts) => getFailedMutations.__executeServer(opts));
+var getFailedMutations = createServerFn({ method: "GET" }).handler(getFailedMutations_createServerFn_handler, async () => {
+	return failedMutations().map((row) => ({
+		id: row.id,
+		kind: row.kind,
+		attempts: row.attempts,
+		lastError: row.last_error,
+		updatedAt: row.updated_at
+	}));
+});
+var retryFailedMutations_createServerFn_handler = createServerRpc({
+	id: "6e5e9052f4c44bc48d2cacaa624ebc266d94ad8c4f5211de50e7760446323376",
+	name: "retryFailedMutations",
+	filename: "src/functions/notifications.ts"
+}, (opts) => retryFailedMutations.__executeServer(opts));
+var retryFailedMutations = createServerFn({ method: "POST" }).handler(retryFailedMutations_createServerFn_handler, async () => {
+	for (const row of failedMutations()) retryMutation(row.id);
+	return drainPendingMutations();
+});
+//#endregion
+export { getFailedMutations_createServerFn_handler, getNotifications_createServerFn_handler, getSyncStatus_createServerFn_handler, markNotificationDone_createServerFn_handler, markNotificationRead_createServerFn_handler, retryFailedMutations_createServerFn_handler, syncNow_createServerFn_handler };

package/.output/server/_ssr/router-DsUHD4bT.mjs

@@ -0,0 +1,179 @@
+import { f as createRouter, h as createRootRouteWithContext, l as Scripts, m as createFileRoute, p as lazyRouteComponent, u as HeadContent } from "../_libs/@tanstack/react-router+[...].mjs";
+import { l as require_jsx_runtime } from "../_libs/@radix-ui/react-arrow+[...].mjs";
+import { n as TSS_SERVER_FUNCTION, r as getServerFnById, t as createServerFn } from "./ssr.mjs";
+import { n as onChange } from "./events-BNrmOvgU.mjs";
+import { t as QueryClient } from "../_libs/tanstack__query-core.mjs";
+import { t as setupRouterSsrQueryIntegration } from "../_libs/@tanstack/react-router-ssr-query+[...].mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/router-DsUHD4bT.js
+var import_jsx_runtime = require_jsx_runtime();
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var styles_default = "/assets/styles-D5xbQNYu.css";
+var Route$2 = createRootRouteWithContext()({
+	head: () => ({
+		meta: [
+			{ charSet: "utf-8" },
+			{
+				name: "viewport",
+				content: "width=device-width, initial-scale=1"
+			},
+			{ title: "gitxp" }
+		],
+		links: [{
+			rel: "stylesheet",
+			href: styles_default
+		}]
+	}),
+	shellComponent: RootDocument
+});
+function RootDocument({ children }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("html", {
+		lang: "en",
+		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("head", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(HeadContent, {}) }), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("body", { children: [children, /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Scripts, {})] })]
+	});
+}
+var createSsrRpc = (functionId) => {
+	const url = "/_serverFn/" + functionId;
+	const serverFnMeta = { id: functionId };
+	const fn = async (...args) => {
+		return (await getServerFnById(functionId, { origin: "server" }))(...args);
+	};
+	return Object.assign(fn, {
+		url,
+		serverFnMeta,
+		[TSS_SERVER_FUNCTION]: true
+	});
+};
+var getNotifications = createServerFn({ method: "GET" }).handler(createSsrRpc("5cfec4c6dee804d3573d611211f1ac5f56628842c036a21f55c9ae92c73dfff0"));
+var syncNow = createServerFn({ method: "POST" }).handler(createSsrRpc("0babd28c77cb1e09ec4d58a288fb1a4e4ea676ad4fb655c65b2949da4de21e51"));
+var getSyncStatus = createServerFn({ method: "GET" }).handler(createSsrRpc("c037beb8cda5c53572baa3bcea8e77650282ca11237e45b8703f106284575801"));
+var markNotificationDone = createServerFn({ method: "POST" }).validator((threadId) => threadId).handler(createSsrRpc("9c3c7c75152987d0c0eb6e93398f5ac49bc91adf254a6cb7e7582da1ab9c7b69"));
+var markNotificationRead = createServerFn({ method: "POST" }).validator((threadId) => threadId).handler(createSsrRpc("ec7cb03fde2349fdcee3000ccfc2f527248df2b7c89c3db9ad0c3ce452363f15"));
+var getFailedMutations = createServerFn({ method: "GET" }).handler(createSsrRpc("2360b4abbe0e8d19207ee28b76c335507d4577387d16ff7c5e69d2d1ccf2900b"));
+var retryFailedMutations = createServerFn({ method: "POST" }).handler(createSsrRpc("6e5e9052f4c44bc48d2cacaa624ebc266d94ad8c4f5211de50e7760446323376"));
+var viewIds = [
+	"inbox",
+	"review",
+	"mentions",
+	"yours",
+	"all"
+];
+var views = [
+	{
+		id: "inbox",
+		label: "Inbox",
+		match: (notification) => notification.unread === 1
+	},
+	{
+		id: "review",
+		label: "Review requests",
+		match: (notification) => notification.unread === 1 && notification.reason === "review_requested"
+	},
+	{
+		id: "mentions",
+		label: "Mentions",
+		match: (notification) => notification.unread === 1 && (notification.reason === "mention" || notification.reason === "assign")
+	},
+	{
+		id: "yours",
+		label: "Yours",
+		match: (notification) => notification.reason === "author"
+	},
+	{
+		id: "all",
+		label: "All",
+		match: () => true
+	}
+];
+function isViewId(value) {
+	return viewIds.includes(value);
+}
+function webUrlFor(notification) {
+	const repoUrl = `https://github.com/${notification.repo_full_name}`;
+	if (notification.subject_url === null) return repoUrl;
+	return notification.subject_url.startsWith("https://api.github.com/repos/") ? notification.subject_url.replace("https://api.github.com/repos/", "https://github.com/").replace("/pulls/", "/pull/") : repoUrl;
+}
+function reasonLabel(reason) {
+	return reason.replace(/_/g, " ");
+}
+var $$splitComponentImporter = () => import("./routes-DIFfr242.mjs");
+var Route$1 = createFileRoute("/")({
+	component: lazyRouteComponent($$splitComponentImporter, "component"),
+	loader: () => getNotifications(),
+	validateSearch: (search) => ({
+		view: isViewId(search.view) ? search.view : "inbox",
+		thread: typeof search.thread === "string" ? search.thread : void 0
+	})
+});
+var heartbeatMs = 3e4;
+var Route = createFileRoute("/api/events")({ server: { handlers: { GET: () => {
+	const encoder = new TextEncoder();
+	let unsubscribe;
+	let heartbeat;
+	const stream = new ReadableStream({
+		start(controller) {
+			const send = (chunk) => {
+				controller.enqueue(encoder.encode(chunk));
+			};
+			send(": connected\n\n");
+			unsubscribe = onChange((resource) => {
+				send(`event: change\ndata: ${JSON.stringify({ resource })}\n\n`);
+			});
+			heartbeat = setInterval(() => {
+				send(": ping\n\n");
+			}, heartbeatMs);
+			heartbeat.unref();
+		},
+		cancel() {
+			unsubscribe?.();
+			if (heartbeat) clearInterval(heartbeat);
+		}
+	});
+	return new Response(stream, { headers: {
+		"content-type": "text/event-stream",
+		"cache-control": "no-cache",
+		connection: "keep-alive"
+	} });
+} } } });
+var rootRouteChildren = {
+	IndexRoute: Route$1.update({
+		id: "/",
+		path: "/",
+		getParentRoute: () => Route$2
+	}),
+	ApiEventsRoute: Route.update({
+		id: "/api/events",
+		path: "/api/events",
+		getParentRoute: () => Route$2
+	})
+};
+var routeTree = Route$2._addFileChildren(rootRouteChildren)._addFileTypes();
+function getContext() {
+	return { queryClient: new QueryClient() };
+}
+var router_exports = /* @__PURE__ */ __exportAll({ getRouter: () => getRouter });
+function getRouter() {
+	const context = getContext();
+	const router = createRouter({
+		routeTree,
+		context,
+		scrollRestoration: true,
+		defaultPreload: "intent",
+		defaultPreloadStaleTime: 0
+	});
+	setupRouterSsrQueryIntegration({
+		router,
+		queryClient: context.queryClient
+	});
+	return router;
+}
+//#endregion
+export { webUrlFor as a, getSyncStatus as c, retryFailedMutations as d, syncNow as f, views as i, markNotificationDone as l, Route$1 as n, getFailedMutations as o, reasonLabel as r, getNotifications as s, router_exports as t, markNotificationRead as u };