js-micro-utilities

```bash

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:

```javascript

import diff from 'just-diff';

import shuffle from 'just-shuffle';

```

---

| Need | Solution |

|------|----------|

| Deep diff two objects/arrays | just-diff |

| Apply JSON-patch to object | just-diff-apply |

| Deep equality check | just-compare |

| Deep clone | structuredClone(obj) |

| Extract property from array | arr.map(x => x.prop) |

| Remove nullish from array | arr.filter(x => x != null) |

---

Merging

| Need | Solution |

|------|----------|

| Deep merge | just-extend |

| Shallow merge | {...a, ...b} or Object.assign(target, src) |

Extracting

| Need | Solution |

|------|----------|

| Values as array | Object.values(obj) |

| Key-value pairs | Object.entries(obj) |

| Keep only certain keys | just-pick |

| Exclude certain keys | just-omit |

Transforming

```javascript

// 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

| Need | Solution |

|------|----------|

| Map values recursively | just-deep-map-values |

| Safe nested get | obj?.a?.b?.c |

| Safe nested set | just-safe-set |

| Check nested exists | obj?.a?.b !== undefined |

Type Checking

| Need | Solution |

|------|----------|

| Is empty | just-is-empty |

| Has circular refs | just-is-circular |

| Is primitive | typeof x !== 'object' \|\| x === null |

| Better typeof | just-typeof (distinguishes array, null, date, regexp) |

---

Access

| Need | Solution |

|------|----------|

| Last element | arr.at(-1) |

| All except first | arr.slice(1) |

| Random element | just-random |

Creating

| Need | Solution |

|------|----------|

| Number sequence | just-range |

| All combinations | just-cartesian-product |

| All orderings | just-permutations |

Transforming

| Need | Solution |

|------|----------|

| Dedupe primitives | [...new Set(arr)] |

| Flatten nested | arr.flat(depth) |

| Remove falsy | arr.filter(Boolean) |

| Shuffle | just-shuffle |

| Chunk into groups | just-split |

Sorting

| Need | Solution |

|------|----------|

| Immutable sort by prop | arr.toSorted((a, b) => a.prop - b.prop) |

| Multi-prop sort | just-order-by |

Set Operations

| Need | Solution |

|------|----------|

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

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

| Union (deduped) | [...new Set([...a, ...b])] |

Splitting

```javascript

// 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

```javascript

// 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

```javascript

// Insert at index (immutable)

arr.toSpliced(i, 0, ...items)

```

---

| Need | Solution |

|------|----------|

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

| Median | just-median |

| Mode | just-mode |

| Percentile | just-percentile |

| Variance | just-variance |

| Std deviation | just-standard-deviation |

| Skewness | just-skewness |

---

Padding & Truncation

| Need | Solution |

|------|----------|

| Pad start | str.padStart(n, char) |

| Pad end | str.padEnd(n, char) |

| Truncate with ... | just-truncate |

| Truncate at word | just-prune |

Case Conversion

| Need | Solution |

|------|----------|

| camelCase | just-camel-case |

| kebab-case | just-kebab-case |

| snake_case | just-snake-case |

| PascalCase | just-pascal-case |

| Capitalize first | str[0].toUpperCase() + str.slice(1) |

Replacement

| Need | Solution |

|------|----------|

| Replace all | str.replaceAll(find, replace) |

| Remove whitespace | str.replaceAll(' ', '') |

| Template interpolation | just-template (supports {{a.b.c}} paths) |

---

| Need | Solution |

|------|----------|

| Clamp to range | Math.min(Math.max(n, min), max) |

| Is prime | just-is-prime |

| True modulo (neg-safe) | just-modulo |

| Random int in range | Math.floor(Math.random() * (max - min + 1)) + min |

---

Composition

| Need | Solution |

|------|----------|

| Right-to-left f(g(h(x))) | just-compose |

| Left-to-right h(g(f(x))) | just-pipe |

Partial Application

| Need | Solution |

|------|----------|

| Curry | just-curry-it |

| Fix args with placeholders | just-partial-it |

| Swap first two args | just-flip |

| Method to function | Function.prototype.call.bind(method) |

Rate Limiting

| Need | Solution |

|------|----------|

| Debounce (wait for pause) | just-debounce-it |

| Throttle (once per interval) | just-throttle |

| Run only first call | just-once |

Caching

| Need | Solution |

|------|----------|

| Memoize by args | just-memoize |

| Cache last call only | just-memoize-last |

---

Most Common Native

```javascript

// 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-*

```javascript

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);

```

---

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