⚡ Bolt: Optimize array accumulation in useSchedule

[anyulled]

💡 What: Replaced array spreading inside an iteration loop with array push() during schedule accumulation.
🎯 Why: Array spreading within loops creates intermediate arrays on each iteration resulting in O(N^2) complexity and significant garbage collection overhead. In a time slot with many sessions, this becomes inefficient. Mutating an existing array with .push() brings this back to O(N) amortized time complexity, and avoids allocating many short-lived objects.
📊 Impact: Array accumulation inside grouping loop is now O(N) instead of O(N^2), removing unnecessary object duplication and reducing memory pressure during generation of schedule views.
🔬 Measurement: Verify tests under __tests__/property/useSchedule.test.ts and __tests__/hooks-useSchedule.test.ts still pass. Check that the schedule renders correctly.

---

PR created automatically by Jules for task 1891322684436265472 started by @anyulled

Summary by CodeRabbit

• Refactor
  • Optimized internal schedule grouping logic for improved performance with no user-facing changes.

[google-labs-jules]

👋 Jules, reporting for duty! I'm here to lend a hand with this pull request.

When you start a review, I'll add a 👀 emoji to each comment to let you know I've read it. I'll focus on feedback directed at me and will do my best to stay out of conversations between you and other bots or reviewers to keep the noise down.

I'll push a commit with your requested changes shortly after. Please note there might be a delay between these steps, but rest assured I'm on the job!

For more direct control, you can switch me to Reactive Mode. When this mode is on, I will only act on comments where you specifically mention me with @jules. You can find this option in the Pull Request section of your global Jules UI settings. You can always switch back!

New to Jules? Learn more at jules.google/docs.

---

For security, I will only act on instructions from the user who triggered this task.

[qodo-code-review]

Review Summary by Qodo

Optimize array accumulation in useSchedule hook

✨ Enhancement

Walkthroughs

Description

• Optimize array accumulation from O(N²) to O(N) complexity
• Replace array spreading with in-place push mutation
• Reduce garbage collection overhead in schedule grouping
• Improve performance for time slots with many sessions

Diagram

flowchart LR
  A["Array spreading<br/>O(N²) complexity"] -->|"Replace with"| B["In-place push<br/>O(N) complexity"]
  B -->|"Result"| C["Reduced memory<br/>pressure & GC"]

Loading

File Changes

1. hooks/useSchedule.ts ✨ Enhancement +8/-2

Optimize session accumulation with in-place mutation

• Replaced array spreading ([...existing, session]) with in-place push() mutation
• Added conditional check to initialize new array only when timeKey doesn't exist
• Eliminated intermediate array creation on each iteration
• Added explanatory comment about O(N²) overhead prevention

hooks/useSchedule.ts

---

[qodo-code-review]

Code Review by Qodo

🐞 Bugs (0) 📘 Rule violations (0) 📎 Requirement gaps (0)

Great, no issues found!

Qodo reviewed your code and found no material issues that require review

ⓘ The new review experience is currently in Beta. Learn more

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: b0ea0972-041c-4665-ae8e-83ef4dd8fc90

📥 Commits

Reviewing files that changed from the base of the PR and between 72509ae and 081a5d0.

📒 Files selected for processing (1)

• hooks/useSchedule.ts

---

📝 Walkthrough

Walkthrough

The getSchedule function's session grouping logic was refactored from using array spreading and .set() to using in-place .push() mutations. When grouping sessions by time, it now initializes the map entry directly or appends to the existing array rather than creating new arrays on each iteration.

Changes

Cohort / File(s)	Summary
Session Grouping Optimization hooks/useSchedule.ts	Refactored session-to-time grouping from functional approach (array spreading with .set()) to imperative approach (.push() mutations). Performance optimization that maintains identical external behavior.

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~8 minutes

Possibly related PRs

• ⚡ Bolt: Add React.cache to getSchedule hook #24 — Also modifies getSchedule in the same file; one changes grouping logic while the other wraps it with React.cache.
• ⚡ Bolt: Optimize talk grouping performance #105 — Both PRs eliminate per-iteration array spreading in hot-path logic in favor of in-place accumulation with .push().

Poem

🐰 Hops with delight
No more spreading arrays wide,
Push and mutate, take a ride!
Sessions grouped by time so true,
Less copying makes us hop anew! 🎉

🚥 Pre-merge checks | ✅ 3

✅ Passed checks (3 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title accurately captures the main optimization change: replacing array spreading with push() for better performance in the useSchedule hook's array accumulation logic.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch bolt/optimize-useSchedule-array-accumulation-1891322684436265472

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[gemini-code-assist]

Code Review

This pull request optimizes the session grouping logic in hooks/useSchedule.ts by replacing array spreading with in-place mutation. This change improves performance by avoiding O(N^2) overhead when processing multiple sessions for the same time key. I have no feedback to provide as there were no review comments.