kajji 0.1.0

package/src/context/focus.tsx

@@ -0,0 +1,63 @@
+import { createMemo, createSignal } from "solid-js"
+import { createSimpleContext } from "./helper"
+import { type Context, type Panel, panelFromContext } from "./types"
+
+export type { Panel }
+
+const PANEL_ORDER: Panel[] = ["log", "refs", "detail"]
+
+export const { use: useFocus, provider: FocusProvider } = createSimpleContext({
+	name: "Focus",
+	init: () => {
+		const [activeContext, setActiveContext] =
+			createSignal<Context>("log.revisions")
+
+		const panel = createMemo<Panel>(() => {
+			return panelFromContext(activeContext()) ?? "log"
+		})
+
+		const setPanel = (p: Panel) => {
+			const current = activeContext()
+			const currentPanel = panelFromContext(current)
+			if (currentPanel === p) return
+
+			switch (p) {
+				case "log":
+					setActiveContext("log.revisions")
+					break
+				case "refs":
+					setActiveContext("refs.bookmarks")
+					break
+				case "detail":
+					setActiveContext("detail")
+					break
+			}
+		}
+
+		const cycleNext = () => {
+			const current = panel()
+			const idx = PANEL_ORDER.indexOf(current)
+			const next = PANEL_ORDER[(idx + 1) % PANEL_ORDER.length] ?? "log"
+			setPanel(next)
+		}
+
+		const cyclePrev = () => {
+			const current = panel()
+			const idx = PANEL_ORDER.indexOf(current)
+			const next =
+				PANEL_ORDER[(idx - 1 + PANEL_ORDER.length) % PANEL_ORDER.length] ??
+				"log"
+			setPanel(next)
+		}
+
+		return {
+			panel,
+			setPanel,
+			activeContext,
+			setActiveContext,
+			cycleNext,
+			cyclePrev,
+			isPanel: (p: Panel) => panel() === p,
+		}
+	},
+})

package/src/context/helper.tsx

@@ -0,0 +1,24 @@
+import { type ParentProps, createContext, useContext } from "solid-js"
+
+export function createSimpleContext<T>(input: {
+	name: string
+	init: () => T
+}) {
+	const ctx = createContext<T>()
+
+	return {
+		provider: (props: ParentProps) => {
+			const value = input.init()
+			return <ctx.Provider value={value}>{props.children}</ctx.Provider>
+		},
+		use: () => {
+			const value = useContext(ctx)
+			if (!value) {
+				throw new Error(
+					`use${input.name} must be used within ${input.name}Provider`,
+				)
+			}
+			return value
+		},
+	}
+}

package/src/context/keybind.tsx

@@ -0,0 +1,51 @@
+import { createMemo } from "solid-js"
+import {
+	DEFAULT_KEYBINDS,
+	type KeybindConfigKey,
+	type KeybindInfo,
+	fromParsedKey,
+	keybindToString,
+	match,
+	parse,
+} from "../keybind"
+import { createSimpleContext } from "./helper"
+
+export const { use: useKeybind, provider: KeybindProvider } =
+	createSimpleContext({
+		name: "Keybind",
+		init: () => {
+			const keybinds = createMemo(() => {
+				const parsed: Record<string, KeybindInfo[]> = {}
+				for (const [key, value] of Object.entries(DEFAULT_KEYBINDS)) {
+					parsed[key] = parse(value)
+				}
+				return parsed
+			})
+
+			return {
+				match: (
+					configKey: KeybindConfigKey,
+					evt: {
+						name?: string
+						ctrl?: boolean
+						meta?: boolean
+						shift?: boolean
+					},
+				): boolean => {
+					const bindings = keybinds()[configKey]
+					if (!bindings) return false
+					const parsed = fromParsedKey(evt)
+					return bindings.some((binding) => match(binding, parsed))
+				},
+
+				print: (configKey: KeybindConfigKey): string => {
+					const bindings = keybinds()[configKey]
+					const first = bindings?.[0]
+					if (!first) return ""
+					return keybindToString(first)
+				},
+
+				all: () => DEFAULT_KEYBINDS,
+			}
+		},
+	})

package/src/context/loading.tsx

@@ -0,0 +1,68 @@
+import { type JSX, createContext, createSignal, useContext } from "solid-js"
+
+const DEBOUNCE_MS = 150
+
+interface LoadingContextValue {
+	isLoading: () => boolean
+	loadingText: () => string | null
+	start: (text: string) => void
+	stop: () => void
+	run: <T>(text: string, fn: () => Promise<T>) => Promise<T>
+}
+
+const LoadingContext = createContext<LoadingContextValue>()
+
+export function LoadingProvider(props: { children: JSX.Element }) {
+	const [isLoading, setIsLoading] = createSignal(false)
+	const [loadingText, setLoadingText] = createSignal<string | null>(null)
+	let debounceTimer: ReturnType<typeof setTimeout> | null = null
+
+	const start = (text: string) => {
+		setLoadingText(text)
+		if (debounceTimer) clearTimeout(debounceTimer)
+		debounceTimer = setTimeout(() => {
+			setIsLoading(true)
+			debounceTimer = null
+		}, DEBOUNCE_MS)
+	}
+
+	const stop = () => {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer)
+			debounceTimer = null
+		}
+		setIsLoading(false)
+		setLoadingText(null)
+	}
+
+	const run = async <T,>(text: string, fn: () => Promise<T>): Promise<T> => {
+		start(text)
+		try {
+			return await fn()
+		} finally {
+			stop()
+		}
+	}
+
+	const value: LoadingContextValue = {
+		isLoading,
+		loadingText,
+		start,
+		stop,
+		run,
+	}
+
+	return (
+		<LoadingContext.Provider value={value}>
+			{props.children}
+		</LoadingContext.Provider>
+	)
+}
+
+export function useLoading(): LoadingContextValue {
+	const ctx = useContext(LoadingContext)
+	if (!ctx) {
+		throw new Error("useLoading must be used within LoadingProvider")
+	}
+	return ctx
+}