🎯 Mini-Project: Task Manager

Data Structure Requirements

• Tasks must have: id, title, description, status, priority, created date, due date (optional), tags
• Status can be: pending, in-progress, completed, cancelled
• Priority can be: low, medium, high, urgent
• Tags are strings that categorize tasks

Functionality Requirements

• Create new tasks with all required fields
• Update existing tasks (partial updates allowed)
• Delete tasks by ID
• Get a task by ID
• Get all tasks
• Filter tasks by status, priority, or tags
• Sort tasks by different criteria
• Calculate statistics (total, by status, by priority)
• Validate task data

🎨 Interactive: Task Data Structure

Explore the Task interface structure. Click on each property to see its type and purpose:

✅ Success Criteria

Your project is complete when:

• All TypeScript code compiles without errors
• All functions have proper type annotations
• Type guards are used for runtime validation
• Generic functions work with proper type inference
• Utility types are used appropriately
• All test cases pass

🏋️ Task: Create Status and Priority Types

Create type aliases for Status and Priority using union types with literal values.

// TODO: Define Status type
// Should include: "pending", "in-progress", "completed", "cancelled"

// TODO: Define Priority type
// Should include: "low", "medium", "high", "urgent"

// Test your types:
const status1: Status = "pending";        // ✅ Should work
const status2: Status = "in-progress";    // ✅ Should work
// const status3: Status = "invalid";     // ❌ Should error

const priority1: Priority = "low";        // ✅ Should work
const priority2: Priority = "urgent";     // ✅ Should work
// const priority3: Priority = "invalid";  // ❌ Should error

type Status = "pending" | "in-progress" | "completed" | "cancelled";
type Priority = "low" | "medium" | "high" | "urgent";

🏋️ Task: Create the Task Interface

Create an interface that represents a task with all necessary properties.

// TODO: Define Task interface
// Required properties:
// - id: string
// - title: string
// - description: string
// - status: Status (use the type you created)
// - priority: Priority (use the type you created)
// - createdAt: Date
// - tags: array of strings
// Optional properties:
// - dueDate: Date

// Test your interface:
const task: Task = {
    id: "task-1",
    title: "Learn TypeScript",
    description: "Complete all TypeScript lessons",
    status: "in-progress",
    priority: "high",
    createdAt: new Date(),
    tags: ["learning", "typescript"],
    dueDate: new Date("2024-12-31")
};

interface Task {
    id: string;
    title: string;
    description: string;
    status: Status;
    priority: Priority;
    createdAt: Date;
    dueDate?: Date;
    tags: string[];
}

🏋️ Task: Create TaskInput and TaskUpdate Types

Create types for creating new tasks and updating existing ones.

// TODO: Define TaskInput type
// This should be the Task interface WITHOUT id and createdAt
// (since these are generated by the system)
// Hint: Use the Omit utility type

// TODO: Define TaskUpdate type
// This should allow partial updates to a Task
// (all fields optional except id)
// Hint: Use Partial and Pick utility types

// Test your types:
const newTask: TaskInput = {
    title: "New Task",
    description: "Task description",
    status: "pending",
    priority: "medium",
    tags: []
    // ✅ No id or createdAt needed
};

const taskUpdate: TaskUpdate = {
    id: "task-1",
    status: "completed"
    // ✅ Only updating status, other fields optional
};

type TaskInput = Omit<Task, "id" | "createdAt">;

type TaskUpdate = Pick<Task, "id"> & Partial<Omit<Task, "id">>;

🏋️ Task: Create FilterOptions and SortField Types

// TODO: Define FilterOptions interface
// Optional properties for filtering:
// - status: Status
// - priority: Priority
// - tags: string array
// - completed: boolean (to filter completed/incomplete tasks)

// TODO: Define SortField type
// Union of fields we can sort by: "createdAt", "dueDate", "priority", "title"

// TODO: Define SortOrder type
// Union of: "asc" (ascending) or "desc" (descending)

// Test your types:
const filters: FilterOptions = {
    status: "in-progress",
    priority: "high"
};

const sortBy: SortField = "createdAt";
const sortOrder: SortOrder = "desc";

