Opinionated collection of reusable JS/TS utilities and types.
- Tree-shakable ES modules: Import only what you need
- Fully tested: Rigorous unit tests with comprehensive coverage
- TypeScript support: Written in TypeScript with full type definitions
- Lightweight: Small bundle size
- Modern: Written with modern JS/TS syntax
- Named arguments: Functions with preferably named arguments
# Using npm
npm install @corentinth/chisels
# Using yarn
yarn add @corentinth/chisels
# Using pnpm
pnpm add @corentinth/chisels
// Using ES6 import
import { safely } from '@corentinth/chisels';
// Using CommonJS require
const { safely } = require('@corentinth/chisels');
const [result, error] = safely(mayThrowError);
console.log({ result, error });
Function - See source
Safely executes a function and return a tuple with the result and an error if any.
const [result, error] = safelySync(myFunction);
if (error) {
console.error(error);
}
console.log(result);
Function - See source
Safely executes an async function or promise and return a tuple with the result and an error if any.
const [result, error] = await safely(myFunction);
if (error) {
console.error(error);
}
console.log(result);
Function - See source
Formats a number of bytes into a human-readable string.
const formatted = formatBytes({ bytes: 4194304 });
console.log(formatted); // 4 MiB
Function - See source
Casts an unknown value to an Error.
try {
// ...
} catch (rawError) {
const error = castError(rawError);
// Do something with a proper Error instance
}
Function - See source
Join URL parts and trim slashes.
const url = joinUrlPaths('/part1/', '/part2/', 'part3', 'part4/');
console.log(url); // 'part1/part2/part3/part4'
Function - See source
Functional wrapper around URL constructor to build an URL string from a base URL and optional path, query params and hash.
const url = buildUrl({ baseUrl: 'https://example.com', path: 'foo', queryParams: { a: '1', b: '2' }, hash: 'hash' });
console.log(url); // 'https://example.com/foo?a=1&b=2#hash'
Function - See source
Injects arguments into a set of functions. Useful for DI of repositories, services, etc.
const functions = {
getUser: ({ userId, db }) => db.users.find({ id: userId }),
removeUser: ({ userId, db }) => db.users.remove({ id: userId }),
};
const { getUser, removeUser } = injectArguments(functions, { db });
getUser({ userId: 1 });
removeUser({ userId: 1 });
Type alias - See source
Make some properties of T optional
type User = {
id: number;
name: string;
email: string;
};
type PartialUser = PartialBy<User, 'email' | 'name'>;
const user: PartialUser = { id: 1 };
Type alias - See source
Flatten an object type for better IDE support
Type alias - See source
Record<string, T> alias
const dictionary: Dictionary<number> = {
a: 1,
b: 2,
};
Type alias - See source
Make all properties of T optional recursively
Type alias - See source
Exclude properties of T that are in U
type User = {
id: number;
name: string;
email: string;
};
type WithId = {
id: number;
}
type UserWithoutId = Subtract<User, WithId>;
This project is licensed under the MIT License. See the LICENSE file for more information.
This project is crafted with ❤️ by Corentin Thomasset.