Consider removing [key: string]: any from interfaces, and use type generics in function definitions.

[timbuckley]

Do you want to request a feature or report a bug?

Feature (for TypeScript users of Slate).

Problem discussion

In the current version of Slate core (v0.57.1), interfaces are declared in the following way

interface Text {
  text: string;
  [key: string]: any;
}

...and most Slate functions are written in a form like the following:

const Text = {
  //...
  decorations(node: Text, decorations: Range[]): Text[] {/* ... */}
}

The problem with this is that TypeScript users would likely want to constrain their Text nodes in their own way, above and beyond the underlying Text, Editor, etc interfaces, while still allowing them to be used directly in helper functions without using as type coercions.

For example:

interface CompanyText extends Text {
  isBold: boolean
  fontSize: number
}

const myTextNode: CompanyText = {text: 'foo', isBold: false, fontSize: 13}

Text.decorations(myTextNode, [])
// Type error! `myTextNode` is not of type `Text`

The CompanyText type is still overly permissive because a typo like isBeld is still allowed, despite the user's extended interface (thanks to key-any). And the user would also have to use myTextNode as Text when calling Text.decorations() on it, otherwise TypeScript will complain.

Proposed solution

Use type generics in functions, and remove the [key: string]: any from interfaces

interface Text {
  text: string;
}

const Text = {
  // ...
  decorations<T extends Text>(node: T, decorations: Range[]): T[]   {/* ... */}
}

This will allow TypeScript consumers of Slate to use it in the CompanyText example above.

[miracle2k]

This would also be a huge help in migrating existing code over to the new API, as I am currently undertaking. For example, an old-style call such as editor.setNodeByKey does not show a typing error once I switch the type over the new new Editor (which has an index-signature).