birdclaw 0.8.2 → 0.8.4

package/src/lib/sqlite.ts

@@ -1,147 +0,0 @@
-import { DatabaseSync, type StatementSync } from "node:sqlite";
-
-export type Database = NativeSqliteDatabase;
-
-type DatabaseOptions = {
-	readonly?: boolean;
-	fileMustExist?: boolean;
-	timeout?: number;
-};
-
-type PragmaOptions = {
-	simple?: boolean;
-};
-
-type RunResult = {
-	changes: number;
-	lastInsertRowid: number;
-};
-
-export const SQLITE_BUSY_TIMEOUT_MS = 30_000;
-
-function bindArgs(parameters: unknown[]) {
-	if (parameters.length === 1 && Array.isArray(parameters[0])) {
-		return parameters[0];
-	}
-	return parameters;
-}
-
-function normalizeValue(value: unknown): unknown {
-	if (value instanceof Uint8Array && !Buffer.isBuffer(value)) {
-		return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
-	}
-	return value;
-}
-
-function normalizeRow(row: unknown): unknown {
-	if (
-		!row ||
-		typeof row !== "object" ||
-		Array.isArray(row) ||
-		Buffer.isBuffer(row)
-	) {
-		return normalizeValue(row);
-	}
-	return Object.fromEntries(
-		Object.entries(row as Record<string, unknown>).map(([key, value]) => [
-			key,
-			normalizeValue(value),
-		]),
-	);
-}
-
-class NativeSqliteStatement {
-	readonly reader: boolean;
-
-	constructor(private readonly statement: StatementSync) {
-		this.reader = statement.columns().length > 0;
-	}
-
-	all(...parameters: unknown[]): unknown[] {
-		return this.statement.all(...bindArgs(parameters)).map(normalizeRow);
-	}
-
-	get(...parameters: unknown[]): unknown {
-		return normalizeRow(this.statement.get(...bindArgs(parameters)));
-	}
-
-	run(...parameters: unknown[]): RunResult {
-		const result = this.statement.run(...bindArgs(parameters));
-		return {
-			changes: Number(result.changes),
-			lastInsertRowid: Number(result.lastInsertRowid),
-		};
-	}
-
-	iterate(...parameters: unknown[]): IterableIterator<unknown> {
-		const rows = this.statement.iterate(...bindArgs(parameters));
-		return (function* () {
-			for (const row of rows) {
-				yield normalizeRow(row);
-			}
-		})();
-	}
-}
-
-export class NativeSqliteDatabase {
-	private transactionDepth = 0;
-	private readonly db: DatabaseSync;
-
-	constructor(path: string, options: DatabaseOptions = {}) {
-		this.db = new DatabaseSync(path, {
-			readOnly: options.readonly,
-			timeout: options.timeout ?? SQLITE_BUSY_TIMEOUT_MS,
-		});
-	}
-
-	close(): void {
-		if (!this.db.isOpen) {
-			return;
-		}
-		this.db.close();
-	}
-
-	exec(sql: string): void {
-		this.db.exec(sql);
-	}
-
-	pragma(sql: string, options: PragmaOptions = {}): unknown {
-		const rows = this.prepare(`pragma ${sql}`).all() as Array<
-			Record<string, unknown>
-		>;
-		if (!options.simple) {
-			return rows;
-		}
-		const first = rows[0];
-		return first ? Object.values(first)[0] : undefined;
-	}
-
-	prepare(sql: string): NativeSqliteStatement {
-		return new NativeSqliteStatement(this.db.prepare(sql));
-	}
-
-	transaction<TArgs extends unknown[], TResult>(
-		fn: (...args: TArgs) => TResult,
-	): (...args: TArgs) => TResult {
-		return (...args: TArgs) => {
-			const nested = this.db.isTransaction;
-			const savepoint = `__birdclaw_tx_${++this.transactionDepth}`;
-			this.exec(nested ? `savepoint ${savepoint}` : "begin immediate");
-			try {
-				const result = fn(...args);
-				this.exec(nested ? `release ${savepoint}` : "commit");
-				return result;
-			} catch (error) {
-				if (nested) {
-					this.exec(`rollback to ${savepoint}`);
-					this.exec(`release ${savepoint}`);
-				} else {
-					this.exec("rollback");
-				}
-				throw error;
-			}
-		};
-	}
-}
-
-export default NativeSqliteDatabase;

package/src/lib/sync-cache.ts

