fn-name

In practice, fn-name does exactly what it promises with zero surprises. The API is a single default export function that takes any function and returns its name as a string. TypeScript support is first-class with proper type definitions included, and IDE autocomplete works flawlessly. I've used it primarily in logging and debugging utilities where function names need to be extracted at runtime.

The package handles edge cases well - anonymous functions, arrow functions, and bound functions all return sensible results. Error handling is straightforward: it returns an empty string for anonymous functions rather than throwing, which is the right choice for a utility like this. The source is tiny (basically a one-liner wrapper around function.name with fallbacks), making it perfect for dependency-conscious projects.

The main limitation is that it's almost too simple - you might question whether you need a dependency for this. However, the cross-environment compatibility and edge case handling it provides saves you from writing and maintaining the same logic yourself. Documentation is minimal but adequate since the API surface is so small.

This is about as simple as a package gets - it extracts the name property from functions. In practice, it's useful for debugging, logging, and metaprogramming scenarios where you need reliable function name extraction. The implementation is straightforward: it checks the function's name property and falls back to parsing Function.prototype.toString() for edge cases.

From a security perspective, this package is refreshingly minimal with zero dependencies, which means no supply chain attack surface. The code is simple enough to audit in minutes. It handles edge cases like anonymous functions and arrow functions predictably by returning empty strings or undefined, which won't cause injection issues in logging contexts. No crypto, no network calls, no file system access - just pure function introspection.

The main gotcha is that minification can strip function names, so don't rely on this for production behavior that affects application logic. It's best used for development tooling, error reporting, and debugging where function names provide context but aren't mission-critical.

fn-name is incredibly straightforward to use - it's literally one function that extracts the name from a named function. The API is dead simple: pass in a function, get back its name as a string. The learning curve is virtually non-existent, and you'll be productive within 30 seconds of reading the README.

The package handles most common scenarios well, including regular named functions, class methods, and arrow functions assigned to variables. However, you'll quickly discover that JavaScript's function naming is more nuanced than expected. Anonymous functions return empty strings, and minified code will give you mangled names. The error messages are minimal since it's such a simple utility, but this also means you need to understand JavaScript's function.name behavior yourself.

For day-to-day use, it's reliable for debugging, logging, and introspection tasks. The package hasn't been updated since 2021, but that's actually fine - it's feature-complete. Community support is limited simply because there's not much that can go wrong, though this means you're mostly on your own for edge cases.