kajji 0.1.0 → 0.1.1

package/src/context/focus.tsx

@@ -1,63 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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
-}