18822132356

Committed 26 Oct 2025 06:39PM UTC coverage: 24.984% (+0.02%) from 24.961%

Build # 18822132356

Build Type

push

github

Committed by

jcubic

Commit Message

add title attr to right panel

Run Details

1819 of 8871 branches covered (20.51%)

Branch coverage included in aggregate %.

883 of 1944 relevant lines covered (45.42%)

1776.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

52.27

/src/components/notes/NotesContext.tsx

'use client';

import { createContext, useContext, useEffect, useCallback, type ReactNode } from 'react';
import { usePathname, useRouter } from 'next/navigation';
import type { NoteTreeNode } from '@/types/tree';
import type { SaveStatus } from '@/types/notes';
import { useNodeSelection } from '@/hooks/useNodeSelection';

interface NotesContextValue {
  notes: NoteTreeNode[];
  selectedNoteId: number | null;
  saveStatus: SaveStatus;
  setNotes: (notes: NoteTreeNode[] | ((prev: NoteTreeNode[]) => NoteTreeNode[])) => void;
  setSaveStatus: (status: SaveStatus) => void;
  updateNoteContent: (noteId: number, content: string) => void;
  updateNoteName: (noteId: number, name: string) => void;
  markNoteDirty: (noteId: number, dirty: boolean) => void;
  getSelectedNote: () => NoteTreeNode | null;
  getNote: (noteId: number) => NoteTreeNode | null;
  selectNote: (noteId: number | null) => void;
}

const NotesContext = createContext<NotesContextValue | undefined>(undefined);

export function useNotesContext() {
  const context = useContext(NotesContext);
  if (context === undefined) {
    throw new Error('useNotesContext must be used within a NotesProvider');
  }
  return context;
}

interface NotesProviderProps {
  children: ReactNode;
  initialNotes?: NoteTreeNode[];
  initialSelectedNoteId?: number | null;
}

export function NotesProvider({
  children,
  initialNotes = [],
  initialSelectedNoteId = null
}: NotesProviderProps) {
  const pathname = usePathname();
  const router = useRouter();

  // Use the hook that manages all the state
  const {
    notes,
    selectedNoteId,
    saveStatus,
    setNotes,
    setSaveStatus,
    updateSelection,
    updateDirtyFlag,
    updateNoteContent,
    updateNoteName
  } = useNodeSelection(initialNotes, initialSelectedNoteId);

  const markNoteDirty = updateDirtyFlag;

  const getSelectedNote = useCallback((): NoteTreeNode | null => {
    if (!selectedNoteId) return null;
    return notes.find((note) => note.id === selectedNoteId) || null;
  }, [notes, selectedNoteId]);

  const getNote = useCallback(
    (noteId: number): NoteTreeNode | null => {
      return notes.find((note) => note.id === noteId) || null;
    },
    [notes]
  );

  // Note selection with Next.js router
  const selectNote = useCallback(
    (noteId: number | null) => {
      // Update state immediately
      updateSelection(noteId);

      // Navigate using Next.js router
      if (noteId === null) {
        router.push('/');
      } else {
        router.push(`/note/${noteId}`);
      }
    },
    [updateSelection, router]
  );

  // Sync URL to state on URL changes
  useEffect(() => {
    const noteMatch = pathname.match(/\/note\/(\d+)/);
    const urlNoteId = noteMatch ? parseInt(noteMatch[1], 10) : null;

    if (urlNoteId !== null) {
      updateSelection(urlNoteId);
    }
  }, [pathname, updateSelection]);

  const value: NotesContextValue = {
    notes,
    selectedNoteId,
    saveStatus,
    setNotes,
    setSaveStatus,
    updateNoteContent,
    updateNoteName,
    markNoteDirty,
    getSelectedNote,
    getNote,
    selectNote
  };

  return <NotesContext.Provider value={value}>{children}</NotesContext.Provider>;
}

