OPEN TECH FOUNDATION

> An Extensive JavaScript Standard Library.

Features

- Simple & Familiar API with some differences

- Cross-Environment Compatibility: Execute seamlessly in browsers, Node.js, Bun, Deno, etc.
- Practical Default Options
- Includes Async Utils
- TypeScript Support
- Works with both CJS & ESM
- Supports some Older Browsers & Node.js >= 16

Installation

Install it using your favourite package manager.

``sh
npm install @opentf/std
`

`sh
yarn add @opentf/std
`

`sh
pnpm add @opentf/std
`

`sh
bun add @opentf/std
`

`sh
deno add @opentf/std
`

Usage

Let’s explore some of the library’s capabilities:

1. Checking if a Value is Numeric:

`js
import { isNum } from "@opentf/std";

isNum(NaN); //=> false
isNum('1'); //=> false
isNum('1', true); //=> true
isNum(1); //=> true
`

2. Converting Strings to Pascal Case:

`js
import { pascalCase } from "@opentf/std";

pascalCase("pascal case"); //=> PascalCase
`

3. Sorting an Array in Descending Order:

`js
import { sort } from "@opentf/std";

sort([1, 10, 21, 2], "desc"); //=> [21, 10, 2, 1]
`

4. Deep Cloning an Object:

`js
import { clone } from "@opentf/std";

const obj = { a: 1, b: "abc", c: new Map([["key", "val"]]) };

clone(obj); // Returns deeply cloned value
`

5. Checking Equality of Objects & Arrays:

`js
import { isEql, isEqlArr } from "@opentf/std";

const mapA = new Map([
["a", 1],
["b", 2],
]);
const mapB = new Map([
["b", 2],
["a", 1],
]);

isEql(mapA, mapB); //=> false

isEqlArr([1, 2, 3], [2, 3, 1]); //=> true
`

6. Adding a Delay (1 second) with sleep:

`js
import { sleep } from "@opentf/std";

await sleep(1000); // Suspends execution for 1 second
`

7. Functions composition using pipe & compose functions:

`js
import { pipe, compose } from "@opentf/std";

pipe(
1,
(x) => x + 1,
(x) => x * 5,
); //=> 10

compose(
1,
(x) => x + 1,
(x) => x * 5,
); //=> 6
`

8. Pick & Omit Paths in an Object

`js
import { pick omit } from '@opentf/std';

const obj = { a: 1, b: 2, c: 3 };

pick(obj, 'a', 'c'); //=> { a: 1, c: 3 }

omit(obj, 'a', 'c'); //=> { b: 2 }
`

API

$3

- arrIns
- arrReplace
- arrRm
- bounds
- chunk
- compact
- countBy
- diff
- drop
- groupBy
- intersection
- intersperse
- max
- min
- move
- range
- reverse
- shuffle
- sort
- sortBy
- swap
- symDiff
- take
- union
- uniq

Async

- aCompose
- aComposeFn
- aFilter
- aForEach
- aMap
- aPipe
- aPipeFn
- aResolvers

$3

- avg
- clamp
- divMod
- isDisjointFrom
- isEven
- isOdd
- isSubsetOf
- isSupersetOf
- mean
- median
- mode
- percentage
- percentageOf
- prod
- sum

$3

- isNegZero
- isZero
- toNum

$3

- compose
- composeFn
- noop
- pipe
- pipeFn
- sleep

$3

- hexToRGB
- rgbToHex

$3

- isEmpty
- isEql
- isEqlArr
- isNil
- isShallowEql

$3

- clone
- fromPath
- get
- has
- merge
- mergeAll
- omit
- pick
- set
- shallowMerge
- shallowMergeAll
- size
- toPath
- unset

$3

- camelCase
- capitalize
- insertAt
- isEmail
- pascalCase
- replaceAt
- strReplace

$3

- isArr
- isArrBuf
- isAsynFn
- isBigInt
- isBlob
- isBool
- isDataView
- isDate
- isErr
- isFn
- isGenFn
- isInfinity
- isJSON
- isMap
- isNull
- isNum
- isObj
- isPureObj
- isRegEx
- isSet
- isStr
- isSym
- isTypedArr
- isUndef
- isWkMap
- isWkRef
- isWkSet

Benchmarks

Some benchmark outputs are shown here for reference.

> [!IMPORTANT]
> Our priorities are reliability and accuracy rather than performance.

`diff
clone:
┌───┬──────────────────────────┬─────────┬────────────────────┬────────┬─────────┐
│ │ Task Name │ ops/sec │ Average Time (ns) │ Margin │ Samples │
├───┼──────────────────────────┼─────────┼────────────────────┼────────┼─────────┤
│ 0 │ structuredClone (Native) │ 276,824 │ 3612.3959469709525 │ ±1.29% │ 27683 │
│ 1 │ _.cloneDeep (Lodash) │ 216,965 │ 4609.032953864744 │ ±2.41% │ 21697 │
│ 2 │ R.clone (ramda) │ 174,567 │ 5728.439422580611 │ ±1.92% │ 17457 │
│ 3 │ R2.clone (remeda) │ 310,268 │ 3223.0154703960834 │ ±2.40% │ 31027 │
│ 4 │ cloneDeep (clone-deep) │ 468,908 │ 2132.611673882092 │ ±1.70% │ 46891 │
│ 5 │ copy (fast-copy) │ 486,179 │ 2056.852050680814 │ ±1.91% │ 48618 │
+ 6 │ clone │ 535,302 │ 1868.1028376072306 │ ±2.07% │ 53531 │
└───┴──────────────────────────┴─────────┴────────────────────┴────────┴─────────┘
*Note:
- Here the lodash does not support errors, sparse arrays & objects in map keys.

