-
-
-
-
setTitle(e.target.value)}
- placeholder="My Math Cheat Sheet"
- required
- className="input-field"
- />
+
+
+
+
+ 70 ? 'title-char-counter-warn' : ''}>
+ {title.length}/80
+
-
+
+
setTitle(e.target.value)}
+ placeholder="My Cheat Sheet"
+ required
+ className="input-field"
+ maxLength={80}
+ autoComplete="off"
+ spellCheck={false}
+ />
+
)}
+ {toast && (
+
+
+ {toast.type === 'success' ? '✓' : '✕'}
+
+ {toast.message}
+
+ )}
);
};
diff --git a/frontend/src/components/CreateCheatSheet.test.jsx b/frontend/src/components/CreateCheatSheet.test.jsx
index 126a83f..e130d22 100644
--- a/frontend/src/components/CreateCheatSheet.test.jsx
+++ b/frontend/src/components/CreateCheatSheet.test.jsx
@@ -1,5 +1,5 @@
import React from 'react';
-import { render, screen, fireEvent, within } from '@testing-library/react';
+import { render, screen, fireEvent, waitFor, within } from '@testing-library/react';
import { describe, it, expect, vi, beforeEach } from 'vitest';
import CreateCheatSheet from './CreateCheatSheet';
import { useFormulas } from '../hooks/formulas';
@@ -31,6 +31,8 @@ describe('CreateCheatSheet Component', () => {
selectedCategories: {},
groupedFormulas: [],
toggleClass: vi.fn(),
+ selectAllClasses: vi.fn(),
+ deselectAllClasses: vi.fn(),
toggleCategory: vi.fn(),
getSelectedFormulasList: vi.fn(),
clearSelections: vi.fn(),
@@ -59,6 +61,8 @@ describe('CreateCheatSheet Component', () => {
setSpacing: vi.fn(),
margins: '0.15in',
setMargins: vi.fn(),
+ orientation: 'portrait',
+ setOrientation: vi.fn(),
pdfBlob: null,
isGenerating: false,
isCompiling: false,
@@ -151,11 +155,35 @@ describe('CreateCheatSheet Component', () => {
expect(screen.queryByLabelText(/Generated LaTeX Code:/i)).not.toBeInTheDocument();
});
+ it('restores saved orientation from initial data', () => {
+ const setOrientation = vi.fn();
+
+ useLatex.mockReturnValue({
+ ...mockUseLatex,
+ setOrientation,
+ });
+
+ render(
+
,
+ );
+
+ expect(setOrientation).toHaveBeenCalledWith('landscape');
+ });
+
it('compiles existing manual content without regenerating', () => {
const handleCompileOnlyMock = vi.fn();
const selectedFormulas = [{ name: 'test' }];
- useLatex.mockReturnValue({ ...mockUseLatex, contentModified: true, handleCompileOnly: handleCompileOnlyMock });
+ useLatex.mockReturnValue({
+ ...mockUseLatex,
+ contentModified: true,
+ canRegenerateFromSelections: false,
+ handleCompileOnly: handleCompileOnlyMock,
+ });
useFormulas.mockReturnValue({
...mockUseFormulas,
selectedCount: 1,
@@ -169,6 +197,102 @@ describe('CreateCheatSheet Component', () => {
expect(handleCompileOnlyMock).toHaveBeenCalledWith(selectedFormulas);
});
+ it('regenerates from selections when source is generated even if contentModified is true', () => {
+ const handleCompileOnlyMock = vi.fn();
+ const handlePreviewMock = vi.fn();
+ const selectedFormulas = [{ name: 'updated-formula' }];
+
+ useLatex.mockReturnValue({
+ ...mockUseLatex,
+ contentModified: true,
+ canRegenerateFromSelections: true,
+ handleCompileOnly: handleCompileOnlyMock,
+ handlePreview: handlePreviewMock,
+ });
+ useFormulas.mockReturnValue({
+ ...mockUseFormulas,
+ selectedCount: 1,
+ getSelectedFormulasList: vi.fn().mockReturnValue(selectedFormulas),
+ });
+
+ render(
);
+
+ fireEvent.click(screen.getByRole('button', { name: /Compile PDF/i }));
+
+ expect(handlePreviewMock).toHaveBeenCalledWith(null, expect.objectContaining({ formulas: selectedFormulas }));
+ expect(handleCompileOnlyMock).not.toHaveBeenCalled();
+ });
+
+ it('regenerates after class changes when sheet was generated previously in session', () => {
+ const handleCompileOnlyMock = vi.fn();
+ const handlePreviewMock = vi.fn();
+ const selectedFormulas = [{ class: 'Math 101', category: 'Algebra', name: 'updated-formula' }];
+
+ useLatex.mockReturnValue({
+ ...mockUseLatex,
+ contentSource: 'generated',
+ canRegenerateFromSelections: false,
+ contentModified: false,
+ handleCompileOnly: handleCompileOnlyMock,
+ handlePreview: handlePreviewMock,
+ });
+ useFormulas.mockReturnValue({
+ ...mockUseFormulas,
+ selectedCount: 1,
+ getSelectedFormulasList: vi.fn().mockReturnValue(selectedFormulas),
+ });
+
+ render(
);
+
+ fireEvent.click(screen.getByRole('button', { name: /Compile PDF/i }));
+
+ expect(handlePreviewMock).toHaveBeenCalledWith(null, expect.objectContaining({ formulas: selectedFormulas }));
+ expect(handleCompileOnlyMock).not.toHaveBeenCalled();
+ });
+
+ it('regenerates when selections change after initial empty-source compile', () => {
+ const handleCompileOnlyMock = vi.fn();
+ const handlePreviewMock = vi.fn();
+ const firstSelection = [{ class: 'Math 101', category: 'Algebra', name: 'first-formula' }];
+ const secondSelection = [{ class: 'Math 102', category: 'Geometry', name: 'second-formula' }];
+
+ useLatex
+ .mockReturnValueOnce({
+ ...mockUseLatex,
+ contentSource: 'empty',
+ canRegenerateFromSelections: true,
+ contentModified: false,
+ handleCompileOnly: handleCompileOnlyMock,
+ handlePreview: handlePreviewMock,
+ })
+ .mockReturnValue({
+ ...mockUseLatex,
+ contentSource: 'manual',
+ canRegenerateFromSelections: false,
+ contentModified: false,
+ handleCompileOnly: handleCompileOnlyMock,
+ handlePreview: handlePreviewMock,
+ });
+
+ useFormulas.mockReturnValue({
+ ...mockUseFormulas,
+ selectedCount: 1,
+ getSelectedFormulasList: vi.fn().mockReturnValueOnce(firstSelection).mockReturnValueOnce(secondSelection),
+ });
+
+ const { rerender } = render(
);
+
+ fireEvent.click(screen.getByRole('button', { name: /Compile PDF/i }));
+
+ rerender(
);
+
+ fireEvent.click(screen.getByRole('button', { name: /Compile PDF/i }));
+
+ expect(handlePreviewMock).toHaveBeenCalledTimes(2);
+ expect(handlePreviewMock).toHaveBeenNthCalledWith(2, null, expect.objectContaining({ formulas: secondSelection }));
+ expect(handleCompileOnlyMock).not.toHaveBeenCalled();
+ });
+
it('does not overwrite compiled manual LaTeX on later compile clicks', () => {
const handleCompileOnlyMock = vi.fn();
const handlePreviewMock = vi.fn();
@@ -196,6 +320,69 @@ describe('CreateCheatSheet Component', () => {
expect(handleCompileOnlyMock).toHaveBeenCalledWith(selectedFormulas);
});
+ it('compiles on Ctrl+Enter and prevents the browser default action', () => {
+ const handlePreviewMock = vi.fn();
+ const selectedFormulas = [{ name: 'test' }];
+
+ useLatex.mockReturnValue({ ...mockUseLatex, handlePreview: handlePreviewMock });
+ useFormulas.mockReturnValue({
+ ...mockUseFormulas,
+ selectedCount: 1,
+ getSelectedFormulasList: vi.fn().mockReturnValue(selectedFormulas),
+ });
+
+ render(
);
+
+ const shortcutEvent = new window.KeyboardEvent('keydown', {
+ key: 'Enter',
+ ctrlKey: true,
+ bubbles: true,
+ cancelable: true,
+ });
+
+ window.dispatchEvent(shortcutEvent);
+
+ expect(shortcutEvent.defaultPrevented).toBe(true);
+ expect(handlePreviewMock).toHaveBeenCalledWith(null, expect.objectContaining({ formulas: selectedFormulas }));
+ });
+
+ it('saves on Ctrl+S and prevents the browser default action', async () => {
+ const onSave = vi.fn().mockResolvedValue(undefined);
+
+ render(
);
+
+ const shortcutEvent = new window.KeyboardEvent('keydown', {
+ key: 's',
+ ctrlKey: true,
+ bubbles: true,
+ cancelable: true,
+ });
+
+ window.dispatchEvent(shortcutEvent);
+
+ expect(shortcutEvent.defaultPrevented).toBe(true);
+ await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+ });
+
+ it('ignores repeated shortcut keydown events', async () => {
+ const onSave = vi.fn().mockResolvedValue(undefined);
+
+ render(
);
+
+ const repeatedShortcutEvent = new window.KeyboardEvent('keydown', {
+ key: 's',
+ ctrlKey: true,
+ bubbles: true,
+ cancelable: true,
+ repeat: true,
+ });
+
+ window.dispatchEvent(repeatedShortcutEvent);
+
+ await waitFor(() => expect(onSave).toHaveBeenCalledTimes(0));
+ expect(repeatedShortcutEvent.defaultPrevented).toBe(false);
+ });
+
it('can open youtube resources when class is selected', () => {
const mockDataWithClass = {
...mockUseFormulas,
@@ -403,4 +590,4 @@ describe('CreateCheatSheet Component', () => {
expect(mockClearSelections).toHaveBeenCalled();
expect(mockReset).toHaveBeenCalled();
});
-});
\ No newline at end of file
+});
diff --git a/frontend/src/data/subjectVideos.js b/frontend/src/data/subjectVideos.js
index e6da17f..96b49ba 100644
--- a/frontend/src/data/subjectVideos.js
+++ b/frontend/src/data/subjectVideos.js
@@ -581,6 +581,47 @@ export const CURATED_SUBJECT_VIDEOS = {
},
],
+ "LINEAR ALGEBRA I": [
+ {
+ title: "Introduction to Vectors and Their Operations",
+ videoId: "KBSCMTYaH1s",
+ channel: "Professor Dave Explains",
+ topic: "Vector Basics"
+ },
+ {
+ title: "Linear Algebra - Matrix Operations",
+ videoId: "p48uw2vFWQs",
+ channel: "Postcard Professor",
+ topic: "Matrix Operations"
+ },
+ {
+ title: "Cramer's Rule - 2x2 Linear System",
+ videoId: "vXqlIOX2itM",
+ channel: "The Organic Chemistry Tutor",
+ topic: "2x2 Systems"
+ },
+ ],
+ "LINEAR ALGEBRA II": [
+ {
+ title: "Linear Algebra: Properties of Matrix Operations - Part 1 (Section 2.2) | Math with Professor V",
+ videoId: "pqhI8RCNkZk",
+ channel: "Math With Professor V",
+ topic: "Matrix Properties"
+ },
+ {
+ title: "Eigenvectors and eigenvalues | Chapter 14, Essence of linear algebra",
+ videoId: "PFDu9oVAE-g",
+ channel: "3Blue1Brown",
+ topic: "Eigenvalues & Eigenvectors"
+ },
+ {
+ title: "Further Matrix Decompositions: LU, Cholesky, QR, and SVD",
+ videoId: "wHAJzemKQW4",
+ channel: "Professor Dave Explains",
+ topic: "Decompositions & Spaces",
+ },
+ ],
+
};
const YOUTUBE_HOSTS = new Set(['youtube.com', 'www.youtube.com', 'm.youtube.com', 'youtu.be']);
diff --git a/frontend/src/hooks/formulas.js b/frontend/src/hooks/formulas.js
index 52261dc..6c133bb 100644
--- a/frontend/src/hooks/formulas.js
+++ b/frontend/src/hooks/formulas.js
@@ -252,6 +252,45 @@ export function useFormulas(initialData) {
});
};
+ const selectAllClasses = useCallback(() => {
+ const nextSelectedClasses = {};
+ const nextSelectedCategories = {};
+ const nextGroupedFormulas = [];
+
+ classesData.forEach((cls) => {
+ nextSelectedClasses[cls.name] = true;
+
+ const formulasForClass = [];
+ cls.categories?.forEach((category) => {
+ nextSelectedCategories[`${cls.name}:${category.name}`] = true;
+ category.formulas?.forEach((formula) => {
+ formulasForClass.push({
+ class: cls.name,
+ category: category.name,
+ name: formula.name,
+ });
+ });
+ });
+
+ if (formulasForClass.length > 0) {
+ nextGroupedFormulas.push({
+ class: cls.name,
+ formulas: formulasForClass,
+ });
+ }
+ });
+
+ setSelectedClasses(nextSelectedClasses);
+ setSelectedCategories(nextSelectedCategories);
+ setGroupedFormulas(nextGroupedFormulas);
+ }, [classesData]);
+
+ const deselectAllClasses = useCallback(() => {
+ setSelectedClasses({});
+ setSelectedCategories({});
+ setGroupedFormulas([]);
+ }, []);
+
const reorderClass = useCallback((oldIndex, newIndex) => {
setGroupedFormulas(prev => {
const newOrder = [...prev];
@@ -300,6 +339,8 @@ export function useFormulas(initialData) {
reorderFormula,
removeClassFromOrder,
removeSingleFormula,
+ selectAllClasses,
+ deselectAllClasses,
selectedCount,
hasSelectedClasses
};
diff --git a/frontend/src/hooks/formulas.test.js b/frontend/src/hooks/formulas.test.js
index 1802a71..2dfd52c 100644
--- a/frontend/src/hooks/formulas.test.js
+++ b/frontend/src/hooks/formulas.test.js
@@ -139,4 +139,32 @@ describe('useFormulas hook', () => {
expect(result.current.selectedCount).toBe(4);
});
+
+ it('selects and deselects all classes in a single action', async () => {
+ const { result } = renderHook(() => useFormulas());
+
+ await vi.waitFor(() => {
+ expect(result.current.classesData.length).toBeGreaterThan(0);
+ });
+
+ act(() => {
+ result.current.selectAllClasses();
+ });
+
+ expect(result.current.selectedClasses.Algebra).toBe(true);
+ expect(result.current.selectedClasses.Geometry).toBe(true);
+ expect(result.current.selectedCategories['Algebra:Linear Equations']).toBe(true);
+ expect(result.current.selectedCategories['Algebra:Quadratics']).toBe(true);
+ expect(result.current.selectedCategories['Geometry:Shapes']).toBe(true);
+ expect(result.current.selectedCount).toBe(4);
+
+ act(() => {
+ result.current.deselectAllClasses();
+ });
+
+ expect(result.current.selectedClasses).toEqual({});
+ expect(result.current.selectedCategories).toEqual({});
+ expect(result.current.groupedFormulas).toEqual([]);
+ expect(result.current.selectedCount).toBe(0);
+ });
});