sindresorhus/is · error · TypeError

Expected value which is `integer`, received value of type `$

Error message

Expected value which is `integer`, received value of type `${is(value)}`.

What it means

Thrown by `assertInteger()` (source/index.ts:1693) when `Number.isInteger(value)` is false. Only actual number primitives with no fractional part pass — numeric strings, NaN, Infinity, floats, and BigInt all fail. The library asserts this before code that does indexing, counting, or bit math on the value.

Source

Thrown at source/index.ts:1695

		throw new TypeError(message ?? typeErrorMessage('Int16Array', value));
	}
}

export function assertInt32Array(value: unknown, message?: string): asserts value is Int32Array {
	if (!isInt32Array(value)) {
		throw new TypeError(message ?? typeErrorMessage('Int32Array', value));
	}
}

export function assertInt8Array(value: unknown, message?: string): asserts value is Int8Array {
	if (!isInt8Array(value)) {
		throw new TypeError(message ?? typeErrorMessage('Int8Array', value));
	}
}

export function assertInteger(value: unknown, message?: string): asserts value is number {
	if (!isInteger(value)) {
		throw new TypeError(message ?? typeErrorMessage('integer', value));
	}
}

export function assertIterable<T = unknown>(value: unknown, message?: string): asserts value is Iterable<T> {
	if (!isIterable(value)) {
		throw new TypeError(message ?? typeErrorMessage('Iterable', value));
	}
}

export function assertMap<Key = unknown, Value = unknown>(value: unknown, message?: string): asserts value is Map<Key, Value> {
	if (!isMap(value)) {
		throw new TypeError(message ?? typeErrorMessage('Map', value));
	}
}

export function assertNan(value: unknown, message?: string): asserts value is number {
	if (!isNan(value)) {
		throw new TypeError(message ?? typeErrorMessage('NaN', value));

View on GitHub ↗ (pinned to 7821031c66)

Solutions

Convert string input explicitly before asserting: `Number.parseInt(raw, 10)` or `Number(raw)`, then assert.
Round intentional floats with `Math.trunc`/`Math.round` if a whole number is the real requirement.
Guard upstream computation against NaN/Infinity (e.g. division by zero) instead of letting it reach the assert.
Use `assertSafeInteger()` if the value must also be within Number.MAX_SAFE_INTEGER.

Example fix

// before
const port = process.env.PORT;
assertInteger(port); // throws — it's a string
// after
const port = Number.parseInt(process.env.PORT ?? '3000', 10);
assertInteger(port);

Defensive patterns

Strategy: validation

Validate before calling

if (typeof value !== 'number' || !Number.isSafeInteger(value)) {
  throw new TypeError(`Expected integer, got ${value}`);
}

Type guard

const isInteger = (v: unknown): v is number => typeof v === 'number' && Number.isInteger(v);

Prevention

Parse user/string input with Number.parseInt and verify with Number.isInteger before passing on
Beware floating-point arithmetic producing 0.30000000000000004-style values — round explicitly if an integer is intended
Remember NaN, Infinity, and numeric strings all fail the integer check; validate at the trust boundary
Per this repo's CLAUDE.md, prefer branded guard types so the false branch doesn't narrow number to never

When it happens

Trigger: Calling `assertInteger()` with a numeric string ('42'), a float (3.5), NaN or Infinity from a failed calculation, a BigInt (42n), or undefined/null from a missing field.

Common situations: Values from `process.env`, CLI args, query strings, and form inputs are strings and are never coerced; division or parse results producing floats or NaN; JSON fields typed loosely. Note `Number.isInteger(5.0)` is true but `parseInt` leftovers like '5px' become NaN via `Number()`.

Related errors

AI-assisted analysis of sindresorhus/is@7821031c66 (2026-07-31). Data as JSON: /data/errors/ad7f28f87fd3609b.json. Report an issue: GitHub ↗.