How to fix Type predicate function does not correctly narrow type in TypeScript

// ❌ Wrong - returns boolean, no narrowing
function isString(value: unknown): boolean {
  return typeof value === 'string';
}

// ✅ Correct - type predicate syntax
function isString(value: unknown): value is string {
  return typeof value === 'string';
}

const x: string | number = 'hello';
if (isString(x)) {
  console.log(x.toUpperCase()); // x is narrowed to string
}

interface User {
  id: number;
  name: string;
}

// ❌ Wrong - checks for name but declares as User
function isUser(value: unknown): value is User {
  return typeof (value as any).name === 'string';
}

// ✅ Correct - checks all required properties
function isUser(value: unknown): value is User {
  return (
    typeof value === 'object' &&
    value !== null &&
    'id' in value &&
    'name' in value &&
    typeof (value as any).id === 'number' &&
    typeof (value as any).name === 'string'
  );
}

const items: (string | null)[] = ['hello', null, 'world', null];

// ❌ Wrong - TypeScript doesn't narrow automatically
const filtered = items.filter(item => item !== null);
// Type: (string | null)[]

// ✅ Correct - explicit type predicate function
function isNotNull<T>(value: T | null): value is T {
  return value !== null;
}

const filtered = items.filter(isNotNull);
// Type: string[]

// ❌ Problematic - Object type predicate doesn't narrow correctly
function isObject(value: unknown): value is Object {
  return typeof value === 'object' && value !== null;
}

const x: number | object = 42;
if (isObject(x)) {
  // Type may be inferred as number | Object (incorrect)
}

// ✅ Better - use specific object types or unknown
function isObject(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value);
}

// ❌ Wrong - not biconditional
// Returns true for small numbers, false for strings AND large numbers
function isSmallNumber(value: string | number): value is number {
  return typeof value === 'number' && value < 100;
}

// ✅ Correct - separates the type check from the value check
function isNumber(value: string | number): value is number {
  return typeof value === 'number';
}

function isSmallNumber(value: number): boolean {
  return value < 100;
}

// TypeScript 5.5+ can infer this as a type predicate
function isString(value: unknown) {
  return typeof value === 'string';
}

// Automatically inferred as: value is string
const items = ['a', 1, 'b', 2].filter(isString);
// Type: string[]

npm install typescript@latest

npx tsc --version