sindresorhus/is · error · TypeError

Expected value which is `non-empty map`, received value of t

Error message

Expected value which is `non-empty map`, received value of type `${is(value)}`.

What it means

Thrown by `assertNonEmptyMap()` (source/index.ts:1747) when the value is not a `Map` instance with `size > 0`. The library uses this assert to both validate at runtime and narrow the type to `Map<Key, Value>` for TypeScript; failure throws a TypeError reporting the actual detected type.

Source

Thrown at source/index.ts:1749

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

export function assertNodeStream(value: unknown, message?: string): asserts value is NodeStream {
	if (!isNodeStream(value)) {
		throw new TypeError(message ?? typeErrorMessage('Node.js Stream', value));
	}
}

export function assertNonEmptyArray<T = unknown, Item = unknown>(value: T | Item[], message?: string): asserts value is [Item, ...Item[]] {
	if (!isNonEmptyArray(value)) {
		throw new TypeError(message ?? typeErrorMessage('non-empty array', value));
	}
}

export function assertNonEmptyMap<Key = unknown, Value = unknown>(value: unknown, message?: string): asserts value is Map<Key, Value> {
	if (!isNonEmptyMap(value)) {
		throw new TypeError(message ?? typeErrorMessage('non-empty map', value));
	}
}

export function assertNonEmptyObject<Key extends keyof any = string, Value = unknown>(value: unknown, message?: string): asserts value is Record<Key, Value> {
	if (!isNonEmptyObject(value)) {
		throw new TypeError(message ?? typeErrorMessage('non-empty object', value));
	}
}

export function assertNonEmptySet<T = unknown>(value: unknown, message?: string): asserts value is Set<T> {
	if (!isNonEmptySet(value)) {
		throw new TypeError(message ?? typeErrorMessage('non-empty set', value));
	}
}

export function assertNonEmptyString(value: unknown, message?: string): asserts value is string {
	if (!isNonEmptyString(value)) {
		throw new TypeError(message ?? typeErrorMessage('non-empty string', value));

View on GitHub ↗ (pinned to 7821031c66)

Solutions

Convert plain objects with `new Map(Object.entries(obj))` before asserting.
If an empty Map is acceptable, use `assert.map(value)` or check `is.nonEmptyMap(value)` conditionally instead.
Fix initialization order so the Map is populated before the consumer asserts on it.

Example fix

// before
const lookup = JSON.parse(raw); // plain object
assert.nonEmptyMap(lookup);
// after
const lookup = new Map(Object.entries(JSON.parse(raw)));
assert.nonEmptyMap(lookup);

Defensive patterns

Strategy: validation

Validate before calling

if (value instanceof Map && value.size > 0) {
  assert.nonEmptyMap(value);
}

Type guard

function isNonEmptyMap<K, V>(v: unknown): v is Map<K, V> {
  return v instanceof Map && v.size > 0;
}

Try / catch

try {
  assert.nonEmptyMap(config);
} catch (error) {
  if (error instanceof TypeError) {
    // map is empty or not a Map — verify it was populated before use
  }
  throw error;
}

Prevention

Check map.size > 0 before asserting, especially after conditional population loops
Remember plain objects are not Maps — is.nonEmptyMap rejects {} and object literals
Use is.nonEmptyMap(value) in an if-statement when emptiness is a legitimate runtime state

When it happens

Trigger: Calling `assert.nonEmptyMap(value)` with `new Map()` (empty), with a plain object `{a: 1}` (objects are not Maps), a WeakMap, a JSON-parsed structure, or `undefined`.

Common situations: Passing a plain object where a Map is expected — especially after `JSON.parse`, since JSON cannot represent Maps; caches or registries that haven't been populated yet due to initialization order bugs.

Related errors

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