The-Adult-In-The-Room/poe2-tools — poe2-tools: A Path of Exile 2 DPS Calculator
The-Adult-In-The-Room/poe2-tools ·
Transcript
QuickFacts
Let's explore poe2-tools, a focused calculator built for Path of Exile 2 players. This tool helps you figure out weapon damage-per-second by reading stats straight from the game. It's a solo project with impressive attention to quality—modern React, TypeScript, and testing discipline throughout.
PlainEnglish
Here's what this tool does. Path of Exile 2 shows you damage ranges like twelve to fifteen physical, three to eight fire—but it doesn't calculate the actual damage per second. This app fills that gap. You hover over a weapon in-game, press control-C, paste into the tool, and instantly see your total DPS broken down by damage type. There's also a history sidebar so you can compare multiple weapons without writing anything down. Everything runs in your browser—no server needed.
QuickFacts
Let's look at the tech stack. On the UI side, it's React nineteen—the latest version—with TypeScript for type safety and CSS modules for styling. For the build pipeline, Parcel handles bundling with zero config, and Vitest runs tests with strict coverage thresholds. The developer also set up pre-commit hooks with ESLint and Prettier, so every commit gets quality-checked automatically. It's a modern, disciplined setup.
Architecture
The architecture follows atomic design principles. The HTML mounts the React app, which wraps the DpsCalc page in a MainLayout with navigation and footer. DpsCalc is the heart of the app—it manages state, calls utility functions for parsing and calculation, and composes smaller components like inputs and cards. The CalcHistory organism handles the sidebar feature. Everything flows in one direction: user input triggers parsing in utils, calculations produce results, and those get rendered through reusable components.
Architecture
Let's trace the data flow for the paste-based workflow. You copy weapon stats in Path of Exile 2 and paste them into the app. The DpsCalc component splits that text into lines and calls findStatValues, which scans for keywords like attacks per second and fire damage, extracting the numbers. Those values flow into handleDpsCalculations, which applies the DPS formula—average damage times attack speed—for each damage type. Finally, the results get mapped to colored cards and displayed. It's a clean, linear pipeline from paste to pixels.
Architecture
Here's the calculation logic. This function takes the form values—attack speed and damage ranges for each type—and applies a simple formula: average damage times attacks per second. For physical damage, it's min plus max divided by two, then multiplied by attack speed. It does this for all five damage types, sums the elemental types together, and returns a calculation object with all the DPS values. Pure, testable, and easy to reason about.
CodeQuality
Let's look at code quality. Overall, this codebase earns an A. The atomic design pattern is executed cleanly, with well-defined component layers. TypeScript is strict throughout, with proper typing on every prop and function. Testing is exemplary—100% coverage thresholds are enforced in CI, and every major piece of logic has a corresponding test file. State management gets a B—local hooks are fine for this app size, though a reducer might help if complexity grows. Error handling also gets a B because parsing failures are silent—users don't see feedback when paste format is wrong.
CodeQuality
There are a few tech debt items worth noting. First, history isn't persisted—refresh the page and you lose all your comparisons. That's frustrating for users comparing multiple weapons. Second, the text parsing is brittle—if Grinding Gear Games changes the clipboard format in a game update, the paste flow breaks with no error message. Third, parsing failures are silent, so users don't know what went wrong. And finally, there are empty placeholder folders for hooks and API, hinting at features that were planned but never built. None of these are critical, but they're good targets for future improvement.
Community
This is a solo project by a single developer who goes by The Adult In The Room. Activity is strong—commits within the last few days, thirty-five commits in the past ninety days. It's actively maintained, not abandoned. With only one contributor, the project's future depends on this developer staying engaged. There are no tags yet, which suggests it's still early in its lifecycle. For a personal tool serving a specific game community, this level of activity is healthy.
Health
Let's talk about the biggest improvement opportunities. First, add localStorage persistence for the history. Users would love to close the tab and come back hours later with their comparisons intact—it's a simple addition with high user satisfaction. Second, show error messages when clipboard parsing fails. Right now, if the format is wrong, nothing happens. A friendly message like could not parse weapon stats, try pasting again would prevent confusion. Third, consider adding a share feature—encoding weapon stats in a URL or copying formatted text so users can send comparisons to friends. That would boost engagement and drive organic growth.
Health
Bottom line: this codebase is in excellent health. It's a focused tool that does one thing well, built by a developer who clearly knows their craft. The architecture is clean, testing is thorough, and the tech choices are modern and appropriate. The only rough edges are missing state persistence and silent error handling, but those are easy wins. For its purpose—helping Path of Exile 2 players compare weapon damage—it succeeds completely. This is a great example of a solo project done right.
How this was made
Lenzon read The-Adult-In-The-Room/poe2-tools and generated this walkthrough automatically. The narration above is the transcript of what it says.
Explain a pull request from your own repo
Point Lenzon at a repo or a pull request and get a narrated walkthrough like this one.
Try it