@peaske7/readit 0.1.8 → 0.2.1

package/src/hooks/useDocument.ts

@@ -1,156 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-import { toast } from "sonner";
-import { appStore, useAppStore } from "../store";
-import type { Document } from "../types";
-
-interface UseDocumentResult {
-  document: Document | null;
-  error: string | null;
-  isInitialized: boolean;
-  reload: () => Promise<void>;
-}
-
-interface DocListItem {
-  path: string;
-  fileName: string;
-  type: Document["type"];
-}
-
-/**
- * Manage multi-document loading, lazy content fetching, and live reloading.
- *
- * On mount: fetches the document list from `/api/documents` and opens all
- * files in the store. Content is loaded lazily when a tab becomes active.
- * SSE events trigger content updates for already-loaded documents.
- */
-export function useDocument(): UseDocumentResult {
-  const [error, setError] = useState<string | null>(null);
-  const [isInitialized, setIsInitialized] = useState(false);
-
-  const activeDocumentPath = useAppStore((s) => s.activeDocumentPath);
-
-  // Active document — null until content is loaded
-  const document = useAppStore((s) => {
-    const ds = s.getActiveDocumentState();
-    if (!ds || !ds.document.content) return null;
-    return ds.document;
-  });
-
-  // Fetch document list on mount, populate store
-  useEffect(() => {
-    async function init() {
-      try {
-        const res = await fetch("/api/documents");
-        if (!res.ok) throw new Error(`Server error: ${res.status}`);
-        const data = await res.json();
-
-        const clean = data.clean || false;
-        if (data.workingDirectory) {
-          appStore.getState().setWorkingDirectory(data.workingDirectory);
-        }
-        data.files.forEach((file: DocListItem, index: number) => {
-          appStore.getState().openDocument(
-            {
-              content: "", // Content loaded lazily on tab activation
-              type: file.type,
-              filePath: file.path,
-              fileName: file.fileName,
-              clean,
-            },
-            { active: index === 0 },
-          );
-        });
-      } catch (err) {
-        setError(
-          err instanceof Error ? err.message : "Failed to load documents",
-        );
-      } finally {
-        setIsInitialized(true);
-      }
-    }
-    init();
-  }, []);
-
-  // Load content when active document changes and has no content yet
-  useEffect(() => {
-    if (!activeDocumentPath) return;
-    const state = appStore.getState().documents.get(activeDocumentPath);
-    if (!state || state.document.content) return;
-
-    async function loadContent() {
-      try {
-        const res = await fetch(
-          `/api/document?path=${encodeURIComponent(activeDocumentPath!)}`,
-        );
-        if (!res.ok) throw new Error(`Server error: ${res.status}`);
-        const data = await res.json();
-        appStore
-          .getState()
-          .updateDocumentContent(data.content, activeDocumentPath!);
-      } catch (err) {
-        setError(
-          err instanceof Error ? err.message : "Failed to load document",
-        );
-      }
-    }
-    loadContent();
-  }, [activeDocumentPath]);
-
-  // SSE: register new documents without stealing focus; reload loaded docs on updates
-  useEffect(() => {
-    const eventSource = new EventSource("/api/document/stream");
-    eventSource.onmessage = async (e) => {
-      try {
-        const data = JSON.parse(e.data);
-        if (data.type === "document-added" && data.path) {
-          appStore.getState().openDocument(
-            {
-              content: "", // Lazy-loaded when tab activated
-              type: data.fileType,
-              filePath: data.path,
-              fileName: data.fileName,
-              clean: false,
-            },
-            { active: false },
-          );
-          return;
-        }
-        if (data.type === "document-updated" && data.path) {
-          // Only reload if content was previously loaded
-          const state = appStore.getState().documents.get(data.path);
-          if (!state || !state.document.content) return;
-
-          const res = await fetch(
-            `/api/document?path=${encodeURIComponent(data.path)}`,
-          );
-          if (res.ok) {
-            const doc = await res.json();
-            appStore.getState().updateDocumentContent(doc.content, data.path);
-          }
-        }
-      } catch {
-        // Ignore non-JSON messages ("connected", "ping")
-      }
-    };
-    return () => eventSource.close();
-  }, []);
-
-  const reload = useCallback(async () => {
-    if (!activeDocumentPath) return;
-    try {
-      const res = await fetch(
-        `/api/document?path=${encodeURIComponent(activeDocumentPath)}`,
-      );
-      if (!res.ok) throw new Error(`Server error: ${res.status}`);
-      const data = await res.json();
-      appStore
-        .getState()
-        .updateDocumentContent(data.content, activeDocumentPath);
-      toast.success("Document reloaded");
-    } catch (err) {
-      toast.error(err instanceof Error ? err.message : "Failed to reload");
-    }
-  }, [activeDocumentPath]);
-
-  return { document, error, isInitialized, reload };
-}

