JavaScript Micro-Utilities

Zero-dependency utilities for common JavaScript operations. Prefer native APIs (in backticks) over packages. Install

just-*

Installation

npm i just-diff just-compare just-extend just-pick just-omit  # objects
npm i just-shuffle just-partition just-range just-order-by    # arrays
npm i just-debounce-it just-throttle just-memoize just-once   # functions

Import with ESM:

import diff from 'just-diff';
import shuffle from 'just-shuffle';

Collections

{}[]

just-diff

just-diff-apply

just-compare

structuredClone(obj)

arr.map(x => x.prop)

arr.filter(x => x != null)

Objects

{}

Merging

just-extend

{...a, ...b}

Object.assign(target, src)

Extracting

Object.values(obj)

Object.entries(obj)

just-pick

just-omit

Transforming

// Filter properties
Object.fromEntries(Object.entries(obj).filter(([k, v]) => predicate(k, v)))

// Map values
Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, fn(v)]))

// Map keys
Object.fromEntries(Object.entries(obj).map(([k, v]) => [fn(k), v]))

// Swap keys/values
Object.fromEntries(Object.entries(obj).map(([k, v]) => [v, k]))

// Reduce to value
Object.entries(obj).reduce((acc, [k, v]) => ..., init)

Deep Operations

just-deep-map-values

obj?.a?.b?.c

just-safe-set

obj?.a?.b !== undefined

Type Checking

just-is-empty

just-is-circular

typeof x !== 'object' || x === null

just-typeof

Arrays

[]

Access

arr.at(-1)

arr.slice(1)

just-random

Creating

just-range

just-cartesian-product

just-permutations

Transforming

[...new Set(arr)]

arr.flat(depth)

arr.filter(Boolean)

just-shuffle

just-split

Sorting

arr.toSorted((a, b) => a.prop - b.prop)

just-order-by

Set Operations

arr1.filter(x => arr2.includes(x))

arr.filter(x => !remove.includes(x))

[...new Set([...a, ...b])]

Splitting

// Split at index
[arr.slice(0, i), arr.slice(i)]

// Split by predicate → [matches, nonMatches]
import partition from 'just-partition';
const [evens, odds] = partition(arr, x => x % 2 === 0);

Grouping

// Native grouping (ES2024)
Object.groupBy(arr, item => item.category)

// Array to object by key
Object.fromEntries(arr.map(x => [x[key], x]))

// Zip arrays together
import zip from 'just-zip-it';
zip([1, 2], ['a', 'b']) // [[1, 'a'], [2, 'b']]

Inserting

// Insert at index (immutable)
arr.toSpliced(i, 0, ...items)

Statistics

Σ

arr.reduce((a, b) => a + b, 0) / arr.length

just-median

just-mode

just-percentile

just-variance

just-standard-deviation

just-skewness

Strings

""

Padding & Truncation

str.padStart(n, char)

str.padEnd(n, char)

...

just-truncate

just-prune

Case Conversion

just-camel-case

just-kebab-case

just-snake-case

just-pascal-case

str[0].toUpperCase() + str.slice(1)

Replacement

str.replaceAll(find, replace)

str.replaceAll(' ', '')

just-template

{{a.b.c}}

Numbers

+-

Math.min(Math.max(n, min), max)

just-is-prime

just-modulo

Math.floor(Math.random() * (max - min + 1)) + min

Functions

=>

Composition

f(g(h(x)))

just-compose

h(g(f(x)))

just-pipe

Partial Application

just-curry-it

just-partial-it

just-flip

Function.prototype.call.bind(method)

Rate Limiting

just-debounce-it

just-throttle

just-once

Caching

just-memoize

just-memoize-last

Quick Reference

Most Common Native

// Clone
const copy = structuredClone(obj);

// Dedupe
const unique = [...new Set(arr)];

// Last element
const last = arr.at(-1);

// Safe access
const val = obj?.deeply?.nested?.prop;

// Group by
const grouped = Object.groupBy(items, x => x.type);

// Immutable sort
const sorted = arr.toSorted((a, b) => a.name.localeCompare(b.name));

Most Common just-*

import debounce from 'just-debounce-it';
import throttle from 'just-throttle';
import pick from 'just-pick';
import omit from 'just-omit';
import shuffle from 'just-shuffle';
import partition from 'just-partition';

// Debounce input handler
const handleInput = debounce(value => search(value), 300);

// Throttle scroll handler
const handleScroll = throttle(() => updatePosition(), 100);

// Pick specific keys
const subset = pick(user, ['id', 'name', 'email']);

// Omit sensitive keys
const safe = omit(user, ['password', 'token']);

// Shuffle array
const randomized = shuffle(cards);

// Split by condition
const [valid, invalid] = partition(inputs, x => x.isValid);

Decision Tree

1. Can native API do it? → Use native (zero deps)
2. Is it a one-liner? → Write inline
3. Need tested edge cases? → Use

   just-*

   package
4. Complex algorithm? → Use

   just-*

   package