1	'use client';
2
3	import { createContext, useContext, useEffect, useCallback, type ReactNode } from 'react';
4	import { usePathname, useRouter } from 'next/navigation';
5	import type { NoteTreeNode } from '@/types/tree';
6	import type { SaveStatus } from '@/types/notes';
7	import { useNodeSelection } from '@/hooks/useNodeSelection';
8
9	interface NotesContextValue {
10	notes: NoteTreeNode[];
11	selectedNoteId: number \| null;
12	saveStatus: SaveStatus;
13	setNotes: (notes: NoteTreeNode[] \| ((prev: NoteTreeNode[]) => NoteTreeNode[])) => void;
14	setSaveStatus: (status: SaveStatus) => void;
15	updateNoteContent: (noteId: number, content: string) => void;
16	updateNoteName: (noteId: number, name: string) => void;
17	markNoteDirty: (noteId: number, dirty: boolean) => void;
18	getSelectedNote: () => NoteTreeNode \| null;
19	getNote: (noteId: number) => NoteTreeNode \| null;
20	selectNote: (noteId: number \| null) => void;
21	}
22
23	const NotesContext = createContext<NotesContextValue \| undefined>(undefined);	4✔
24
25	export function useNotesContext() {	4✔
26	const context = useContext(NotesContext);	38✔
27	if (context === undefined) {	38!
28	throw new Error('useNotesContext must be used within a NotesProvider');	×
29	}
30	return context;	38✔
31	}
32
33	interface NotesProviderProps {
34	children: ReactNode;
35	initialNotes?: NoteTreeNode[];
36	initialSelectedNoteId?: number \| null;
37	}
38
39	export function NotesProvider({	4✔
40	children,
41	initialNotes = [],	×
42	initialSelectedNoteId = null	×
43	}: NotesProviderProps) {
44	const pathname = usePathname();	22✔
45	const router = useRouter();	22✔
46
47	// Use the hook that manages all the state
48	const {
49	notes,
50	selectedNoteId,
51	saveStatus,
52	setNotes,
53	setSaveStatus,
54	updateSelection,
55	updateDirtyFlag,
56	updateNoteContent,
57	updateNoteName
58	} = useNodeSelection(initialNotes, initialSelectedNoteId);	22✔
59
60	const markNoteDirty = updateDirtyFlag;	22✔
61
62	const getSelectedNote = useCallback((): NoteTreeNode \| null => {	22✔
63	if (!selectedNoteId) return null;	8!
64	return notes.find((note) => note.id === selectedNoteId) \|\| null;	×
65	}, [notes, selectedNoteId]);
66
67	const getNote = useCallback(	22✔
68	(noteId: number): NoteTreeNode \| null => {
69	return notes.find((note) => note.id === noteId) \|\| null;	×
70	},
71	[notes]
72	);
73
74	// Note selection with Next.js router
75	const selectNote = useCallback(	22✔
76	(noteId: number \| null) => {
77	// Update state immediately
78	updateSelection(noteId);	×
79
80	// Navigate using Next.js router
81	if (noteId === null) {	×
82	router.push('/');	×
83	} else {
84	router.push(`/note/${noteId}`);	×
85	}
86	},
87	[updateSelection, router]
88	);
89
90	// Sync URL to state on URL changes
91	useEffect(() => {	22✔
92	const noteMatch = pathname.match(/\/note\/(\d+)/);	3✔
93	const urlNoteId = noteMatch ? parseInt(noteMatch[1], 10) : null;	3!
94
95	if (urlNoteId !== null) {	3!
96	updateSelection(urlNoteId);	×
97	}
98	}, [pathname, updateSelection]);
99
100	const value: NotesContextValue = {	22✔
101	notes,
102	selectedNoteId,
103	saveStatus,
104	setNotes,
105	setSaveStatus,
106	updateNoteContent,
107	updateNoteName,
108	markNoteDirty,
109	getSelectedNote,
110	getNote,
111	selectNote
112	};
113
114	return <NotesContext.Provider value={value}>{children}</NotesContext.Provider>;	×
115	}

jcubic / 10xDevs / 18822132356

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous