declare.d.ts
142 lines
| 7.7 KiB
| video/mp2t
|
TypeScriptLexer
cin
|
r21 | import dojo = require("./kernel"); | ||
|
cin
|
r15 | declare module "./kernel" { | ||
| interface Dojo { | ||||
|
cin
|
r21 | declare: dojo._base.Declare; | ||
|
cin
|
r15 | safeMixin: typeof declare.safeMixin; | ||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r21 | namespace _base { | ||
| interface DeclareCreatedObject { | ||||
| declaredClass: string; | ||||
| /** | ||||
| * Calls a super method. | ||||
| * | ||||
| * This method is used inside method of classes produced with | ||||
| * declare() to call a super method (next in the chain). It is | ||||
| * used for manually controlled chaining. Consider using the regular | ||||
| * chaining, because it is faster. Use "this.inherited()" only in | ||||
| * complex cases. | ||||
| * | ||||
| * This method cannot me called from automatically chained | ||||
| * constructors including the case of a special (legacy) | ||||
| * constructor chaining. It cannot be called from chained methods. | ||||
| * | ||||
| * If "this.inherited()" cannot find the next-in-chain method, it | ||||
| * does nothing and returns "undefined". The last method in chain | ||||
| * can be a default method implemented in Object, which will be | ||||
| * called last. | ||||
| * | ||||
| * If "name" is specified, it is assumed that the method that | ||||
| * received "args" is the parent method for this call. It is looked | ||||
| * up in the chain list and if it is found the next-in-chain method | ||||
| * is called. If it is not found, the first-in-chain method is | ||||
| * called. | ||||
| * | ||||
| * If "name" is not specified, it will be derived from the calling | ||||
| * method (using a methoid property "nom"). | ||||
| */ | ||||
| inherited<U>(args: IArguments, newArgs?: any[]): U; | ||||
| inherited(args: IArguments, newArgs?: true): Function | void; | ||||
| inherited<U>(name: string, args: IArguments, newArgs?: any[]): U; | ||||
| inherited(name: string, args: IArguments, newArgs?: true): Function | void; | ||||
| /** | ||||
| * Returns a super method. | ||||
| * | ||||
| * This method is a convenience method for "this.inherited()". | ||||
| * It uses the same algorithm but instead of executing a super | ||||
| * method, it returns it, or "undefined" if not found. | ||||
| */ | ||||
| getInherited(args: IArguments): Function | void; | ||||
| getInherited(name: string, args: IArguments): Function | void; | ||||
| /** | ||||
| * Checks the inheritance chain to see if it is inherited from this class. | ||||
| * | ||||
| * This method is used with instances of classes produced with | ||||
| * declare() to determine of they support a certain interface or | ||||
| * not. It models "instanceof" operator. | ||||
| */ | ||||
| isInstanceOf(cls: any): boolean; | ||||
| } | ||||
| interface DeclareConstructor<T> { | ||||
| new(...args: any[]): T & DeclareCreatedObject; | ||||
| prototype: T; | ||||
|
cin
|
r2 | |||
|
cin
|
r21 | /** | ||
| * Adds all properties and methods of source to constructor's | ||||
| * prototype, making them available to all instances created with | ||||
| * constructor. This method is specific to constructors created with | ||||
| * declare(). | ||||
| * | ||||
| * Adds source properties to the constructor's prototype. It can | ||||
| * override existing properties. | ||||
| * | ||||
| * This method is similar to dojo.extend function, but it is specific | ||||
| * to constructors produced by declare(). It is implemented | ||||
| * using dojo.safeMixin, and it skips a constructor property, | ||||
| * and properly decorates copied functions. | ||||
| */ | ||||
| extend<U>(source: U): DeclareConstructor<T & U>; | ||||
|
cin
|
r2 | |||
|
cin
|
r21 | /** | ||
| * Create a subclass of the declared class from a list of base classes. | ||||
| * | ||||
| * Create a constructor using a compact notation for inheritance and | ||||
| * prototype extension. | ||||
| * | ||||
| * Mixin ancestors provide a type of multiple inheritance. | ||||
| * Prototypes of mixin ancestors are copied to the new class: | ||||
| * changes to mixin prototypes will not affect classes to which | ||||
| * they have been mixed in. | ||||
| */ | ||||
| createSubclass<U, V, X>(mixins: [DeclareConstructor<U>, DeclareConstructor<V>], props: X): DeclareConstructor<T & U & V & X>; | ||||
| createSubclass<U, V>(mixins: [DeclareConstructor<U>], props: V): DeclareConstructor<T & U & V>; | ||||
| createSubclass<U, V>(mixins: DeclareConstructor<U>, props: V): DeclareConstructor<T & U & V>; | ||||
| createSubclass<U>(mixins: [DeclareConstructor<U>]): DeclareConstructor<T & U>; | ||||
| createSubclass<U>(mixins: DeclareConstructor<U>): DeclareConstructor<T & U>; | ||||
| createSubclass<U>(mixins: any, props: U): DeclareConstructor<T & U>; | ||||
| } | ||||
| interface Declare { | ||||
| <A, B, C, D>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>]): DeclareConstructor<A & B & C & D>; | ||||
| <A, B, C>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>]): DeclareConstructor<A & B & C>; | ||||
| <A, B>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>]): DeclareConstructor<A & B>; | ||||
| <A>(superClass: DeclareConstructor<A> | [DeclareConstructor<A>]): DeclareConstructor<A>; | ||||
| <A, B, C, D, E>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>], props: E): DeclareConstructor<A & B & C & D & E>; | ||||
| <A, B, C, D>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>], props: D): DeclareConstructor<A & B & C & D>; | ||||
| <A, B, C>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>], props: C): DeclareConstructor<A & B & C>; | ||||
| <A, B>(superClass: DeclareConstructor<A> | [DeclareConstructor<A>], props: B): DeclareConstructor<A & B>; | ||||
| <A, B, C, D>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>]): DeclareConstructor<A & B & C & D>; | ||||
| <A, B, C>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>]): DeclareConstructor<A & B & C>; | ||||
| <A, B>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>]): DeclareConstructor<A & B>; | ||||
| <A>(className: string, superClass: DeclareConstructor<A> | [DeclareConstructor<A>]): DeclareConstructor<A>; | ||||
| <A, B, C, D, E>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>], props: E): DeclareConstructor<A & B & C & D & E>; | ||||
| <A, B, C, D>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>], props: D): DeclareConstructor<A & B & C & D>; | ||||
| <A, B, C>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>], props: C): DeclareConstructor<A & B & C>; | ||||
| <A, B>(className: string, superClass: DeclareConstructor<A> | [DeclareConstructor<A>], props: B): DeclareConstructor<A & B>; | ||||
| <A>(className: string, superClass: any, props: A): DeclareConstructor<A>; | ||||
| (className: string, superClass: any): DeclareConstructor<any>; | ||||
| <A>(superClass: any, props: A): DeclareConstructor<A>; | ||||
| (superClass: any): DeclareConstructor<any>; | ||||
| /** | ||||
| * Mix in properties skipping a constructor and decorating functions | ||||
| * like it is done by declare(). | ||||
| */ | ||||
| safeMixin<A, B>(target: A, source: B): A & B; | ||||
| } | ||||
|
cin
|
r2 | } | ||
| } | ||||
|
cin
|
r21 | |||
| declare const declare: dojo._base.Declare; | ||||
|
cin
|
r2 | export = declare; | ||