package/src/hooks/useEditorScheme.ts

@@ -1,51 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-import { toast } from "sonner";
-import { type EditorScheme, EditorSchemes } from "../types";
-
-interface UseEditorSchemeResult {
-  editorScheme: EditorScheme;
-  setEditorScheme: (scheme: EditorScheme) => Promise<void>;
-}
-
-export function useEditorScheme(): UseEditorSchemeResult {
-  const [editorScheme, setEditorSchemeState] = useState<EditorScheme>(
-    EditorSchemes.NONE,
-  );
-
-  useEffect(() => {
-    const fetchSettings = async () => {
-      try {
-        const response = await fetch("/api/settings");
-        if (response.ok) {
-          const settings = await response.json();
-          setEditorSchemeState(settings.editorScheme || EditorSchemes.NONE);
-        }
-      } catch (err) {
-        console.error("Failed to fetch settings:", err);
-      }
-    };
-
-    fetchSettings();
-  }, []);
-
-  const setEditorScheme = useCallback(async (scheme: EditorScheme) => {
-    setEditorSchemeState(scheme);
-
-    try {
-      const response = await fetch("/api/settings", {
-        method: "PUT",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ editorScheme: scheme }),
-      });
-
-      if (!response.ok) {
-        throw new Error("Failed to save settings");
-      }
-    } catch (err) {
-      console.error("Failed to save editor scheme:", err);
-      toast.error("Failed to save editor scheme");
-    }
-  }, []);
-
-  return { editorScheme, setEditorScheme };
-}

package/src/hooks/useFontPreference.ts

@@ -1,59 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-import { toast } from "sonner";
-import { FontFamilies, type FontFamily } from "../types";
-
-interface UseFontPreferenceResult {
-  fontFamily: FontFamily;
-  setFontFamily: (font: FontFamily) => Promise<void>;
-  isLoading: boolean;
-}
-
-export function useFontPreference(): UseFontPreferenceResult {
-  const [fontFamily, setFontFamilyState] = useState<FontFamily>(
-    FontFamilies.SERIF,
-  );
-  const [isLoading, setIsLoading] = useState(true);
-
-  useEffect(() => {
-    const fetchSettings = async () => {
-      try {
-        const response = await fetch("/api/settings");
-        if (response.ok) {
-          const settings = await response.json();
-          setFontFamilyState(settings.fontFamily || FontFamilies.SERIF);
-        }
-      } catch (err) {
-        console.error("Failed to fetch settings:", err);
-      } finally {
-        setIsLoading(false);
-      }
-    };
-
-    fetchSettings();
-  }, []);
-
-  const setFontFamily = useCallback(async (font: FontFamily) => {
-    setFontFamilyState(font);
-
-    try {
-      const response = await fetch("/api/settings", {
-        method: "PUT",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ fontFamily: font }),
-      });
-
-      if (!response.ok) {
-        throw new Error("Failed to save settings");
-      }
-    } catch (err) {
-      console.error("Failed to save font preference:", err);
-      toast.error("Failed to save font preference");
-    }
-  }, []);
-
-  return {
-    fontFamily,
-    setFontFamily,
-    isLoading,
-  };
-}

package/src/hooks/useHeadings.test.ts