@@ -1,65 +0,0 @@
-import { getNativeDb } from "./db";
-
-export interface SyncCacheEntry<T> {
-	value: T;
-	updatedAt: string;
-}
-
-function readSyncCacheRow(cacheKey: string, db = getNativeDb()) {
-	return db
-		.prepare(
-			`
-      select value_json, updated_at
-      from sync_cache
-      where cache_key = ?
-      `,
-		)
-		.get(cacheKey) as
-		| {
-				value_json: string;
-				updated_at: string;
-		  }
-		| undefined;
-}
-
-export function readSyncCache<T>(
-	cacheKey: string,
-	db = getNativeDb(),
-): SyncCacheEntry<T> | null {
-	const row = readSyncCacheRow(cacheKey, db);
-	if (!row) {
-		return null;
-	}
-
-	try {
-		return {
-			value: JSON.parse(row.value_json) as T,
-			updatedAt: row.updated_at,
-		};
-	} catch {
-		return null;
-	}
-}
-
-export function writeSyncCache(
-	cacheKey: string,
-	value: unknown,
-	db = getNativeDb(),
-) {
-	const updatedAt = new Date().toISOString();
-	db.prepare(
-		`
-    insert into sync_cache (cache_key, value_json, updated_at)
-    values (?, ?, ?)
-    on conflict(cache_key) do update set
-      value_json = excluded.value_json,
-      updated_at = excluded.updated_at
-    `,
-	).run(cacheKey, JSON.stringify(value), updatedAt);
-
-	return updatedAt;
-}
-
-export function deleteSyncCache(cacheKey: string, db = getNativeDb()) {
-	db.prepare("delete from sync_cache where cache_key = ?").run(cacheKey);
-}

package/src/lib/theme-transition.ts

@@ -1,113 +0,0 @@
-import { flushSync } from "react-dom";
-import type { ThemeValue } from "./theme";
-
-export interface ThemeTransitionContext {
-	element?: HTMLElement | null;
-	pointerClientX?: number;
-	pointerClientY?: number;
-}
-
-const clamp01 = (value: number) => {
-	if (Number.isNaN(value)) return 0.5;
-	if (value <= 0) return 0;
-	if (value >= 1) return 1;
-	return value;
-};
-
-const hasReducedMotionPreference = () => {
-	if (
-		typeof window === "undefined" ||
-		typeof window.matchMedia !== "function"
-	) {
-		return false;
-	}
-
-	return window.matchMedia("(prefers-reduced-motion: reduce)").matches ?? false;
-};
-
-const cleanupThemeTransition = (root: HTMLElement) => {
-	root.classList.remove("theme-transition");
-	root.style.removeProperty("--theme-switch-x");
-	root.style.removeProperty("--theme-switch-y");
-};
-
-export function startThemeTransition({
-	nextTheme,
-	currentTheme,
-	setTheme,
-	context,
-}: {
-	nextTheme: ThemeValue;
-	currentTheme: ThemeValue | null;
-	setTheme: (theme: ThemeValue) => void;
-	context?: ThemeTransitionContext;
-}) {
-	if (currentTheme === nextTheme) {
-		return;
-	}
-
-	if (typeof document === "undefined") {
-		setTheme(nextTheme);
-		return;
-	}
-
-	const root = document.documentElement;
-	const startViewTransition =
-		typeof document.startViewTransition === "function"
-			? document.startViewTransition.bind(document)
-			: undefined;
-	const canUseViewTransition =
-		Boolean(startViewTransition) && !hasReducedMotionPreference();
-
-	const applyTheme = () => {
-		flushSync(() => {
-			setTheme(nextTheme);
-		});
-	};
-
-	if (!canUseViewTransition) {
-		applyTheme();
-		cleanupThemeTransition(root);
-		return;
-	}
-
-	let xPercent = 0.5;
-	let yPercent = 0.5;
-
-	if (
-		context?.pointerClientX !== undefined &&
-		context.pointerClientY !== undefined &&
-		typeof window !== "undefined"
-	) {
-		xPercent = clamp01(context.pointerClientX / window.innerWidth);
-		yPercent = clamp01(context.pointerClientY / window.innerHeight);
-	} else if (context?.element && typeof window !== "undefined") {
-		const rect = context.element.getBoundingClientRect();
-		if (rect.width > 0 && rect.height > 0) {
-			xPercent = clamp01((rect.left + rect.width / 2) / window.innerWidth);
-			yPercent = clamp01((rect.top + rect.height / 2) / window.innerHeight);
-		}
-	}
-
-	root.style.setProperty("--theme-switch-x", `${xPercent * 100}%`);
-	root.style.setProperty("--theme-switch-y", `${yPercent * 100}%`);
-	root.classList.add("theme-transition");
-
-	try {
-		const transition = startViewTransition?.(() => {
-			applyTheme();
-		});
-
-		if (!transition?.finished) {
-			cleanupThemeTransition(root);
-			return;
-		}
-
-		void transition.finished
-			.catch(() => undefined)
-			.finally(() => cleanupThemeTransition(root));
-	} catch {
-		cleanupThemeTransition(root);
-		applyTheme();
-	}
-}

package/src/lib/theme.tsx

