Unknown syntax in typescript interface - syntax

Question

I have a definition file with this in it:
interface _Form {
Dump:string;
}
interface Form extends _Form { constructor:{ new():Form }; }
What is the meaning of constructor:{ new():Form };?
If I try to implement this interface with this:
class MyForm implements Form {
Dump:string;
}
I get this error:
Class 'MyForm' incorrect implements interface 'Form'.
Types of property 'constructor' are incompatible.
Type 'Function' is not assignable to type 'new() => Form'.
Type 'Function' provides no match for signature 'new(): Form'

Answer 1

What you did is defined that Form has a property named constructor and it's a Form constructor (that is, a function which returns a new instance of Form).
To explain, consider the following:
class Form {}
type FormConstructor = { new(): Form };
let formCtor: FormConstructor = Form;
let form: Form = new formCtor();
You can also define static properties/functions this way:
class Form {
private dump: string;
constructor() {}
static fromDump(dump: string): Form {
let form = new Form();
form.dump = dump;
return form;
}
}
type FormConstructor = {
new(): Form;
fromDump: (dump: string) => Form;
};
let form1: Form = new Form();
let form2: Form = Form.fromDump("dump");
let formCtor: FormConstructor = Form;
let form3: Form = new formCtor();
let form4: Form = formCtor.fromDump("dump");
A good example for this is the Array (lib.ts & lib.es6.ts) and ArrayConstructor (lib.d.ts & lib.es6.d.ts).
In your case though I don't see a reason for this, and you probably just want to define a class constructor:
interface Form {
dump: string;
}
class MyForm implements Form {
dump: string;
constructor(dump: string) {
this.dump = dump;
}
}
You don't need to specify in the interface that implementing classes need to have a ctor, that's a given.
Edit
If that interface is auto generated then you need to stop using whatever it is that generates it because it's doing an awful job.
That interface is (I'm pretty sure) impossible to implement, here's something close:
interface _Form {
Dump:string;
}
interface Form extends _Form { ctor:{ new():Form }; }
class MyForm implements Form {
public ctor: { new():Form };
public Dump: string;
constructor() {
this.ctor = MyForm;
}
}
(code in playground)
It's exactly the same except that I changed it from constructor to ctor, and it compiles fine (though still it makes no sense).
If you change the ctor to constructor:
class MyForm implements Form {
public constructor: { new():Form };
public Dump: string;
constructor() {
this.constructor = MyForm;
}
}
you'll get errors because the class constructor (which is a keyword) needs to be a function and only one using that name.