@produck/ow

Throwing exception regularly.

Installation

npm install @produck/ow

Usage

import * as Ow from '@produck/ow';

Ow.throw(value)

Throws the given value directly.

Ow.throw(new Error('something went wrong'));
// => throws Error: something went wrong

Ow.throw('plain string');
// => throws 'plain string'

Ow.Thrower(ErrorConstructor)

Creates a thrower function bound to the specified error constructor. The returned function accepts the same arguments as the error constructor and throws the constructed error.

const throwTypeError = Ow.Thrower(TypeError);

throwTypeError('invalid type');
// => throws TypeError: invalid type

class CustomError extends Error {
  constructor(message) {
    super(message);
    this.name = 'CustomError';
  }
}

const throwCustom = Ow.Thrower(CustomError);

throwCustom('custom message');
// => throws CustomError: custom message

Ow.Error

A collection of pre-built thrower functions for all built-in error types.

| Thrower | Error Type | | -------------------- | ---------------- | | Ow.Error.Common | Error | | Ow.Error.Eval | EvalError | | Ow.Error.Range | RangeError | | Ow.Error.Reference | ReferenceError | | Ow.Error.Syntax | SyntaxError | | Ow.Error.Type | TypeError | | Ow.Error.URI | URIError | | Ow.Error.Aggregate | AggregateError |

Ow.Error.Type('expected a string');
// => throws TypeError: expected a string

Ow.Error.Range('index out of bounds');
// => throws RangeError: index out of bounds

Ow.Error.Aggregate([err1, err2], 'multiple errors');
// => throws AggregateError: multiple errors

TypeScript

Type definitions are included. All thrower functions are fully typed with ConstructorParameters inference.

import * as Ow from '@produck/ow';

Ow.Error.Type('msg'); // (...args: ConstructorParameters<TypeErrorConstructor>) => never
Ow.throw(new Error()); // (any: unknown) => never

Why

In JavaScript, throw is a statement, not an expression. This means it cannot be used directly in arrow functions, ternary expressions, or logical chains. @produck/ow wraps throw into function calls, making exception throwing more flexible and composable.

// Without ow — statement only, cannot inline
if (!input) {
  throw new TypeError('input is required');
}

// With ow — works as an expression
const value = input ?? Ow.Error.Type('input is required');

// Arrow function — throw is not allowed in expression body
const assertString = (v) =>
  typeof v === 'string' || Ow.Error.Type('expected a string');

Thrower() creates reusable thrower functions that can be assigned, passed around, and shared — no need to repeat throw new XxxError(...) everywhere.

All thrower functions return never in TypeScript, so the compiler correctly infers that control flow does not continue past the call.

License

MIT © Produck Shop