Naughty-util NPM

Naughty Util

Usage

Install: npm install naughty-util
Require: const utils = require('naughty-util')

Abstract utils

factorify<T, N, K extends keyof T>(dataset: T, nullable?: N): (key: K) => T[K] | N
factory<T extends { new(): any }>(Interface: T, ...params: ConstructorParameters<T>): () => InstanceType<T>

factorify helps remove tons of ifs and switches, also helps with strategies and commands.

const example = abstract.factorify({
  order: (user, id, message = "") => ({name: user.name, id, cancelled: false, message}),
  cancel: (user, id, message = "") => ({name: user.name, id, cancelled: true, message}),
  payments: (user, id, message = "") => ({name: user.name,}),
}, {user: null, id: 0});

const cancel = example("cancel");
const result = cancel({user: "John Doe", id: 5, message: "Service sucks"});
console.log(result); // {user: "John Doe", id: 5, cancelled: true, message: "Service sucks"}

const nullable = example("randomText");
const default = nullable({user: "John Doe", id: 5, message: "Test nullable"});
console.log(default); // {user: null, id: 0}

Array utils

valid(data: any): boolean
accessor<T>(array: Array<T>, meta: Record<string | symbol, number>): Array<T>

Access helps rid of unnamed values of the array.

const user = ["John Doe", 18, true];
const meta = {name: 0, age: 1, employed: 2};
array.accessor(user, meta);
console.log(user.name, user.age, user.employed); // "John Doe", 18, true

Async utils

promisify<F extends Callback>(fn: F): (...params: Parameters<F>) => any
compose<F extends CallbackAsync>(...fns: F[]): (...params: Parameters<F>) => Promise<any>
thenable<F extends Callback>(fn: F, ...params: Parameters<F>): Thenable<any>
pause(ms: number): Promise<void>
parallel<F extends CallbackAsync>(...fns: F[]): (...params: Parameters<F>) => Promise<any>

promisify allow to change callback last error first(errback) contract to Promise.

  const fsPromise = async.promisify(fs.readFile);
  const file = await fsPromise(__filename, "utf-8");
  console.log(file);

Buffer utils

random(length?: number): Thenable<Buffer>

Stream utils

read<T extends NodeJS.ReadableStream>(readable: T): Thenable<Buffer>

read helps with reading stream/readable, http socket for example.

  const handler = async(req, res) => {
    const body = await stream.read(req);
    console.log(body);
  };

number utils

safe(value: number): number
isSafe(value: number): boolean
positiveInt(value: number): boolean
cutFraction(value: number): number
total(dataset: number[]): number
average(dataset: number[]): number
percentRatio(amount: number, part: number): number
percentOf(base: number, percent: number): number

mixin utils

weakAssign<T extends object, M extends object>(target: T, mixin: M): M & T
forget<T extends object, K extends keyof T>(target: T, keys: K[]): any

date utils

verbalEpoch(input: string): number
verbal(input: string): number
unix(input: ConstructorParameters<DateConstructor>[0]): number
midnightUTC(input: ConstructorParameters<DateConstructor>[0]): number
midnight(input: ConstructorParameters<DateConstructor>[0]): number
difference(base: ConstructorParameters<DateConstructor>[0], target: ConstructorParameters<DateConstructor>[0]): number
reached(base: ConstructorParameters<DateConstructor>[0], target: ConstructorParameters<DateConstructor>[0]): boolean
DAY: number
HOUR: number
MINUTE: number
SECOND: number

HTTP utils

parseHost(host: string): string
parseCookies(cookie: string): Record<string, string>
createParams(params: string[][] | Record<string, string> | string | URLSearchParams): string
parseParams(params: string[][] | Record<string, string> | string | URLSearchParams): Record<string, string>
parseURL(pathname: string): URL

Misc utils

id<T>(entity: T): T
inRange<T extends string | number>(value: T, min: T, max: T): boolean
compose<F extends Callback>(...fns: F[]): (...params: Parameters<F>) => any
range(end: number, start?: number, step?: number): Generator<number>
partial<F extends Callback>(fn: F, ...params: Partial<Parameters<F>>): (...params: any) => any
projection<T extends [string, string | T, Callback], O extends object>(meta: T[], data: O): any

cache

cache({ ms, max }?: { ms?: number, max?: number }) => Set & Cache

  const store = cache({ max: 3, ms: 5000 });
  store("key", {data: 1});
  store("buffer", Buffer.from("Hello"));
  store("api-return", await someApi.get("something"));

  const data = store.get("key"); // {data: 1}

  store.limit(10); // max from 3 to 10;
  store.timeout(1000); // ms from 5000 to 1000