Add support to define cause type, instead of always unknown

[rentalhost]

lib Update Request

Configuration Check

My compilation target is ES2022 and my lib is the default.

Missing / Incorrect Definition

I would like to suggest to improve the Error type to accept generic, so we can define an error cause directly, without workarounds on class constructors.

https://github.com/microsoft/TypeScript/blob/main/src/lib/es2022.error.d.ts

interface ErrorOptions<C = unknown> {
    cause?: C;
}

interface Error<C = unknown> {
    cause?: C;
}

interface ErrorConstructor<C = unknown> {
    new (message?: string, options?: ErrorOptions<C>): Error<C>;
    (message?: string, options?: ErrorOptions<C>): Error<C>;
}

// so on...

Sample Code

// Currently:
class CurrentlyError extends Error { }

throw new CurrentlyError("message", { cause: { code: 123 } }); // Nothing: Validates incorrectly
throw new CurrentlyError("message", { cause: { code: 'abc' } }); // Nothing: Validates incorrectly

// Workarounded:
class WorkaroundedError extends Error {
  cause: { code: number }
  constructor(message: string, cause: { cause: number }) {
    super(message, cause);
  }
}

throw new WorkaroundedError("message", { cause: { code: 123 } }); // OK: Validates correctly
throw new WorkaroundedError("message", { cause: { code: 'abc' } }); // Error: Validates correctly

// Suggestion:
class SuggestionError extends Error<{ code: number }> { }

throw new SuggestionError("message", { cause: { code: 123 } }); // OK: Validates correctly
throw new SuggestionError("message", { cause: { code: 'abc' } }); // Error: Validates correctly

[fatcerberus]

Constraining cause in this way doesn't really make sense IMO as its intended use case was meant to be

try {
    // whatever
}
catch (e) {
    throw FooError("Something stupid happened", { cause: e });
}

[rentalhost]

So maybe it must be set as cause?: Error?

[RyanCavanaugh]

cause is meant to wrap the inner exception, and the inner exception can be literally anything (throw null; is legal JS). So there's not really any point to try to declare this in the first place, especially with an unenforceable generic