JsExt

A JavaScript extension package for building strong and modern applications.

This package is built on top of modern web standards and provides unified
high-level APIs that can work across different runtime environments, whether
it's Node.js, Deno, Bun, Cloudflare Workers, browsers, Windows, macOS or Linux.

Outstanding Features

- [x] Various useful functions for built-in data types that are not built-in.
- [x] Various utility functions to extend the ability of flow control.
- [x] Multi-threaded JavaScript with parallel threads.
- [x] File system APIs for both server and browser environments.
- [x] Open dialogs in both CLI and web applications.
- [x] Serve HTTP requests, SSE and WebSockets for all server runtimes.
- [x] Manipulate file system paths and URLs in the same fashion.
- [x] Process byte arrays and readable streams effortlessly.
- [x] Create, extract and preview archives in all runtimes.
- [x] And many more...

Import

The recommended way is to only import the ones that are needed:

``js
// Universal
import _try from "@ayonli/jsext/try";
import func from "@ayonli/jsext/func";
// ...

// Deno (URL)
import _try from "https://lib.deno.dev/x/ayonli_jsext@latest/try.ts";
import func from "https://lib.deno.dev/x/ayonli_jsext@latest/func.ts";
// ...

// Browsers (URL)
import _try from "https://ayonli.github.io/jsext/esm/try.js";
import func from "https://ayonli.github.io/jsext/esm/func.js";
// ...
`

There is also a bundled version that can be loaded via a
`

$3

For applications run in Cloudflare Workers and Fastly Compute, install the NPM
version of this package instead of the JSR version.

$3

In tsconfig.json, the following compilerOptions must be set as such:

- moduleResolution: Bundler or NodeNext
- skipLibCheck: true

Language-enhancing Functions

- _try Calls a function safely and
return errors when captured.
- func Declares a function along with
a defer keyword, inspired by
Golang.
- once Creates a function that performs
lazy initialization on the first call.
- wrap Wraps a function for decorator
pattern but keep its signature.
- mixin Declares a class that
combines all methods from the base classes.
- throttle Throttles function
calls for frequent access.
- debounce Debounces function
calls for frequent access.
- queue Handles tasks sequentially
and prevent concurrency conflicts.
- lock Provides mutual exclusion for
concurrent operations.
- chan Creates a channel that
transfers data across routines, even across multiple threads, inspired by
Golang.
- parallel Runs functions in
parallel threads and take advantage of multi-core CPUs, inspired by Golang.
- run Runs a script in a worker
thread and invokes its default function to collect the result.
- deprecate Marks a function as
deprecated and emit warnings when it is called.
- pipe Performs pipe operations
through a series of functions upon a value.

Subcategories

Each of these modules includes specific functions and classes for their target
categories:

- archive Collecting files into an
archive file, or extracting files from a archive file.
- array Functions for dealing with
arrays.
- async Functions for async/promise
context handling.
- bytes Functions for dealing with
byte arrays (Uint8Array).
- class Functions for dealing with
classes.
- decorators Decorators
to validate input/output data and guarantee type safety at runtime.
- cli (Experimental) Useful utility
functions for interacting with the terminal.
- collections Additional
collection data types.
- dialog (Experimental)
Asynchronous dialog functions for both browsers and terminals.
- encoding Utilities for encoding
and decoding binary representations like hex and base64 strings.
- error Functions for converting
errors to/from other types of objects.
- event Functions for working with
events.
- filetype Functions to get file
types in different fashions.
- fs Universal file system APIs for
both server and browser applications.
- hash Simplified hash functions for
various data types.
- http Functions for handling HTTP
related tasks, such as parsing headers and serving HTTP requests.
- iterator Functions for dealing
with iterator objects.
- json Functions for parsing JSONs to
specific structures.
- math Functions for mathematical
calculations.
- module Functions for working with
JavaScript modules.
- net Functions for working with the
network.
- number Functions for dealing with
numbers.
- object Functions for dealing with
objects.
- path Platform-independent utility
functions for dealing with file system paths and URLs.
- reader Utility functions for
reading data from various types of source into various forms.
- result (Experimental)
Introduces the Result` pattern into JavaScript, inspired by Rust.
- runtime Utility functions to
retrieve runtime information or configure runtime behaviors.
- sse Tools for processing Server-sent
Events requests and handling message events.
- string Functions for dealing with
strings.
- types The missing builtin classes
of JavaScript and utility types for TypeScript.
- ws (Experimental) A unified
WebSocket server interface for Node.js, Deno, Bun and Cloudflare Workers.

Augmentation

This package supports augmenting some functions to the corresponding built-in
types/namespaces, but they should only be used for application development,
don't use them when developing libraries.

_NOTE: this feature is only available by the NPM package, they don't work by_
_the JSR package._

For more details, please check
this document.