What is strictBindCallApply?

`strictBindCallApply` is a TypeScript compiler option that enables stricter type checking for the `bind`, `call`, and `apply` methods on functions. When enabled, it ensures that the `this` context and arguments passed to these methods are correctly typed according to the function's signature, preventing common runtime errors.

What is `strictBindCallApply`?

By default, TypeScript's Function.prototype.bind, Function.prototype.call, and Function.prototype.apply methods have very loose type signatures. This allows developers to call these methods with incompatible this contexts or arguments without a compile-time error, often leading to subtle runtime bugs, especially when dealing with the this keyword.

When strictBindCallApply is set to true in your tsconfig.json (either directly or as part of the strict compiler option), TypeScript applies much stricter type checking. It verifies that the this argument provided to call or apply, or bound by bind, matches the function's expected this type. Similarly, it ensures that the arguments provided align with the function's parameter types.

This option is part of TypeScript's broader strict mode. Enabling strict: true automatically enables strictBindCallApply along with other strict checks like noImplicitAny, strictNullChecks, strictFunctionTypes, etc.

Why is it useful?

• Improved Type Safety: It helps catch potential TypeError exceptions at compile time, such as 'Cannot read property 'x' of undefined' when this is incorrectly bound.
• Catches Common Runtime Errors: It prevents many common mistakes related to function contexts and argument spreading that might otherwise only surface during execution.
• Better IDE Support: With stricter types, IDEs can provide more accurate autocompletion and refactoring tools when working with bind, call, and apply.

Example

class MyClass {
  value = 10;

  printValue(multiplier: number): void {
    console.log(this.value * multiplier);
  }
}

const instance = new MyClass();

// --- Without strictBindCallApply (or with strict: false in tsconfig.json) ---
// This might compile successfully, but at runtime 'this.value' would be undefined
// if 'this' is not correctly bound to an object with a 'value' property.
// const badBoundPrint = instance.printValue.bind({ /* Missing 'value' property */ });
// badBoundPrint(2); // Runtime error: Cannot read properties of undefined (reading 'value')

// --- With strictBindCallApply (or with strict: true in tsconfig.json) ---
// The above line (badBoundPrint) would now produce a compile-time error:
// Argument of type '{}' is not assignable to parameter of type 'MyClass'.
//   Property 'value' is missing in type '{}' but required in type 'MyClass'.

// Correct usage:
const goodBoundPrint = instance.printValue.bind(instance);
goodBoundPrint(2); // Outputs: 20

// Example for 'call' with strictBindCallApply
instance.printValue.call({ value: 50 }, 3); // Outputs: 150 (implicitly OK as it has a 'value' property)
// instance.printValue.call({ /* Missing 'value' */ }, 3); // Compile error if strictBindCallApply is true