helpers4 vs Radashi — Detailed Comparison

Radashi is a general-purpose TypeScript utility toolkit (~130 functions), and the actively maintained fork of Radash. helpers4 covers that same general-purpose ground (and then some — see below) plus the domain-specific categories radashi’s core deliberately excludes.

This page details the differences to help you decide whether you need helpers4, radashi, or both.

Philosophy

	helpers4	radashi
Goal	General-purpose utilities plus domain-specific helpers other toolkits don’t cover	General-purpose utility belt
Scope	General core (array, object, string, number, function, guard) plus domain-specific categories (URL, date, semver…)	Core limited to the most popular/common utilities
Package strategy	Independent @helpers4/* packages per category	Single radashi package
Dependencies	Zero runtime dependencies	Zero dependencies
License	LGPL-3.0	MIT

Origin story

helpers4 was born from a recurring problem: repeatedly recoding the same domain-specific helpers (URL manipulation, string humanisation, promise guards…) across projects due to licensing constraints. After 10 years of rewriting the same utilities, the question became: should this effort go into an existing library, or into a standalone project?

The question was raised directly to the Radashi community: “How Far Should More Helper Functions Be Integrated?”. The answer from the Radashi maintainer was clear and fair: Radashi core stays focused on the most popular utilities, niche helpers belong either in a future radashi-edge package or in complementary third-party libraries. This confirmed the need for helpers4 as a standalone project.

A concrete case confirmed this: URL helpers proposed to Radashi core were acknowledged as well-built, but the Radashi maintainer raised a philosophical concern: “when encountering malformed paths, it’s often more maintainable to fix the issue at its source rather than normalising downstream.”

The counter-argument — and helpers4’s actual position — is that these utilities are string manipulations, no different in nature from capitalize or kebabCase. When a string arrives from a third-party API, a config file, or a legacy codebase, you cannot always “fix the source”. You need a clean, named, typed helper that does one obvious thing. cleanPath(url) is not masking a problem; it is the solution.

The two libraries ended up at different answers to the same question, and that’s fine. Radashi stayed a lean, single-package core; helpers4 grew into a broader, modular toolkit that covers that same general-purpose ground and everything radashi’s popularity threshold excludes.

Key philosophical differences

• Breadth: helpers4 covers the same general-purpose surface as radashi (array, object, string, number, function, guard) plus categories radashi deliberately excludes — dates, URLs, semver, observables — because they don’t meet radashi’s popularity threshold for core.
• Tree-shaking makes breadth viable: With modern bundlers, having many functions in independent packages adds zero overhead. helpers4 leans into this.
• Two valid answers to the same question: radashi optimizes for a minimal, single-package core; helpers4 optimizes for one modular ecosystem that covers both the general and the domain-specific. Both can be used standalone or together.

What helpers4 adds that radashi doesn’t have

Date utilities (@helpers4/date)

Function	Description
compare	Compare two dates with configurable precision
daysDifference	Number of days between two dates
isSameDay	Check if two dates are the same calendar day
safeDate	Parse dates safely (handles timestamps in seconds)
toISO8601 / toRFC2822 / toRFC3339	Format dates to standard formats
isTimestampInSeconds	Detect if a timestamp is in seconds vs milliseconds
normalizeTimestamp	Normalize any timestamp to milliseconds
dateToISOString	Safe ISO string conversion

radashi has no date utilities.

URL utilities (@helpers4/url)

Function	Description
cleanPath	Normalize a URL path
extractPureURI	Strip query params and fragments
onlyPath	Extract the path from a full URL
relativeURLToAbsolute	Convert relative URLs to absolute
withLeadingSlash / withoutLeadingSlash	Ensure/remove leading slash
withTrailingSlash / withoutTrailingSlash	Ensure/remove trailing slash

radashi has no URL utilities.

Version / Semver utilities (@helpers4/version)

Function	Description
parse	Parse a semver string into components
compare	Compare two semver versions
increment	Bump major/minor/patch/prerelease
satisfiesRange	Check if a version satisfies a range
stripV	Remove the v prefix

radashi has no semver utilities.

Observable utilities (@helpers4/observable)

Function	Description
combine	Combine multiple observables into one
combineLatest	Combine latest values from multiple observables

radashi has no RxJS / observable utilities.

Promise guards (@helpers4/promise)

Function	Description
truthyPromiseOrThrow	Assert a promise resolves to a truthy value
falsyPromiseOrThrow	Assert a promise resolves to a falsy value
meaningPromiseOrThrow	Assert a promise resolves to a non-empty value
consoleLogPromise	Log and pass-through in promise chains

radashi has retry, sleep, parallel, defer, guard — different async patterns, but no typed promise guards.

Where they overlap

For functions that exist in both libraries, here’s how they compare:

Array

helpers4	radashi	Notes
chunk	cluster	Same concept, different names
unique	unique	Same concept
difference	diff	Same concept
intersection	intersects	radashi returns boolean, helpers4 returns the intersection array
arrayEquals	isArrayEqual	Same concept
deepCompare	—	helpers4 only (array-specific deep comparison)
oneInCommon	intersects	radashi’s intersects returns boolean like oneInCommon
createSortBy*Fn	sort	helpers4 provides sort function factories; radashi has a single sort

Object

helpers4	radashi	Notes
deepClone	cloneDeep	Same concept
deepMerge	assign	radashi’s assign does recursive merge
get	get	Same concept
set	set	Same concept
deepCompare	isEqual	Same concept (deep equality)
removeUndefinedNull	shake	radashi’s shake removes any falsy by predicate

String

helpers4	radashi	Notes
camelCase	camel	Same concept
capitalize	capitalize	Same concept
kebabCase	dash	Same concept (dash-case = kebab-case)
slugify	—	helpers4 only
labelize	title	Similar (humanize a key into a label)
errorToReadableMessage	—	helpers4 only

Function

helpers4	radashi	Notes
debounce	debounce	Same concept
throttle	throttle	Same concept
memoize	memo	Same concept

Number

helpers4	radashi	Notes
clamp	clamp	Same concept
roundTo	round	Same concept
randomBetween	random	Same concept

Type checking

helpers4	radashi	Notes
isArray	isArray	Same
isBoolean	isBoolean	Same
isDate	isDate	Same
isEmpty	isEmpty	Same
isFunction	isFunction	Same
isNumber	isNumber	Same
isObject	isObject	Same
isSet	isSet	Same
isString	isString	Same
isValidRegex	—	helpers4 only

When to use which

Scenario	Recommendation
You need date formatting/comparison	helpers4 (@helpers4/date)
You need URL path manipulation	helpers4 (@helpers4/url)
You need semver parsing/comparison	helpers4 (@helpers4/version)
You need RxJS observable combinators	helpers4 (@helpers4/observable)
You need typed promise guards	helpers4 (@helpers4/promise)
You need general-purpose utilities and domain-specific helpers in one toolkit	helpers4
You want the smallest possible single-package core, no domain extras	radashi
You need both, from separate minimal packages	both — they work together

Summary

helpers4 and radashi both cover the same general-purpose ground (arrays, objects, strings, functions) — helpers4 provides its own implementation with zero runtime dependencies. Where they differ is scope: radashi stays a lean, single-package core; helpers4 additionally covers what radashi’s popularity threshold excludes (dates, URLs, semver, observables, promise guards). Pick radashi for the smallest possible general-purpose package, helpers4 for that same ground plus the domain-specific gaps, or use both together.