Adding typings

[TomSwiedler]

I was working to create a tonic.d.ts file when I ran into the following issue:

HTMLElement defines the click method as: click(): void. This is use to simulate a click on the element in code.

Tonic uses the the click signature: click(e:Event): void;

This can be handled in tonic.d.ts by adding: click(e?:Event):void

However it requires the implementation of the click handlers to use click(e?:Event): void for their signatures.

Would it make sense to use onClick(e?:Event) or similar in the Tonic implementation rather than overloading the click method of the HTMLElement?

[Raynos]

Does typescript support method overloading ?

Can we implement click(e: Event): void and then ignore the fact the base class also implements click(): void.

At some point I was thinking of adding JSDoc annotations to Tonic to make it more typescript friendly.

[heapwolf]

If someone wants the base class' behavior of .click(), they could implement their click handler like...

click (e) {
  if (!e) super.click()
  /* ... */
}

in that case, click(e?: Event): void makes sense.

Another thing to consider is sometimes methods are async...

async click (e) {
  if (!e) return super.click()
  /* ... */
}

So maybe something like click(e?: Event): void|Promise<Any> makes sense?

[TomSwiedler]

So something like:

declare class TonicTemplate {
constructor(rawText: string, templateStrings: string[], unsafe: boolean);

valueOf(): string;
toString(): string;
}

export default class Tonic extends HTMLElement {
new(): Tonic;
html(TemplateStringArray, values?: string[]): string;
static add(c: typeof Tonic, tagName?: string);
static escape(s: string): string;
static unsafeRawString(s: string, templateStrings: string[] | null): TonicTemplate;
static match(el: HTMLElement, selector: string);
click(e?:Event): void | Promise;
}

[heapwolf]

Is there a way to write a test for this?

[TomSwiedler]

I will look into into it. It is really only a syntax check issue. I am not sure if we would need to widen some of the types to accommodate desired overloads.