- Here the ramda & remeda does not support cloning Map & Set.

- The fast-copy does not clone objects within Map, buffers in TypedArray, sparse arrays.

- The clone-deep does not handle circular refs, does not clone objects within map,
sparse arrays, internal refs within the object, TypedArray buffers & DataView.

sortBy:
┌───┬────────────────────┬───────────┬───────────────────┬────────┬─────────┐
│ │ Task Name │ ops/sec │ Average Time (ns) │ Margin │ Samples │
├───┼────────────────────┼───────────┼───────────────────┼────────┼─────────┤
│ 0 │ _.orderBy (Lodash) │ 1,231,295 │ 812.1529684071648 │ ±3.09% │ 123130 │
│ 1 │ R.sortWith (Ramda) │ 1,279,200 │ 781.7380570822326 │ ±2.27% │ 127921 │
│ 2 │ R2.sortBy (Remeda) │ 1,419,707 │ 704.3703291518029 │ ±2.81% │ 141971 │
│ 3 │ sort (Moderndash) │ 2,697,568 │ 370.7042634668106 │ ±1.82% │ 269757 │
+ 4 │ sortBy │ 2,728,366 │ 366.5196435965459 │ ±2.19% │ 272837 │
└───┴────────────────────┴───────────┴───────────────────┴────────┴─────────┘

*Note: Here the Moderndash does not support passing object prop as string.

isEql:
┌───┬─────────────────────────────────────┬─────────┬────────────────────┬────────┬─────────┐
│ │ Task Name │ ops/sec │ Average Time (ns) │ Margin │ Samples │
├───┼─────────────────────────────────────┼─────────┼────────────────────┼────────┼─────────┤
│ 0 │ deepStrictEqual (Native) │ 950,686 │ 1051.871609041841 │ ±0.24% │ 95069 │
│ 1 │ fastDeepEqual (fast-deep-equal/es6) │ 652,611 │ 1532.3058134904193 │ ±1.49% │ 65262 │
│ 2 │ dequal │ 120,791 │ 8278.7573675501 │ ±0.74% │ 12080 │
│ 3 │ _.isEqual (Lodash) │ 152,075 │ 6575.660376117521 │ ±2.02% │ 15208 │
│ 4 │ R.equals (Ramda) │ 51,496 │ 19418.976504855284 │ ±1.70% │ 5150 │
+ 5 │ isEql │ 104,355 │ 9582.655710998957 │ ±1.13% │ 10436 │
└───┴─────────────────────────────────────┴─────────┴────────────────────┴────────┴─────────┘

*Note:

- The native util deepStrictEqual not available in browsers, does not check Map ordering & same invalid dates.
- The fast-deep-equal/es6 does not support cyclic refs, Map ordering check, invalid dates, symbols, objects values in Set & TypedArrays.
- The lodash isEqual having issues with Map & does not check Map ordering & object values in Set.
- The ramda equals does not check Map ordering & symbols.
- The dequal does not support cyclic refs, Map ordering, symbols & same invalid dates.
`

$3

`sh
$ bun run build
$ bun benchmark.js
``

Articles

Please read our important articles:

- Introducing Our New JavaScript Standard Library

- You Don’t Need JavaScript Native Methods

License

Copyright (c) Thanga Ganapathy (MIT License).