interface FilterOptions {
    status?: Status;
    priority?: Priority;
    tags?: string[];
    completed?: boolean;
}

type SortField = "createdAt" | "dueDate" | "priority" | "title";
type SortOrder = "asc" | "desc";

🏋️ Task: Create TaskStatistics Interface

// TODO: Define TaskStatistics interface
// Properties:
// - total: number (total tasks)
// - byStatus: Record of Status to number
// - byPriority: Record of Priority to number
// - completed: number
// - overdue: number
// Hint: Use Record<Status, number> for byStatus

// Test your interface:
const stats: TaskStatistics = {
    total: 10,
    byStatus: {
        "pending": 3,
        "in-progress": 4,
        "completed": 2,
        "cancelled": 1
    },
    byPriority: {
        "low": 2,
        "medium": 5,
        "high": 2,
        "urgent": 1
    },
    completed: 2,
    overdue: 1
};

interface TaskStatistics {
    total: number;
    byStatus: Record<Status, number>;
    byPriority: Record<Priority, number>;
    completed: number;
    overdue: number;
}

✅ Type System Complete!

Great work! You've designed a complete type system for the Task Manager. You've used:

• Type aliases with union types (Status, Priority)
• Interfaces (Task, FilterOptions, TaskStatistics)
• Utility types (Omit, Partial, Pick, Record)
• Optional properties
• Type composition with intersection types

🏋️ Task: Create Type Guards

Create type guard functions to validate Status and Priority values at runtime.

// TODO: Create isValidStatus type guard
// Function signature: function isValidStatus(value: any): value is Status
// Should return true if value is a valid Status

// TODO: Create isValidPriority type guard
// Function signature: function isValidPriority(value: any): value is Priority
// Should return true if value is a valid Priority

// Test your type guards:
console.log(isValidStatus("pending"));      // ✅ true
console.log(isValidStatus("invalid"));      // ❌ false
console.log(isValidPriority("high"));       // ✅ true
console.log(isValidPriority("invalid"));    // ❌ false

function isValidStatus(value: any): value is Status {
    return ["pending", "in-progress", "completed", "cancelled"].includes(value);
}

function isValidPriority(value: any): value is Priority {
    return ["low", "medium", "high", "urgent"].includes(value);
}

🏋️ Task: Create Task Validation Function

Create a function to validate a complete Task object.

// TODO: Create validateTask function
// Function signature: function validateTask(task: Task): boolean
// Should check:
// - id is not empty
// - title is not empty
// - description is not empty
// - status is valid (use isValidStatus)
// - priority is valid (use isValidPriority)
// - createdAt is a valid Date
// - tags is an array
// Return true if all checks pass, false otherwise

// Test your validation:
const validTask: Task = {
    id: "task-1",
    title: "Test Task",
    description: "Test Description",
    status: "pending",
    priority: "high",
    createdAt: new Date(),
    tags: ["test"]
};

console.log(validateTask(validTask));  // ✅ true

const invalidTask: Task = {
    id: "",
    title: "",
    description: "Test",
    status: "invalid" as Status,
    priority: "high",
    createdAt: new Date(),
    tags: []
};

console.log(validateTask(invalidTask));  // ❌ false

function validateTask(task: Task): boolean {
    return (
        task.id.trim().length > 0 &&
        task.title.trim().length > 0 &&
        task.description.trim().length > 0 &&
        isValidStatus(task.status) &&
        isValidPriority(task.priority) &&
        task.createdAt instanceof Date &&
        !isNaN(task.createdAt.getTime()) &&
        Array.isArray(task.tags)
    );
}

🏋️ Task: Create TaskManager Class Structure

Create a class with a private tasks array and basic structure.

// TODO: Create TaskManager class
// Private property: tasks (array of Task objects)
// Constructor: initializes empty tasks array
// Private method: generateId() - generates unique IDs (use Date.now() + random number)

class TaskManager {
    // TODO: Add private tasks property
    
    // TODO: Add constructor
    
    // TODO: Add private generateId method
}

// Test your class:
const manager = new TaskManager();
console.log(manager);  // Should create instance successfully

class TaskManager {
    private tasks: Task[] = [];

