@sanurb/ringi 0.2.1 → 0.3.1

package/server/server/_ssr/api-handler-CstW2n82.mjs

@@ -0,0 +1,189 @@
+import { C as consolePretty, Mt as makeMemoMap, Nt as mergeAll, Pt as provide, bt as runSync, d as layer, dt as gen, n as layerHttp, o as layerNdjson, ot as catchTags, st as die, u as group, v as toWebHandler, w as layer$1, y as layerServices } from "../_libs/effect+[...].mjs";
+import { a as GitService, i as ExportService, l as getDiffSummary, n as CoreLive, o as ReviewService, r as EventService, s as TodoService, t as CommentService, u as parseDiff } from "./runtime-D9IbnMlF.mjs";
+import { n as DomainRpc, r as ReviewsRpc, t as DomainApi } from "./domain-rpc-3Ds9DPr0.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/api-handler-CstW2n82.js
+var CommentsApiLive = group(DomainApi, "comments", (handlers) => handlers.handle("getByReview", (_) => gen(function* CommentsApiLive() {
+	const svc = yield* CommentService;
+	const { filePath } = _.query;
+	if (filePath) return yield* svc.getByFile(_.params.reviewId, filePath);
+	return yield* svc.getByReview(_.params.reviewId);
+})).handle("getById", (_) => gen(function* CommentsApiLive() {
+	return yield* (yield* CommentService).getById(_.params.id);
+})).handle("create", (_) => gen(function* CommentsApiLive() {
+	return yield* (yield* CommentService).create(_.params.reviewId, _.payload);
+})).handle("update", (_) => gen(function* CommentsApiLive() {
+	return yield* (yield* CommentService).update(_.params.id, _.payload);
+})).handle("resolve", (_) => gen(function* CommentsApiLive() {
+	return yield* (yield* CommentService).resolve(_.params.id);
+})).handle("unresolve", (_) => gen(function* CommentsApiLive() {
+	return yield* (yield* CommentService).unresolve(_.params.id);
+})).handle("remove", (_) => gen(function* CommentsApiLive() {
+	return yield* (yield* CommentService).remove(_.params.id);
+})).handle("stats", (_) => gen(function* CommentsApiLive() {
+	return yield* (yield* CommentService).getStats(_.params.reviewId);
+})));
+var loadScopedDiff = (scope) => gen(function* loadScopedDiffEffect() {
+	const git = yield* GitService;
+	let diffText = "";
+	switch (scope) {
+		case "uncommitted":
+			diffText = yield* git.getUncommittedDiff;
+			break;
+		case "unstaged":
+			diffText = yield* git.getUnstagedDiff;
+			break;
+		case "last-commit":
+			diffText = yield* git.getLastCommitDiff;
+			break;
+		default:
+			diffText = yield* git.getStagedDiff;
+			break;
+	}
+	const files = parseDiff(diffText);
+	const summary = getDiffSummary(files);
+	return {
+		files,
+		repository: yield* git.getRepositoryInfo,
+		summary
+	};
+});
+var DiffApiLive = group(DomainApi, "diff", (handlers) => handlers.handle("staged", (_) => loadScopedDiff("staged").pipe(catchTags({ GitError: (error) => die(error) }))).handle("unstaged", (_) => loadScopedDiff("unstaged").pipe(catchTags({ GitError: (error) => die(error) }))).handle("scoped", (_) => loadScopedDiff(_.query.scope).pipe(catchTags({ GitError: (error) => die(error) }))).handle("files", (_) => gen(function* loadDiffFiles() {
+	const stagedFiles = yield* (yield* GitService).getStagedFiles;
+	return {
+		files: stagedFiles,
+		hasStagedChanges: stagedFiles.length > 0
+	};
+}).pipe(catchTags({ GitError: (error) => die(error) }))));
+var ReviewFilesApiLive = group(DomainApi, "reviewFiles", (handlers) => handlers.handle("hunks", (_) => gen(function* loadReviewFileHunks() {
+	return { hunks: yield* (yield* ReviewService).getFileHunks(_.params.reviewId, _.query.path) };
+}).pipe(catchTags({ GitError: (error) => die(error) }))));
+var EventsApiLive = group(DomainApi, "events", (handlers) => handlers.handle("notify", (_) => gen(function* EventsApiLive() {
+	yield* (yield* EventService).broadcast(_.payload.type, { action: _.payload.action });
+	return { success: true };
+})).handle("clients", (_) => gen(function* EventsApiLive() {
+	return { count: yield* (yield* EventService).getClientCount() };
+})));
+var ExportApiLive = group(DomainApi, "export", (handlers) => handlers.handle("markdown", (_) => gen(function* ExportApiLive() {
+	return yield* (yield* ExportService).exportReview(_.params.id);
+})));
+var GitApiLive = group(DomainApi, "git", (handlers) => handlers.handle("info", (_) => gen(function* GitApiLive() {
+	return yield* (yield* GitService).getRepositoryInfo;
+}).pipe(catchTags({ GitError: (e) => die(e) }))).handle("branches", (_) => gen(function* GitApiLive() {
+	return yield* (yield* GitService).getBranches;
+}).pipe(catchTags({ GitError: (e) => die(e) }))).handle("commits", (_) => gen(function* GitApiLive() {
+	return yield* (yield* GitService).getCommits({});
+}).pipe(catchTags({ GitError: (e) => die(e) }))).handle("staged", (_) => gen(function* GitApiLive() {
+	return { hasStagedChanges: (yield* (yield* GitService).getStagedFiles).length > 0 };
+}).pipe(catchTags({ GitError: (e) => die(e) }))).handle("stage", (_) => gen(function* GitApiLive() {
+	return {
+		staged: [...yield* (yield* GitService).stageFiles(_.payload.files)],
+		success: true
+	};
+}).pipe(catchTags({ GitError: (e) => die(e) }))).handle("stageAll", (_) => gen(function* GitApiLive() {
+	return {
+		staged: [...yield* (yield* GitService).stageAll],
+		success: true
+	};
+}).pipe(catchTags({ GitError: (e) => die(e) }))).handle("unstage", (_) => gen(function* GitApiLive() {
+	return {
+		success: true,
+		unstaged: [...yield* (yield* GitService).unstageFiles(_.payload.files)]
+	};
+}).pipe(catchTags({ GitError: (e) => die(e) }))));
+/**
+* Wires HttpApiBuilder handlers for the ReviewsApiGroup.
+*/
+var ReviewsApiLive = group(DomainApi, "reviews", (handlers) => handlers.handle("list", () => gen(function* () {
+	return yield* (yield* ReviewService).list({});
+})).handle("getById", (_) => gen(function* () {
+	return yield* (yield* ReviewService).getById(_.params.id);
+})).handle("create", (_) => gen(function* () {
+	return yield* (yield* ReviewService).create(_.payload);
+}).pipe(catchTags({
+	GitError: (e) => die(e),
+	ReviewError: (e) => die(e)
+}))).handle("update", (_) => gen(function* () {
+	return yield* (yield* ReviewService).update(_.params.id, _.payload);
+})).handle("remove", (_) => gen(function* () {
+	return yield* (yield* ReviewService).remove(_.params.id);
+})).handle("stats", () => gen(function* () {
+	return yield* (yield* ReviewService).getStats();
+})));
+/**
+* Wires RPC handlers for ReviewsRpc.
+*
+* ReviewService leaks ReviewRepo, ReviewFileRepo, and GitService as runtime
+* requirements. Those must be provided by the caller.
+*/
+var ReviewsRpcLive = ReviewsRpc.toLayer({
+	reviews_create: (_) => gen(function* reviews_create() {
+		return yield* (yield* ReviewService).create(_.input);
+	}).pipe(catchTags({
+		GitError: (e) => die(e),
+		ReviewError: (e) => die(e)
+	})),
+	reviews_getById: (_) => gen(function* reviews_getById() {
+		return yield* (yield* ReviewService).getById(_.id);
+	}),
+	reviews_list: (_) => gen(function* reviews_list() {
+		return yield* (yield* ReviewService).list({
+			page: _.page,
+			pageSize: _.pageSize,
+			status: _.status
+		});
+	}),
+	reviews_remove: (_) => gen(function* reviews_remove() {
+		return yield* (yield* ReviewService).remove(_.id);
+	}),
+	reviews_stats: (_) => gen(function* reviews_stats() {
+		return yield* (yield* ReviewService).getStats();
+	}),
+	reviews_update: (_) => gen(function* reviews_update() {
+		return yield* (yield* ReviewService).update(_.id, _.input);
+	})
+});
+var TodosApiLive = group(DomainApi, "todos", (handlers) => handlers.handle("list", (_) => gen(function* TodosApiLive() {
+	return yield* (yield* TodoService).list({});
+})).handle("getById", (_) => gen(function* TodosApiLive() {
+	return yield* (yield* TodoService).getById(_.params.id);
+})).handle("create", (_) => gen(function* TodosApiLive() {
+	return yield* (yield* TodoService).create(_.payload);
+})).handle("update", (_) => gen(function* TodosApiLive() {
+	return yield* (yield* TodoService).update(_.params.id, _.payload);
+})).handle("toggle", (_) => gen(function* TodosApiLive() {
+	return yield* (yield* TodoService).toggle(_.params.id);
+})).handle("remove", (_) => gen(function* TodosApiLive() {
+	return yield* (yield* TodoService).remove(_.params.id);
+})).handle("removeCompleted", (_) => gen(function* TodosApiLive() {
+	return yield* (yield* TodoService).removeCompleted();
+})).handle("reorder", (_) => gen(function* TodosApiLive() {
+	return yield* (yield* TodoService).reorder(_.payload.orderedIds);
+})).handle("move", (_) => gen(function* TodosApiLive() {
+	return yield* (yield* TodoService).move(_.params.id, _.payload.position);
+})).handle("stats", (_) => gen(function* TodosApiLive() {
+	return yield* (yield* TodoService).getStats();
+})));
+var ServiceLayers = CoreLive;
+var AllRoutes = mergeAll(layerHttp({
+	group: DomainRpc,
+	path: "/api/rpc",
+	spanPrefix: "rpc"
+}).pipe(provide(ReviewsRpcLive), provide(layerNdjson)), layer(DomainApi).pipe(provide(ReviewsApiLive), provide(CommentsApiLive), provide(TodosApiLive), provide(DiffApiLive), provide(ReviewFilesApiLive), provide(GitApiLive), provide(EventsApiLive), provide(ExportApiLive), provide(layerServices))).pipe(provide(ServiceLayers), provide(layer$1([consolePretty()])));
+/**
+* Initialize the Effect HTTP + RPC handler.
+* Called lazily on first API request to avoid blocking SSR module evaluation.
+*/
+var initApiHandler = async () => {
+	const { handler, dispose: disposeHandler } = toWebHandler(AllRoutes, { memoMap: runSync(makeMemoMap) });
+	const { serverRuntime } = await import("./server-runtime-D99qpmma.mjs");
+	const dispose = async () => {
+		await disposeHandler();
+		await serverRuntime.dispose();
+	};
+	return {
+		handler,
+		dispose
+	};
+};
+//#endregion
+export { initApiHandler };

package/server/server/_ssr/client-runtime-BoPuAEoA.mjs

@@ -0,0 +1,245 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { u as require_react } from "../_libs/@floating-ui/react-dom+[...].mjs";
+import { n as require_jsx_runtime } from "../_libs/@pierre/diffs+[...].mjs";
+import { At as exponential, O as isStream, Pt as provide, Rt as Service, S as make$2, a as make, b as filterStatusOk, dt as gen, ft as isEffect, i as layerProtocolHttp, jt as effect, k as tapCause$1, l as make$1, o as layerNdjson, pt as logError, t as layer, wt as tapCause, x as retryTransient } from "../_libs/effect+[...].mjs";
+import { n as DomainRpc, t as DomainApi } from "./domain-rpc-3Ds9DPr0.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/client-runtime-BoPuAEoA.js
+var import_react = /* @__PURE__ */ __toESM(require_react());
+var import_jsx_runtime = require_jsx_runtime();
+/** Ordered list: default first. IDs must match `data-ringi-palette` in `ringi-palettes.css`. */
+var RINGI_PALETTES = [
+	{
+		description: "Ringi default — cool neutral surfaces, blue accent.",
+		id: "ringi",
+		label: "Ringi",
+		swatches: [
+			"#0d0d0d",
+			"#3d6ad6",
+			"#3fb950",
+			"#f85149"
+		]
+	},
+	{
+		description: "Classic Dracula-inspired contrast with green accent.",
+		id: "dracula",
+		label: "Dracula",
+		swatches: [
+			"#282a36",
+			"#50fa7b",
+			"#8be9fd",
+			"#ff5555"
+		]
+	},
+	{
+		description: "Tokyo Night — deep blue-violet editor tones.",
+		id: "tokyo-night",
+		label: "Tokyo Night",
+		swatches: [
+			"#1a1b26",
+			"#7aa2f7",
+			"#9ece6a",
+			"#f7768e"
+		]
+	},
+	{
+		description: "Catppuccin Mocha — soft pastel accents on dark base.",
+		id: "catppuccin",
+		label: "Catppuccin",
+		swatches: [
+			"#1e1e2e",
+			"#89dceb",
+			"#a6e3a1",
+			"#f38ba8"
+		]
+	},
+	{
+		description: "Gruvbox — warm paper-like dark UI.",
+		id: "gruvbox",
+		label: "Gruvbox",
+		swatches: [
+			"#282828",
+			"#d79921",
+			"#b8bb26",
+			"#fb4934"
+		]
+	},
+	{
+		description: "Rosé Pine — muted mauve and sage atmosphere.",
+		id: "rose-pine",
+		label: "Rosé Pine",
+		swatches: [
+			"#191724",
+			"#ebbcba",
+			"#9ccfd8",
+			"#eb6f92"
+		]
+	},
+	{
+		description: "Monokai-inspired greens and magentas.",
+		id: "monokai",
+		label: "Monokai",
+		swatches: [
+			"#272822",
+			"#a6e22e",
+			"#66d9ef",
+			"#f92672"
+		]
+	},
+	{
+		description: "Synthwave hints — coral accent on midnight plum.",
+		id: "synthwave",
+		label: "Synthwave",
+		swatches: [
+			"#1a1625",
+			"#f97e72",
+			"#34d3c6",
+			"#b794f6"
+		]
+	}
+];
+var RINGI_PREFERENCES_STORAGE_KEY = "ringi.preferences.v1";
+var DEFAULT_RINGI_PREFERENCES = {
+	appearance: "system",
+	palette: "ringi"
+};
+var PALETTE_IDS = new Set(RINGI_PALETTES.map((p) => p.id));
+var isAppearanceMode = (v) => v === "dark" || v === "light" || v === "system";
+var isPaletteId = (v) => typeof v === "string" && PALETTE_IDS.has(v);
+var parseRingiPreferences = (raw) => {
+	if (!raw) return DEFAULT_RINGI_PREFERENCES;
+	try {
+		const data = JSON.parse(raw);
+		const { appearance } = data;
+		const { palette } = data;
+		return {
+			appearance: isAppearanceMode(appearance) ? appearance : DEFAULT_RINGI_PREFERENCES.appearance,
+			palette: isPaletteId(palette) ? palette : DEFAULT_RINGI_PREFERENCES.palette
+		};
+	} catch {
+		return DEFAULT_RINGI_PREFERENCES;
+	}
+};
+var readRingiPreferencesFromStorage = () => {
+	if (typeof window === "undefined") return DEFAULT_RINGI_PREFERENCES;
+	return parseRingiPreferences(localStorage.getItem(RINGI_PREFERENCES_STORAGE_KEY));
+};
+var writeRingiPreferencesToStorage = (prefs) => {
+	if (typeof window === "undefined") return;
+	localStorage.setItem(RINGI_PREFERENCES_STORAGE_KEY, JSON.stringify(prefs));
+};
+/** Inline script for <head>: applies class + palette before paint (must stay in sync with read logic). */
+var getRingiThemeBootScript = () => {
+	return `(function(){try{var k=${JSON.stringify(RINGI_PREFERENCES_STORAGE_KEY)};var ok=${`{${RINGI_PALETTES.map((x) => `${JSON.stringify(x.id)}:1`).join(",")}}`};var d=JSON.parse(localStorage.getItem(k)||'null');var a=d&&d.appearance;var p=d&&d.palette;var appearance=a==='dark'||a==='light'||a==='system'?a:'system';var pal=ok[p]?p:'ringi';var dark=appearance==='dark'||(appearance==='system'&&window.matchMedia('(prefers-color-scheme: dark)').matches);document.documentElement.classList.toggle('dark',dark);document.documentElement.dataset.ringiPalette=pal;}catch(e){document.documentElement.classList.add('dark');document.documentElement.dataset.ringiPalette='ringi';}})();`;
+};
+var resolveDarkAppearance = (appearance) => {
+	if (appearance === "dark") return true;
+	if (appearance === "light") return false;
+	if (typeof window === "undefined") return true;
+	return window.matchMedia("(prefers-color-scheme: dark)").matches;
+};
+var applyRingiThemeToDocument = (doc, appearance, palette) => {
+	const root = doc.documentElement;
+	root.classList.toggle("dark", resolveDarkAppearance(appearance));
+	root.dataset.ringiPalette = palette;
+};
+var RingiThemeContext = (0, import_react.createContext)(null);
+var useRingiTheme = () => {
+	const ctx = (0, import_react.use)(RingiThemeContext);
+	if (!ctx) throw new Error("useRingiTheme must be used within RingiThemeProvider");
+	return ctx;
+};
+var RingiThemeProvider = ({ children }) => {
+	const [appearance, setAppearanceState] = (0, import_react.useState)(() => readRingiPreferencesFromStorage().appearance);
+	const [palette, setPaletteState] = (0, import_react.useState)(() => readRingiPreferencesFromStorage().palette);
+	const applyDom = (0, import_react.useEffectEvent)(() => {
+		applyRingiThemeToDocument(document, appearance, palette);
+	});
+	(0, import_react.useEffect)(() => {
+		applyDom();
+	}, [appearance, palette]);
+	(0, import_react.useEffect)(() => {
+		if (appearance !== "system") return;
+		const mql = window.matchMedia("(prefers-color-scheme: dark)");
+		const onChange = () => {
+			applyDom();
+		};
+		mql.addEventListener("change", onChange);
+		return () => mql.removeEventListener("change", onChange);
+	}, [appearance]);
+	(0, import_react.useEffect)(() => {
+		writeRingiPreferencesToStorage({
+			appearance,
+			palette
+		});
+	}, [appearance, palette]);
+	const value = (0, import_react.useMemo)(() => ({
+		appearance,
+		palette,
+		setAppearance: (mode) => {
+			(0, import_react.startTransition)(() => setAppearanceState(mode));
+		},
+		setPalette: (id) => {
+			(0, import_react.startTransition)(() => setPaletteState(id));
+		},
+		setPreferences: (next) => {
+			(0, import_react.startTransition)(() => {
+				setAppearanceState(next.appearance);
+				setPaletteState(next.palette);
+			});
+		}
+	}), [appearance, palette]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RingiThemeContext.Provider, {
+		value,
+		children
+	});
+};
+var addRpcErrorLogging = (client) => {
+	const wrapCall = (fn, path) => {
+		const rpcId = path.join(".");
+		const logCause = (cause) => logError(`[API] ${rpcId} failed`, cause);
+		return function wrappedCall(...args) {
+			const result = fn.apply(this, args);
+			if (isEffect(result)) return result.pipe(tapCause(logCause));
+			if (isStream(result)) return result.pipe(tapCause$1(logCause));
+			return result;
+		};
+	};
+	const visit = (node, path) => {
+		if (node && typeof node === "object") for (const [key, value] of Object.entries(node)) {
+			const nextPath = [...path, key];
+			if (typeof value === "function") {
+				node[key] = wrapCall(value, nextPath);
+				continue;
+			}
+			visit(value, nextPath);
+		}
+		return node;
+	};
+	return visit(client, []);
+};
+var getBaseUrl = () => typeof window === "undefined" ? "http://localhost:3000" : window.location.origin;
+var RpcConfigLive = layerProtocolHttp({ url: `${getBaseUrl()}/api/rpc` }).pipe(provide([layer, layerNdjson]));
+var ApiClient = class ApiClient extends Service()("ApiClient") {
+	static Default = effect(ApiClient, gen(function* () {
+		const rpcClient = yield* make(DomainRpc);
+		const httpClient = yield* make$1(DomainApi, {
+			baseUrl: getBaseUrl(),
+			transformClient: (client) => client.pipe(filterStatusOk, retryTransient({
+				schedule: exponential("1 second"),
+				times: 3
+			}))
+		});
+		return ApiClient.of({
+			http: httpClient,
+			rpc: addRpcErrorLogging(rpcClient)
+		});
+	})).pipe(provide(RpcConfigLive), provide(layer));
+};
+var runtime = make$2(ApiClient.Default);
+var clientRuntime = {
+	...runtime,
+	runFork: runtime.runFork,
+	runPromise: runtime.runPromise
+};
+//#endregion
+export { getRingiThemeBootScript as a, clientRuntime as i, RINGI_PALETTES as n, useRingiTheme as o, RingiThemeProvider as r, ApiClient as t };

package/server/server/_ssr/createServerRpc--0mcGlWK.mjs

@@ -0,0 +1,12 @@
+import { t as TSS_SERVER_FUNCTION } from "./ssr.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/createServerRpc--0mcGlWK.js
+var createServerRpc = (serverFnMeta, splitImportFn) => {
+	const url = "/_serverFn/" + serverFnMeta.id;
+	return Object.assign(splitImportFn, {
+		url,
+		serverFnMeta,
+		[TSS_SERVER_FUNCTION]: true
+	});
+};
+//#endregion
+export { createServerRpc as t };

package/server/server/_ssr/createSsrRpc-AwdiLXmF.mjs

@@ -0,0 +1,16 @@
+import { i as getServerFnById, t as TSS_SERVER_FUNCTION } from "./ssr.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/createSsrRpc-AwdiLXmF.js
+var createSsrRpc = (functionId, importer) => {
+	const url = "/_serverFn/" + functionId;
+	const serverFnMeta = { id: functionId };
+	const fn = async (...args) => {
+		return (importer ? await importer() : await getServerFnById(functionId))(...args);
+	};
+	return Object.assign(fn, {
+		url,
+		serverFnMeta,
+		[TSS_SERVER_FUNCTION]: true
+	});
+};
+//#endregion
+export { createSsrRpc as t };