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.

1npm install @opentf/std

1yarn add @opentf/std

1pnpm add @opentf/std

1bun add @opentf/std

1deno add @opentf/std

Usage

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

1. Checking if a Value is Numeric:

1import { isNum } from "@opentf/std";
2
3isNum(NaN); //=> false
4isNum('1'); //=> false
5isNum('1', true); //=> true
6isNum(1); //=> true

2. Converting Strings to Pascal Case:

1import { pascalCase } from "@opentf/std";
2
3pascalCase("pascal case"); //=> PascalCase

3. Sorting an Array in Descending Order:

1import { sort } from "@opentf/std";
2
3sort([1, 10, 21, 2], "desc"); //=> [21, 10, 2, 1]

4. Deep Cloning an Object:

1import { clone } from "@opentf/std";
2
3const obj = { a: 1, b: "abc", c: new Map([["key", "val"]]) };
4
5clone(obj); // Returns deeply cloned value

5. Checking Equality of Objects & Arrays:

1import { isEql, isEqlArr } from "@opentf/std";
2
3const mapA = new Map([
4  ["a", 1],
5  ["b", 2],
6]);
7const mapB = new Map([
8  ["b", 2],
9  ["a", 1],
10]);
11
12isEql(mapA, mapB); //=> false
13
14isEqlArr([1, 2, 3], [2, 3, 1]); //=> true

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

1import { sleep } from "@opentf/std";
2
3await sleep(1000); // Suspends execution for 1 second

7. Functions composition using pipe & compose functions:

1import { pipe, compose } from "@opentf/std";
2
3pipe(
4  1,
5  (x) => x + 1,
6  (x) => x * 5,
7); //=> 10
8
9compose(
10  1,
11  (x) => x + 1,
12  (x) => x * 5,
13); //=> 6

8. Pick & Omit Paths in an Object

1import { pick omit } from '@opentf/std';
2 
3const obj = { a: 1, b: 2, c: 3 };
4 
5pick(obj, 'a', 'c'); //=> { a: 1, c: 3 }
6 
7omit(obj, 'a', 'c'); //=> { b: 2 }

API

Array

• 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

Maths

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

Number

• isNegZero
• isZero
• toNum

Function

• compose
• composeFn
• noop
• pipe
• pipeFn
• sleep

Colors

• hexToRGB
• rgbToHex

Assert

• isEmpty
• isEql
• isEqlArr
• isNil
• isShallowEql

Object

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

String

• camelCase
• capitalize
• insertAt
• isEmail
• pascalCase
• replaceAt
• strReplace

Types

• 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.

1clone:
2┌───┬──────────────────────────┬─────────┬────────────────────┬────────┬─────────┐
3│   │ Task Name                │ ops/sec │ Average Time (ns)  │ Margin │ Samples │
4├───┼──────────────────────────┼─────────┼────────────────────┼────────┼─────────┤
5│ 0 │ structuredClone (Native) │ 276,824 │ 3612.3959469709525 │ ±1.29% │ 27683   │
6│ 1 │ _.cloneDeep (Lodash)     │ 216,965 │ 4609.032953864744  │ ±2.41% │ 21697   │
7│ 2 │ R.clone (ramda)          │ 174,567 │ 5728.439422580611  │ ±1.92% │ 17457   │
8│ 3 │ R2.clone (remeda)        │ 310,268 │ 3223.0154703960834 │ ±2.40% │ 31027   │
9│ 4 │ cloneDeep (clone-deep)   │ 468,908 │ 2132.611673882092  │ ±1.70% │ 46891   │
10│ 5 │ copy (fast-copy)         │ 486,179 │ 2056.852050680814  │ ±1.91% │ 48618   │
11+ 6 │ clone                    │ 535,302 │ 1868.1028376072306 │ ±2.07% │ 53531   │
12└───┴──────────────────────────┴─────────┴────────────────────┴────────┴─────────┘
13*Note:
14    - Here the lodash does not support errors, sparse arrays & objects in map keys.
15
16    - Here the ramda & remeda does not support cloning Map & Set.
17
18    - The fast-copy does not clone objects within Map, buffers in TypedArray, sparse arrays.
19
20    - The clone-deep does not handle circular refs, does not clone objects within map,
21    sparse arrays, internal refs within the object, TypedArray buffers & DataView.
22
23sortBy:
24┌───┬────────────────────┬───────────┬───────────────────┬────────┬─────────┐
25│   │ Task Name          │ ops/sec   │ Average Time (ns) │ Margin │ Samples │
26├───┼────────────────────┼───────────┼───────────────────┼────────┼─────────┤
27│ 0 │ _.orderBy (Lodash) │ 1,231,295 │ 812.1529684071648 │ ±3.09% │ 123130  │
28│ 1 │ R.sortWith (Ramda) │ 1,279,200 │ 781.7380570822326 │ ±2.27% │ 127921  │
29│ 2 │ R2.sortBy (Remeda) │ 1,419,707 │ 704.3703291518029 │ ±2.81% │ 141971  │
30│ 3 │ sort (Moderndash)  │ 2,697,568 │ 370.7042634668106 │ ±1.82% │ 269757  │
31+ 4 │ sortBy             │ 2,728,366 │ 366.5196435965459 │ ±2.19% │ 272837  │
32└───┴────────────────────┴───────────┴───────────────────┴────────┴─────────┘
33
34*Note: Here the Moderndash does not support passing object prop as string.
35
36isEql:
37┌───┬─────────────────────────────────────┬─────────┬────────────────────┬────────┬─────────┐
38│   │ Task Name                           │ ops/sec │ Average Time (ns)  │ Margin │ Samples │
39├───┼─────────────────────────────────────┼─────────┼────────────────────┼────────┼─────────┤
40│ 0 │ deepStrictEqual (Native)            │ 950,686 │ 1051.871609041841  │ ±0.24% │ 95069   │
41│ 1 │ fastDeepEqual (fast-deep-equal/es6) │ 652,611 │ 1532.3058134904193 │ ±1.49% │ 65262   │
42│ 2 │ dequal                              │ 120,791 │ 8278.7573675501    │ ±0.74% │ 12080   │
43│ 3 │ _.isEqual (Lodash)                  │ 152,075 │ 6575.660376117521  │ ±2.02% │ 15208   │
44│ 4 │ R.equals (Ramda)                    │ 51,496  │ 19418.976504855284 │ ±1.70% │ 5150    │
45+ 5 │ isEql                               │ 104,355 │ 9582.655710998957  │ ±1.13% │ 10436   │
46└───┴─────────────────────────────────────┴─────────┴────────────────────┴────────┴─────────┘
47
48*Note:
49
50  - The native util `deepStrictEqual` not available in browsers, does not check `Map` ordering & same invalid dates.
51  - The `fast-deep-equal/es6` does not support cyclic refs, Map ordering check, invalid dates, symbols, objects values in Set & TypedArrays.
52  - The lodash `isEqual` having issues with Map &  does not check `Map` ordering & object values in `Set`.
53  - The ramda `equals` does not check `Map` ordering & symbols.
54  - The dequal does not support cyclic refs, Map ordering, symbols & same invalid dates.

Running benchmarks

1$ bun run build
2$ 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).