    constructor() {
        this.tasks = [];
    }

    private generateId(): string {
        return `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
    }
}

🏋️ Task: Implement createTask Method

Add a method to create new tasks.

// TODO: Add createTask method to TaskManager class
// Method signature: createTask(input: TaskInput): Task
// Should:
// 1. Generate a unique id
// 2. Set createdAt to current Date
// 3. Create a Task object with all properties
// 4. Validate the task (throw error if invalid)
// 5. Add to tasks array
// 6. Return the created task

// Add this method to your TaskManager class:
class TaskManager {
    // ... previous code ...

    createTask(input: TaskInput): Task {
        // TODO: Implement this method
    }
}

// Test your method:
const manager = new TaskManager();
const newTask = manager.createTask({
    title: "Learn TypeScript",
    description: "Complete all lessons",
    status: "in-progress",
    priority: "high",
    tags: ["learning"]
});
console.log(newTask);  // Should show task with generated id and createdAt

createTask(input: TaskInput): Task {
    const task: Task = {
        ...input,
        id: this.generateId(),
        createdAt: new Date()
    };

    if (!validateTask(task)) {
        throw new Error("Invalid task data");
    }

    this.tasks.push(task);
    return task;
}

🏋️ Task: Implement Read Methods

Add methods to retrieve tasks.

// TODO: Add these methods to TaskManager class

// Method 1: getTaskById(id: string): Task | undefined
// Should return the task with matching id, or undefined if not found

// Method 2: getAllTasks(): Task[]
// Should return a copy of all tasks (use spread or slice to avoid mutation)

// Method 3: getTaskCount(): number
// Should return the total number of tasks

// Add to your TaskManager class:
class TaskManager {
    // ... previous code ...

    getTaskById(id: string): Task | undefined {
        // TODO: Implement this method
    }

    getAllTasks(): Task[] {
        // TODO: Implement this method
    }

    getTaskCount(): number {
        // TODO: Implement this method
    }
}

// Test your methods:
const task = manager.getTaskById(newTask.id);
console.log(task);  // Should return the task

const allTasks = manager.getAllTasks();
console.log(allTasks);  // Should return array of all tasks

const count = manager.getTaskCount();
console.log(count);  // Should return number of tasks

getTaskById(id: string): Task | undefined {
    return this.tasks.find(task => task.id === id);
}

getAllTasks(): Task[] {
    return [...this.tasks];
}

getTaskCount(): number {
    return this.tasks.length;
}

🏋️ Task: Implement updateTask Method

Add a method to update existing tasks with partial data.

// TODO: Add updateTask method to TaskManager class
// Method signature: updateTask(update: TaskUpdate): Task | undefined
// Should:
// 1. Find the task by id
// 2. If not found, return undefined
// 3. Merge the update with existing task (use spread operator)
// 4. Validate the updated task
// 5. Replace the old task with updated task
// 6. Return the updated task

// Add to your TaskManager class:
class TaskManager {
    // ... previous code ...

    updateTask(update: TaskUpdate): Task | undefined {
        // TODO: Implement this method
    }
}

// Test your method:
const updated = manager.updateTask({
    id: newTask.id,
    status: "completed",
    priority: "medium"
});
console.log(updated);  // Should show task with updated fields

updateTask(update: TaskUpdate): Task | undefined {
    const index = this.tasks.findIndex(task => task.id === update.id);
    
    if (index === -1) {
        return undefined;
    }

    const { id, ...updates } = update;
    const updatedTask: Task = {
        ...this.tasks[index],
        ...updates
    };

    if (!validateTask(updatedTask)) {
        throw new Error("Invalid task data");
    }

    this.tasks[index] = updatedTask;
    return updatedTask;
}

🏋️ Task: Implement deleteTask Method

Add a method to delete tasks by ID.

// TODO: Add deleteTask method to TaskManager class
// Method signature: deleteTask(id: string): boolean
// Should:
// 1. Find the task by id
// 2. If found, remove it from the array
// 3. Return true if deleted, false if not found

// Add to your TaskManager class:
class TaskManager {
    // ... previous code ...

    deleteTask(id: string): boolean {
        // TODO: Implement this method
    }
}

// Test your method:
const deleted = manager.deleteTask(newTask.id);
console.log(deleted);  // Should return true

const deletedAgain = manager.deleteTask(newTask.id);
console.log(deletedAgain);  // Should return false (already deleted)

deleteTask(id: string): boolean {
    const index = this.tasks.findIndex(task => task.id === id);
    
    if (index === -1) {
        return false;
    }

    this.tasks.splice(index, 1);
    return true;
}

✅ Core CRUD Operations Complete!

Excellent work! You've implemented all the basic CRUD operations:

• Create: createTask() with validation
• Read: getTaskById(), getAllTasks(), getTaskCount()
• Update: updateTask() with partial updates using Partial<T>
• Delete: deleteTask() with boolean return

You've used type guards, utility types (Partial, Omit), proper return types, and error handling!

🎨 Interactive: CRUD Operations Simulator

Watch how each CRUD operation works with tasks. Click buttons to simulate operations:

Click an operation to see it in action

🏋️ Task: Implement filterTasks Method

Create a method to filter tasks based on various criteria.

// TODO: Add filterTasks method to TaskManager class
// Method signature: filterTasks(filters: FilterOptions): Task[]
// Should filter tasks based on:
// - status (if provided)
// - priority (if provided)
// - tags (if provided - task must have ALL specified tags)
// - completed (if provided - true returns only completed, false returns non-completed)
// Return array of matching tasks

// Add to your TaskManager class:
class TaskManager {
    // ... previous code ...

    filterTasks(filters: FilterOptions): Task[] {
        // TODO: Implement this method
    }
}

// Test your method:
const highPriorityTasks = manager.filterTasks({ priority: "high" });
console.log(highPriorityTasks);

const inProgressTasks = manager.filterTasks({ status: "in-progress" });
console.log(inProgressTasks);

const completedHighPriority = manager.filterTasks({ 
    status: "completed", 
    priority: "high" 
});
console.log(completedHighPriority);

filterTasks(filters: FilterOptions): Task[] {
    return this.tasks.filter(task => {
        // Filter by status
        if (filters.status && task.status !== filters.status) {
            return false;
        }

        // Filter by priority
        if (filters.priority && task.priority !== filters.priority) {
            return false;
        }

        // Filter by tags (task must have ALL specified tags)
        if (filters.tags && filters.tags.length > 0) {
            const hasAllTags = filters.tags.every(tag => 
                task.tags.includes(tag)
            );
            if (!hasAllTags) {
                return false;
            }
        }

        // Filter by completed status
        if (filters.completed !== undefined) {
            const isCompleted = task.status === "completed";
            if (isCompleted !== filters.completed) {
                return false;
            }
        }

        return true;
    });
}

🏋️ Task: Implement sortTasks Method

Create a method to sort tasks by different fields.

// TODO: Add sortTasks method to TaskManager class
// Method signature: sortTasks(tasks: Task[], field: SortField, order: SortOrder = "asc"): Task[]
// Should:
// 1. Sort tasks by the specified field
// 2. Handle ascending and descending order
// 3. Handle Date fields (createdAt, dueDate)
// 4. Handle string fields (title)
// 5. Handle priority (treat as: low < medium < high < urgent)
// 6. Return a NEW sorted array (don't mutate original)

// Add to your TaskManager class:
class TaskManager {
    // ... previous code ...

    sortTasks(tasks: Task[], field: SortField, order: SortOrder = "asc"): Task[] {
        // TODO: Implement this method
        // Hint: Create a copy first with [...tasks]
        // Hint: For priority, create a priority order map
    }
}

// Test your method:
const allTasks = manager.getAllTasks();
const sortedByDate = manager.sortTasks(allTasks, "createdAt", "desc");
console.log(sortedByDate);

const sortedByPriority = manager.sortTasks(allTasks, "priority", "desc");
console.log(sortedByPriority);

sortTasks(tasks: Task[], field: SortField, order: SortOrder = "asc"): Task[] {
    const priorityOrder: Record<Priority, number> = {
        "low": 0,
        "medium": 1,
        "high": 2,
        "urgent": 3
    };

    const sortedTasks = [...tasks].sort((a, b) => {
        let comparison = 0;

        switch (field) {
            case "createdAt":
            case "dueDate":
                const dateA = field === "createdAt" ? a.createdAt : (a.dueDate || new Date(0));
                const dateB = field === "createdAt" ? b.createdAt : (b.dueDate || new Date(0));
                comparison = dateA.getTime() - dateB.getTime();
                break;

            case "priority":
                comparison = priorityOrder[a.priority] - priorityOrder[b.priority];
                break;

            case "title":
                comparison = a.title.localeCompare(b.title);
                break;
        }

        return order === "asc" ? comparison : -comparison;
    });

    return sortedTasks;
}

🏋️ Task: Implement getStatistics Method

Create a method to calculate task statistics.

// TODO: Add getStatistics method to TaskManager class
// Method signature: getStatistics(): TaskStatistics
// Should calculate:
// - total: total number of tasks
// - byStatus: count of tasks for each status
// - byPriority: count of tasks for each priority
// - completed: number of completed tasks
// - overdue: number of tasks past their due date (if dueDate exists and is past)

// Add to your TaskManager class:
class TaskManager {
    // ... previous code ...

    getStatistics(): TaskStatistics {
        // TODO: Implement this method
        // Hint: Use reduce() to build the byStatus and byPriority objects
    }
}

// Test your method:
const stats = manager.getStatistics();
console.log(stats);
// Should show object with all statistics

getStatistics(): TaskStatistics {
    const now = new Date();

    const byStatus: Record<Status, number> = {
        "pending": 0,
        "in-progress": 0,
        "completed": 0,
        "cancelled": 0
    };

    const byPriority: Record<Priority, number> = {
        "low": 0,
        "medium": 0,
        "high": 0,
        "urgent": 0
    };

    let completed = 0;
    let overdue = 0;

    this.tasks.forEach(task => {
        byStatus[task.status]++;
        byPriority[task.priority]++;

        if (task.status === "completed") {
            completed++;
        }

        if (
            task.dueDate &&
            task.dueDate < now &&
            task.status !== "completed" &&
            task.status !== "cancelled"
        ) {
            overdue++;
        }
    });

    return {
        total: this.tasks.length,
        byStatus,
        byPriority,
        completed,
        overdue
    };
}

🏋️ Task: Implement Generic Search Method

Create a generic search method that can search any field.

// TODO: Add searchTasks method to TaskManager class
// Method signature: searchTasks<K extends keyof Task>(field: K, value: Task[K]): Task[]
// This is a GENERIC method that can search any field of a task
// Should return tasks where the field matches the value

// Add to your TaskManager class:
class TaskManager {
    // ... previous code ...

    searchTasks<K extends keyof Task>(field: K, value: Task[K]): Task[] {
        // TODO: Implement this method
    }
}

// Test your method:
const tasksByTitle = manager.searchTasks("title", "Learn TypeScript");
console.log(tasksByTitle);

const tasksByStatus = manager.searchTasks("status", "in-progress");
console.log(tasksByStatus);

const tasksByPriority = manager.searchTasks("priority", "high");
console.log(tasksByPriority);

searchTasks<K extends keyof Task>(field: K, value: Task[K]): Task[] {
    return this.tasks.filter(task => task[field] === value);
}

✅ Advanced Features Complete!

Outstanding! You've implemented all advanced features:

• Filtering: Complex multi-criteria filtering
• Sorting: Sort by multiple fields with ascending/descending order
• Statistics: Comprehensive analytics with Record types
• Generic Search: Type-safe search using generics with keyof

You've mastered: Generics, Record types, keyof operator, and complex array operations!

🎨 Interactive: Statistics Dashboard

See how the getStatistics() method calculates task metrics. Click to add sample tasks and watch the stats update:

🏋️ Task: Create Test Suite

Create a function that runs all tests and reports results.

// TODO: Create a test function
function testTaskManager(): void {
    console.log("🧪 Starting Task Manager Tests...\n");

    const manager = new TaskManager();

    // Test 1: Create tasks
    console.log("Test 1: Creating tasks...");
    const task1 = manager.createTask({
        title: "Learn TypeScript Basics",
        description: "Complete lessons 1-3",
        status: "completed",
        priority: "high",
        tags: ["learning", "typescript"]
    });
    console.log("✅ Task 1 created:", task1.id);

    const task2 = manager.createTask({
        title: "Build Task Manager",
        description: "Complete mini-project",
        status: "in-progress",
        priority: "urgent",
        tags: ["project", "typescript"],
        dueDate: new Date("2024-12-31")
    });
    console.log("✅ Task 2 created:", task2.id);

    const task3 = manager.createTask({
        title: "Review React Concepts",
        description: "Prepare for Module 2",
        status: "pending",
        priority: "medium",
        tags: ["learning", "react"]
    });
    console.log("✅ Task 3 created:", task3.id);

    // Test 2: Get tasks
    console.log("\nTest 2: Retrieving tasks...");
    const allTasks = manager.getAllTasks();
    console.log(`✅ Total tasks: ${allTasks.length}`);

    const foundTask = manager.getTaskById(task1.id);
    console.log(`✅ Found task: ${foundTask?.title}`);

    // Test 3: Update task
    console.log("\nTest 3: Updating task...");
    const updated = manager.updateTask({
        id: task3.id,
        status: "in-progress",
        priority: "high"
    });
    console.log(`✅ Updated task: ${updated?.title} - Status: ${updated?.status}`);

    // Test 4: Filter tasks
    console.log("\nTest 4: Filtering tasks...");
    const highPriority = manager.filterTasks({ priority: "high" });
    console.log(`✅ High priority tasks: ${highPriority.length}`);

    const inProgress = manager.filterTasks({ status: "in-progress" });
    console.log(`✅ In-progress tasks: ${inProgress.length}`);

    const learningTasks = manager.filterTasks({ tags: ["learning"] });
    console.log(`✅ Learning tasks: ${learningTasks.length}`);

    // Test 5: Sort tasks
    console.log("\nTest 5: Sorting tasks...");
    const sortedByPriority = manager.sortTasks(allTasks, "priority", "desc");
    console.log(`✅ Sorted by priority (desc):`, 
        sortedByPriority.map(t => `${t.title} (${t.priority})`).join(", "));

    // Test 6: Statistics
    console.log("\nTest 6: Getting statistics...");
    const stats = manager.getStatistics();
    console.log("✅ Statistics:");
    console.log(`   Total: ${stats.total}`);
    console.log(`   Completed: ${stats.completed}`);
    console.log(`   By Status:`, stats.byStatus);
    console.log(`   By Priority:`, stats.byPriority);

    // Test 7: Generic search
    console.log("\nTest 7: Generic search...");
    const urgentTasks = manager.searchTasks("priority", "urgent");
    console.log(`✅ Urgent tasks: ${urgentTasks.length}`);

    // Test 8: Delete task
    console.log("\nTest 8: Deleting task...");
    const deleted = manager.deleteTask(task1.id);
    console.log(`✅ Task deleted: ${deleted}`);
    console.log(`✅ Remaining tasks: ${manager.getTaskCount()}`);

    console.log("\n🎉 All tests completed!");
}

// Run the tests
testTaskManager();

🧪 Starting Task Manager Tests...

Test 1: Creating tasks...
✅ Task 1 created: task-1234567890-abc123
✅ Task 2 created: task-1234567891-def456
✅ Task 3 created: task-1234567892-ghi789

Test 2: Retrieving tasks...
✅ Total tasks: 3
✅ Found task: Learn TypeScript Basics

Test 3: Updating task...
✅ Updated task: Review React Concepts - Status: in-progress

Test 4: Filtering tasks...
✅ High priority tasks: 2
✅ In-progress tasks: 2
✅ Learning tasks: 2

Test 5: Sorting tasks...
✅ Sorted by priority (desc): Build Task Manager (urgent), Learn TypeScript Basics (high), Review React Concepts (high)

Test 6: Getting statistics...
✅ Statistics:
   Total: 3
   Completed: 1
   By Status: { pending: 0, 'in-progress': 2, completed: 1, cancelled: 0 }
   By Priority: { low: 0, medium: 0, high: 2, urgent: 1 }

Test 7: Generic search...
✅ Urgent tasks: 1

Test 8: Deleting task...
✅ Task deleted: true
✅ Remaining tasks: 2

🎉 All tests completed!

⚠️ Common Issues to Check

• Type errors: Make sure all functions have proper type annotations
• Validation: Ensure tasks are validated before being added/updated
• Immutability: Array methods like sort() should return new arrays, not mutate originals
• Edge cases: Handle missing tasks (undefined returns), empty arrays, etc.
• Date handling: Make sure dates are properly compared for overdue tasks

✅ What You've Accomplished

In this project, you successfully applied:

• ✅ Type Aliases - Status, Priority, SortField, SortOrder
• ✅ Interfaces - Task, FilterOptions, TaskStatistics
• ✅ Union Types - Literal string unions for Status and Priority
• ✅ Utility Types - Omit, Partial, Pick, Record
• ✅ Type Guards - isValidStatus, isValidPriority, custom validation
• ✅ Generics - Generic search method with keyof
• ✅ Optional Properties - dueDate in Task
• ✅ Type-safe Functions - All parameters and returns properly typed
• ✅ Array Methods - filter, sort, map, find, every
• ✅ Classes - TaskManager with private properties and methods

Goal: Add support for task dependencies - tasks that must be completed before others can start.

• Add a dependsOn property (array of task IDs)
• Create a method to check if a task's dependencies are satisfied
• Prevent starting tasks with unsatisfied dependencies
• Create a method to get the dependency chain

Goal: Track the history of changes to each task.

• Add a history property (array of change records)
• Record what changed, when, and what the previous value was
• Create a method to get the full history of a task
• Create a method to undo the last change

Goal: Add support for nested subtasks.

• Add a subtasks property (array of Tasks)
• Create methods to add/remove subtasks
• Update statistics to include subtask counts
• Calculate completion percentage based on subtasks

Goal: Save and load tasks from localStorage.

• Create a save() method to persist tasks
• Create a load() method to restore tasks
• Handle Date serialization/deserialization
• Add auto-save functionality

Goal: Add more sophisticated filtering options.

• Date range filtering (created between X and Y)
• Text search in title/description
• Regex pattern matching
• Compound filters with AND/OR logic

Goal: Add methods for bulk operations.

• bulkUpdate(ids: string[], updates: Partial<Task>)
• bulkDelete(ids: string[])
• bulkStatusChange(ids: string[], status: Status)
• Return results with success/failure for each operation

🎉 Congratulations on Completing Module 1!

You've built a complete, type-safe Task Manager application from scratch. This project showcases your mastery of TypeScript fundamentals:

• 📝 Designed a comprehensive type system
• 🔒 Implemented type guards for runtime safety
• ⚙️ Created all CRUD operations with proper typing
• 🔍 Built advanced filtering and sorting
• 📊 Calculated statistics with Record types
• 🎁 Used generics for flexible, reusable code

Take a moment to reflect on your learning:

• Which TypeScript feature surprised you the most?
• What was the most challenging part of this project?
• How do type guards improve code safety?
• When would you use generics vs. union types?
• How did utility types save you time?

Make sure you understand these key concepts:

• ☑️ The difference between type aliases and interfaces
• ☑️ How union types represent "OR" logic
• ☑️ How intersection types represent "AND" logic
• ☑️ When and how to use type guards
• ☑️ How generics enable reusable, type-safe code
• ☑️ Common utility types (Partial, Pick, Omit, Record)
• ☑️ How to use conditional types
• ☑️ Template literal types for string patterns

Coming in Module 2:

• 🎨 Introduction to React - Components, JSX, and the virtual DOM
• 📦 JSX and TSX - Typed templates with full TypeScript support
• 🧩 Components and Props - Building reusable, type-safe components
• 💅 Styling in React - CSS modules, styled-components, and Tailwind
• ⚡ Events in React - Typed event handlers and synthetic events
• 🎯 Module Project - Build a portfolio website with React + TypeScript!

🎊 Module 1 Complete!

You've mastered TypeScript fundamentals and built a real application. You're now ready to bring these skills into React development!

Take a break, celebrate your achievement, and get ready for React! 🚀