@@ -1,159 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import { describe, expect, it } from "vitest";
-import { useHeadings } from "./useHeadings";
-
-describe("useHeadings - markdown", () => {
-  it("extracts basic headings", () => {
-    const content = `# Heading 1
-## Heading 2
-### Heading 3`;
-
-    const { result } = renderHook(() => useHeadings(content, "markdown"));
-
-    expect(result.current).toEqual([
-      { id: "heading-1", text: "Heading 1", level: 1 },
-      { id: "heading-2", text: "Heading 2", level: 2 },
-      { id: "heading-3", text: "Heading 3", level: 3 },
-    ]);
-  });
-
-  it("handles duplicate headings", () => {
-    const content = `## Section
-## Section
-## Section`;
-
-    const { result } = renderHook(() => useHeadings(content, "markdown"));
-
-    expect(result.current).toEqual([
-      { id: "section", text: "Section", level: 2 },
-      { id: "section-1", text: "Section", level: 2 },
-      { id: "section-2", text: "Section", level: 2 },
-    ]);
-  });
-
-  it("ignores headings inside fenced code blocks", () => {
-    const content = `# Real Heading
-
-\`\`\`bash
-# This is a comment, not a heading
-echo "hello"
-\`\`\`
-
-## Another Real Heading`;
-
-    const { result } = renderHook(() => useHeadings(content, "markdown"));
-
-    expect(result.current).toEqual([
-      { id: "real-heading", text: "Real Heading", level: 1 },
-      { id: "another-real-heading", text: "Another Real Heading", level: 2 },
-    ]);
-  });
-
-  it("ignores headings inside triple-tilde code blocks", () => {
-    const content = `# Real Heading
-
-~~~python
-# Python comment
-def foo():
-    pass
-~~~
-
-## Another Real Heading`;
-
-    const { result } = renderHook(() => useHeadings(content, "markdown"));
-
-    expect(result.current).toEqual([
-      { id: "real-heading", text: "Real Heading", level: 1 },
-      { id: "another-real-heading", text: "Another Real Heading", level: 2 },
-    ]);
-  });
-
-  it("handles multiple code blocks", () => {
-    const content = `# Introduction
-
-\`\`\`bash
-# Comment 1
-\`\`\`
-
-## Methods
-
-\`\`\`python
-# Comment 2
-\`\`\`
-
-## Results`;
-
-    const { result } = renderHook(() => useHeadings(content, "markdown"));
-
-    expect(result.current).toEqual([
-      { id: "introduction", text: "Introduction", level: 1 },
-      { id: "methods", text: "Methods", level: 2 },
-      { id: "results", text: "Results", level: 2 },
-    ]);
-  });
-
-  it("handles code block with language specifier", () => {
-    const content = `# Setup
-
-\`\`\`bash
-# Use a custom port
-npx readit document.md --port 3000
-\`\`\`
-
-## Usage`;
-
-    const { result } = renderHook(() => useHeadings(content, "markdown"));
-
-    expect(result.current).toEqual([
-      { id: "setup", text: "Setup", level: 1 },
-      { id: "usage", text: "Usage", level: 2 },
-    ]);
-  });
-
-  it("returns empty array for null content", () => {
-    const { result } = renderHook(() => useHeadings(null, "markdown"));
-    expect(result.current).toEqual([]);
-  });
-
-  it("returns empty array for null type", () => {
-    const { result } = renderHook(() => useHeadings("# Heading", null));
-    expect(result.current).toEqual([]);
-  });
-});
-
-describe("useHeadings - html", () => {
-  it("extracts basic headings", () => {
-    const content = `<h1>Heading 1</h1>
-<h2>Heading 2</h2>
-<h3>Heading 3</h3>`;
-
-    const { result } = renderHook(() => useHeadings(content, "html"));
-
-    expect(result.current).toEqual([
-      { id: "heading-1", text: "Heading 1", level: 1 },
-      { id: "heading-2", text: "Heading 2", level: 2 },
-      { id: "heading-3", text: "Heading 3", level: 3 },
-    ]);
-  });
-
-  it("uses existing id attribute", () => {
-    const content = `<h1 id="custom-id">Heading 1</h1>`;
-
-    const { result } = renderHook(() => useHeadings(content, "html"));
-
-    expect(result.current).toEqual([
-      { id: "custom-id", text: "Heading 1", level: 1 },
-    ]);
-  });
-
-  it("decodes HTML entities", () => {
-    const content = `<h1>Hello &amp; World</h1>`;
-
-    const { result } = renderHook(() => useHeadings(content, "html"));
-
-    // Note: & is stripped, leaving "Hello  World" → "hello-world" (hyphens collapsed)
-    expect(result.current).toEqual([
-      { id: "hello-world", text: "Hello & World", level: 1 },
-    ]);
-  });
-});

