18840571689

Committed 27 Oct 2025 12:14PM UTC coverage: 23.648% (-1.9%) from 25.594%

Build # 18840571689

Build Type

push

github

Committed by

jcubic

Commit Message

update workflow

Run Details

1783 of 8857 branches covered (20.13%)

Branch coverage included in aggregate %.

761 of 1901 relevant lines covered (40.03%)

1814.76 hits per line

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

0.0

/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);

  // Sync notes state when initialNotes prop changes (e.g., after redirect)
  useEffect(() => {
    if (initialNotes.length > 0 && notes.length === 0) {
      setNotes(initialNotes);
    }
  }, [initialNotes, notes.length, setNotes]);

  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);	×
24
25	export function useNotesContext() {
26	const context = useContext(NotesContext);	×
27	if (context === undefined) {	×
28	throw new Error('useNotesContext must be used within a NotesProvider');	×
29	}
30	return context;	×
31	}
32
33	interface NotesProviderProps {
34	children: ReactNode;
35	initialNotes?: NoteTreeNode[];
36	initialSelectedNoteId?: number \| null;
37	}
38
39	export function NotesProvider({
40	children,
41	initialNotes = [],	×
42	initialSelectedNoteId = null	×
43	}: NotesProviderProps) {
44	const pathname = usePathname();	×
45	const router = useRouter();	×
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);	×
59
60	// Sync notes state when initialNotes prop changes (e.g., after redirect)
61	useEffect(() => {	×
62	if (initialNotes.length > 0 && notes.length === 0) {	×
63	setNotes(initialNotes);	×
64	}
65	}, [initialNotes, notes.length, setNotes]);
66
67	const markNoteDirty = updateDirtyFlag;	×
68
69	const getSelectedNote = useCallback((): NoteTreeNode \| null => {	×
70	if (!selectedNoteId) return null;	×
71	return notes.find((note) => note.id === selectedNoteId) \|\| null;	×
72	}, [notes, selectedNoteId]);
73
74	const getNote = useCallback(	×
75	(noteId: number): NoteTreeNode \| null => {
76	return notes.find((note) => note.id === noteId) \|\| null;	×
77	},
78	[notes]
79	);
80
81	// Note selection with Next.js router
82	const selectNote = useCallback(	×
83	(noteId: number \| null) => {
84	// Update state immediately
85	updateSelection(noteId);	×
86
87	// Navigate using Next.js router
88	if (noteId === null) {	×
89	router.push('/');	×
90	} else {
91	router.push(`/note/${noteId}`);	×
92	}
93	},
94	[updateSelection, router]
95	);
96
97	// Sync URL to state on URL changes
98	useEffect(() => {	×
99	const noteMatch = pathname.match(/\/note\/(\d+)/);	×
100	const urlNoteId = noteMatch ? parseInt(noteMatch[1], 10) : null;	×
101
102	if (urlNoteId !== null) {	×
103	updateSelection(urlNoteId);	×
104	}
105	}, [pathname, updateSelection]);
106
107	const value: NotesContextValue = {	×
108	notes,
109	selectedNoteId,
110	saveStatus,
111	setNotes,
112	setSaveStatus,
113	updateNoteContent,
114	updateNoteName,
115	markNoteDirty,
116	getSelectedNote,
117	getNote,
118	selectNote
119	};
120
121	return <NotesContext.Provider value={value}>{children}</NotesContext.Provider>;	×
122	}

jcubic / 10xDevs / 18840571689

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