@@ -1,165 +0,0 @@
-import {
-	createContext,
-	type ReactNode,
-	useContext,
-	useEffect,
-	useMemo,
-	useState,
-} from "react";
-
-export type ThemeValue = "system" | "light" | "dark";
-export type ResolvedTheme = "light" | "dark";
-
-const THEME_STORAGE_KEY = "birdclaw-theme";
-
-interface ThemeContextValue {
-	isReady: boolean;
-	theme: ThemeValue;
-	resolvedTheme: ResolvedTheme;
-	setTheme: (theme: ThemeValue) => void;
-}
-
-const ThemeContext = createContext<ThemeContextValue | null>(null);
-
-function getSystemTheme(): ResolvedTheme {
-	if (
-		typeof window === "undefined" ||
-		typeof window.matchMedia !== "function"
-	) {
-		return "light";
-	}
-	return window.matchMedia("(prefers-color-scheme: dark)").matches
-		? "dark"
-		: "light";
-}
-
-function resolveTheme(theme: ThemeValue): ResolvedTheme {
-	return theme === "system" ? getSystemTheme() : theme;
-}
-
-function applyThemeToDocument(theme: ThemeValue) {
-	if (typeof document === "undefined") return;
-
-	const resolvedTheme = resolveTheme(theme);
-	document.documentElement.dataset.themePreference = theme;
-	document.documentElement.dataset.theme = resolvedTheme;
-	document.documentElement.style.colorScheme = resolvedTheme;
-}
-
-function readInitialTheme(): ThemeValue {
-	if (typeof document !== "undefined") {
-		const value = document.documentElement.dataset.themePreference;
-		if (value === "light" || value === "dark" || value === "system") {
-			return value;
-		}
-	}
-
-	if (typeof window !== "undefined") {
-		const stored = window.localStorage.getItem(THEME_STORAGE_KEY);
-		if (stored === "light" || stored === "dark" || stored === "system") {
-			return stored;
-		}
-	}
-
-	return "system";
-}
-
-export const themeScript = `
-(() => {
-  const storageKey = "${THEME_STORAGE_KEY}";
-  const root = document.documentElement;
-  const stored = window.localStorage.getItem(storageKey);
-  const preference =
-    stored === "light" || stored === "dark" || stored === "system"
-      ? stored
-      : "system";
-  const resolved =
-    preference === "system"
-      ? window.matchMedia("(prefers-color-scheme: dark)").matches
-        ? "dark"
-        : "light"
-      : preference;
-  root.dataset.themePreference = preference;
-  root.dataset.theme = resolved;
-  root.style.colorScheme = resolved;
-})();
-`;
-
-export function ThemeProvider({ children }: { children: ReactNode }) {
-	const [theme, setThemeState] = useState<ThemeValue>("system");
-	const [resolvedTheme, setResolvedTheme] = useState<ResolvedTheme>("light");
-	const [isReady, setIsReady] = useState(false);
-
-	useEffect(() => {
-		const initialTheme = readInitialTheme();
-		setThemeState(initialTheme);
-		setResolvedTheme(resolveTheme(initialTheme));
-		applyThemeToDocument(initialTheme);
-		setIsReady(true);
-	}, []);
-
-	useEffect(() => {
-		if (!isReady) {
-			return;
-		}
-
-		applyThemeToDocument(theme);
-		setResolvedTheme(resolveTheme(theme));
-		window.localStorage.setItem(THEME_STORAGE_KEY, theme);
-
-		if (theme !== "system" || typeof window.matchMedia !== "function") {
-			return;
-		}
-
-		const media = window.matchMedia(
-			"(prefers-color-scheme: dark)",
-		) as unknown as {
-			matches: boolean;
-			addEventListener?: (type: "change", listener: () => void) => void;
-			removeEventListener?: (type: "change", listener: () => void) => void;
-			addListener?: (listener: () => void) => void;
-			removeListener?: (listener: () => void) => void;
-		};
-		const onChange = () => {
-			const nextResolvedTheme = media.matches ? "dark" : "light";
-			setResolvedTheme(nextResolvedTheme);
-			document.documentElement.dataset.theme = nextResolvedTheme;
-			document.documentElement.style.colorScheme = nextResolvedTheme;
-		};
-
-		if (typeof media.addEventListener === "function") {
-			media.addEventListener("change", onChange);
-		} else {
-			media.addListener?.(onChange);
-		}
-		return () => {
-			if (typeof media.removeEventListener === "function") {
-				media.removeEventListener("change", onChange);
-			} else {
-				media.removeListener?.(onChange);
-			}
-		};
-	}, [isReady, theme]);
-
-	const value = useMemo<ThemeContextValue>(
-		() => ({
-			isReady,
-			theme,
-			resolvedTheme,
-			setTheme: setThemeState,
-		}),
-		[isReady, resolvedTheme, theme],
-	);
-
-	return (
-		<ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>
-	);
-}
-
-export function useTheme() {
-	const context = useContext(ThemeContext);
-	if (!context) {
-		throw new Error("useTheme must be used within ThemeProvider");
-	}
-	return context;
-}