How to fix Function type '() => void' is not assignable to function type '() => undefined' in TypeScript

// BEFORE - causes error
type Handler = () => undefined;
const myHandler: Handler = () => {
  console.log("Hello");
  // Implicitly returns void, not undefined
};

// AFTER - fix by adding explicit return
type Handler = () => undefined;
const myHandler: Handler = () => {
  console.log("Hello");
  return undefined; // Explicitly return undefined
};

// OR change the type to void if appropriate
type Handler = () => void;
const myHandler: Handler = () => {
  console.log("Hello");
  // No return needed for void
};

// Function that doesn't return anything (void)
const logMessage = (msg: string): void => {
  console.log(msg);
};

// Type expecting undefined return
type Callback = () => undefined;

// Type assertion tells TypeScript to trust you
const callback: Callback = logMessage as () => undefined;

// Alternative syntax
const callback2: Callback = logMessage as unknown as () => undefined;

// Use with caution - only when you're sure the function
// won't be used in a context that depends on undefined return

// BEFORE - overly restrictive
interface EventEmitter {
  on(event: string, handler: () => undefined): void;
}

// AFTER - use void for callbacks that don't need to return values
interface EventEmitter {
  on(event: string, handler: () => void): void;
}

// Example usage with void
const emitter: EventEmitter = {
  on: (event, handler) => {
    // handler can return anything, we ignore it
    handler();
  }
};

emitter.on("click", () => {
  console.log("Clicked!");
  // Can return a value (ignored) or nothing
  return 42; // Allowed with void
});

// Library with incorrect type
declare module "bad-library" {
  export type BadCallback = () => undefined;
  export function register(callback: BadCallback): void;
}

// Your wrapper function
function wrapCallback(callback: () => void): () => undefined {
  return () => {
    callback();
    return undefined; // Explicit return to satisfy undefined type
  };
}

// Usage
import { register } from "bad-library";

const myHandler = () => {
  console.log("Handling event");
  // No return - void function
};

// Wrap to satisfy library's incorrect type
register(wrapCallback(myHandler));

// Alternative: inline wrapper
register(() => {
  myHandler();
  return undefined;
});

// Method 1: Overloads
function register(callback: () => void): void;
function register(callback: () => undefined): void;
function register(callback: (() => void) | (() => undefined)): void {
  // Implementation
  const result = callback();
  // result is void | undefined
}

// Method 2: Generic with conditional type
type CallbackReturn<T> = T extends void ? void : undefined;

function register<T extends void | undefined>(
  callback: () => T
): void {
  callback();
}

// Both work
register(() => { console.log("void"); });
register(() => { console.log("undefined"); return undefined; });

// Method 3: Union type (simplest)
type FlexibleCallback = (() => void) | (() => undefined);

function register(callback: FlexibleCallback): void {
  callback();
}

// void functions can return values in certain contexts
type VoidFunc = () => void;

// These are all valid!
const f1: VoidFunc = () => true;
const f2: VoidFunc = () => "hello";
const f3: VoidFunc = () => 42;
const f4: VoidFunc = () => ({ key: "value" });

// When called, the return values are treated as void
const result = f1(); // result has type void

// This enables common patterns
const numbers = [1, 2, 3];
const results = numbers.map(n => n * 2); // returns number[]
numbers.forEach(n => n * 2); // forEach expects (n) => void

// Key insight: If an API expects () => void, you can give it
// a function that returns anything, and it will work.
// The reverse is not true: () => void cannot be assigned to () => undefined.

// Use this knowledge to design better types:
// When in doubt, use 'void' for maximum compatibility