Hi,

This is very interesting! Thanks for implementing.

This changes the behavior of the default compactor, does it not? Or are the results the same and this is purely performance?

Additionally, can you see this being implemented horizontally too, and if so, can we remove a bunch of old code? I would be very happy with that.

Hi!

This changes the behavior of the default compactor

I think it does, but hopefully only in subtle ways (weird edge cases). I'll try to quantify this with some tests, let me get back to you.

can you see this being implemented horizontally too

I haven't tried, but I suspect horizontal compaction needs a different approach. While grids can grow vertically indefinitely, the number of columns is constant, so it looks like a (slightly?) separate problem. I'm thinking t might be safer to take it on separately 🤔 would you see this as a show stopper for this PR?

I don't want to leave the code base with a lot of dead code, so it's fairly high priority. I think this is a measurable improvement and the change is actually easier to read, so I'm excited about what it might bring.

I've added two minimal tests illustrating differences in behavior. The first one produces a more compact layout, the second one produces a less compact result (which may be considered a regression) than current master. I think the input layouts are a bit ambiguous though, so not sure if either behavior is "better" or "worse".

Running some randomized tests (roughly same inputs from the new fuzzy tests), I've found the new compaction algorithm to produce equivalent layouts for about 65-75% of inputs. This may be indeed too much of a deviation.

However, I think it comes down more to the user experience while moving items: Does the layout change in unexpected/unintended ways while dragging and dropping? Regarding that, I'm fairly confident it works well (if not better):

In the end, it's your call of course :) let me know if you think the changed behavior is good enough. I might take a stab at horizontal compaction in that case

Playing with it more, I found the algorithm to be surprisingly powerful as it can support manipulation (move/resize) as well by applying the manipulation, sorting cleverly, and using compaction as a repair step.

I was able to implement a RGL alternative that's more opinionated (less options, e.g. no horizontal compaction) but much, much faster, based on it: https://github.com/morris/fast-grid-layout - may be interesting for you as well :)

That's pretty cool @morris. I'll spend some time with this again.

I'm a performance junkie and you really whipped my butt with this one.

Auto code review

No issues found. Checked for bugs and CLAUDE.md compliance.

Note: This PR was created before the v2 TypeScript rewrite and targets the legacy lib/utils.js codebase. The master branch has since been updated to v2 with TypeScript in src/core/. To merge this performance improvement, the changes would need to be rebased and reimplemented in src/core/compactors.ts.

🤖 Generated with Claude Code

_{- If this code review was useful, please react with 👍. Otherwise, react with 👎.}

Ok this is pretty good.

┌───────────────────────────────────────────────────────────────────────────┐
│                    ⚡ Compactor Performance Comparison                     │
├───────────────────────────────────────────────────────────────────────────┤
│ Items    │ Standard Vertical     │ Fast Vertical         │ Speedup        │
├──────────┼───────────────────────┼───────────────────────┼────────────────┤
│ 50       │             105.03 µs │              17.77 µs │   5.91x faster │
│ 100      │             261.62 µs │              36.20 µs │   7.23x faster │
│ 200      │             928.55 µs │              55.97 µs │  16.59x faster │
│ 500      │               6.56 ms │             141.10 µs │  46.46x faster │
└───────────────────────────────────────────────────────────────────────────┘

This algorithm has been migrated to the v2 TypeScript architecture in #2184. Thanks for the contribution @morris.