package/src/hooks/useHeadings.ts

@@ -1,129 +0,0 @@
-import { useMemo } from "react";
-import { slugify } from "../lib/utils";
-import type { DocumentType } from "../types";
-
-export interface Heading {
-  id: string;
-  text: string;
-  level: 1 | 2 | 3 | 4 | 5 | 6;
-}
-
-/**
- * Remove code blocks from markdown content.
- * Handles both fenced (```) and indented (4 spaces) code blocks.
- */
-function stripCodeBlocks(content: string): string {
-  // Remove fenced code blocks (``` or ~~~)
-  let result = content.replace(/^(`{3,}|~{3,}).*$[\s\S]*?^\1\s*$/gm, "");
-
-  // Remove indented code blocks (4 spaces or 1 tab at start of line)
-  // Only remove if preceded by a blank line (to avoid removing list items)
-  result = result.replace(/(?:^|\n\n)((?:(?:[ ]{4}|\t).+\n?)+)/g, "\n\n");
-
-  return result;
-}
-
-/**
- * Extract headings from markdown content
- */
-function parseMarkdownHeadings(content: string): Heading[] {
-  const headings: Heading[] = [];
-  const seenIds = new Map<string, number>();
-
-  // Strip code blocks to avoid matching # comments in code
-  const contentWithoutCode = stripCodeBlocks(content);
-
-  const regex = /^(#{1,6})\s+(.+)$/gm;
-  let match = regex.exec(contentWithoutCode);
-
-  while (match !== null) {
-    const level = match[1].length as 1 | 2 | 3 | 4 | 5 | 6;
-    const text = match[2].trim();
-    const baseId = slugify(text);
-    const count = seenIds.get(baseId) ?? 0;
-    const id = count > 0 ? `${baseId}-${count}` : baseId;
-    seenIds.set(baseId, count + 1);
-
-    headings.push({ id, text, level });
-    match = regex.exec(contentWithoutCode);
-  }
-
-  return headings;
-}
-
-/**
- * Generate ID matching the iframe's ensureHeadingIds algorithm.
- * Note: This differs from utils/slugify - it strips underscores to match
- * the iframe script's ID generation exactly.
- */
-function generateHeadingId(text: string): string {
-  return text
-    .toLowerCase()
-    .trim()
-    .replace(/[^a-z0-9 -]/g, "")
-    .replace(/ +/g, "-")
-    .replace(/-+/g, "-");
-}
-
-/**
- * Extract headings from HTML content
- */
-function parseHtmlHeadings(content: string): Heading[] {
-  const headings: Heading[] = [];
-  const seenIds = new Map<string, number>();
-
-  // Match h1-h6 tags, capturing attributes and text content
-  const regex = /<h([1-6])([^>]*)>([^<]+)<\/h\1>/gi;
-  let match = regex.exec(content);
-
-  while (match !== null) {
-    const level = Number.parseInt(match[1], 10) as 1 | 2 | 3 | 4 | 5 | 6;
-    const attributes = match[2];
-    // Strip any remaining HTML tags and decode entities
-    const text = match[3]
-      .replace(/<[^>]+>/g, "")
-      .replace(/&amp;/g, "&")
-      .replace(/&lt;/g, "<")
-      .replace(/&gt;/g, ">")
-      .replace(/&quot;/g, '"')
-      .trim();
-
-    if (text) {
-      // Extract existing id attribute if present
-      const idMatch = /\sid=["']([^"']+)["']/i.exec(attributes);
-
-      // Use existing ID or generate one with duplicate handling
-      const id = idMatch
-        ? idMatch[1]
-        : (() => {
-            const baseId = generateHeadingId(text);
-            const count = seenIds.get(baseId) ?? 0;
-            seenIds.set(baseId, count + 1);
-            return count > 0 ? `${baseId}-${count}` : baseId;
-          })();
-
-      headings.push({ id, text, level });
-    }
-    match = regex.exec(content);
-  }
-
-  return headings;
-}
-
-/**
- * Hook to extract headings from document content
- */
-export function useHeadings(
-  content: string | null,
-  type: DocumentType | null,
-): Heading[] {
-  return useMemo(() => {
-    if (!content || !type) return [];
-
-    if (type === "markdown") {
-      return parseMarkdownHeadings(content);
-    }
-
-    return parseHtmlHeadings(content);
-  }, [content, type]);
-}

package/src/hooks/useKeybindings.ts

@@ -1,108 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-import { toast } from "sonner";
-import {
-  resolveShortcuts,
-  type ShortcutDefinition,
-} from "../lib/shortcut-registry";
-import type { KeybindingOverride, ShortcutBinding } from "../types";
-
-interface UseKeybindingsResult {
-  shortcuts: ShortcutDefinition[];
-  updateBinding: (id: string, binding: ShortcutBinding) => Promise<void>;
-  toggleEnabled: (id: string) => Promise<void>;
-  resetToDefaults: () => Promise<void>;
-  isLoading: boolean;
-}
-
-export function useKeybindings(): UseKeybindingsResult {
-  const [overrides, setOverrides] = useState<KeybindingOverride[]>([]);
-  const [isLoading, setIsLoading] = useState(true);
-
-  useEffect(() => {
-    const fetchKeybindings = async () => {
-      try {
-        const response = await fetch("/api/settings");
-        if (response.ok) {
-          const settings = await response.json();
-          setOverrides(settings.keybindings ?? []);
-        }
-      } catch (err) {
-        console.error("Failed to fetch keybindings:", err);
-      } finally {
-        setIsLoading(false);
-      }
-    };
-
-    fetchKeybindings();
-  }, []);
-
-  const persistOverrides = useCallback(
-    async (newOverrides: KeybindingOverride[]) => {
-      try {
-        const response = await fetch("/api/settings");
-        if (!response.ok) return;
-
-        const currentSettings = await response.json();
-        const updated = { ...currentSettings, keybindings: newOverrides };
-
-        const putResponse = await fetch("/api/settings", {
-          method: "PUT",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(updated),
-        });
-
-        if (!putResponse.ok) {
-          throw new Error("Failed to save keybindings");
-        }
-      } catch (err) {
-        console.error("Failed to save keybindings:", err);
-        toast.error("Failed to save keybindings");
-      }
-    },
-    [],
-  );
-
-  const updateBinding = useCallback(
-    async (id: string, binding: ShortcutBinding) => {
-      const newOverrides = overrides.filter((o) => o.id !== id);
-      newOverrides.push({ id, binding, enabled: true });
-
-      setOverrides(newOverrides);
-      await persistOverrides(newOverrides);
-    },
-    [overrides, persistOverrides],
-  );
-
-  const toggleEnabled = useCallback(
-    async (id: string) => {
-      const existing = overrides.find((o) => o.id === id);
-      const currentEnabled = existing?.enabled ?? true;
-      const newOverrides = overrides.filter((o) => o.id !== id);
-      newOverrides.push({
-        id,
-        binding: existing?.binding,
-        enabled: !currentEnabled,
-      });
-
-      setOverrides(newOverrides);
-      await persistOverrides(newOverrides);
-    },
-    [overrides, persistOverrides],
-  );
-
-  const resetToDefaults = useCallback(async () => {
-    setOverrides([]);
-    await persistOverrides([]);
-    toast.success("Keyboard shortcuts reset to defaults");
-  }, [persistOverrides]);
-
-  const shortcuts = resolveShortcuts(overrides);
-
-  return {
-    shortcuts,
-    updateBinding,
-    toggleEnabled,
-    resetToDefaults,
-    isLoading,
-  };
-}