implab/implabjs-djx Commit - r21:b1e622a3b266

Compatibility with dojo-typings package

cin -

r21:b1e622a3b266 default

parent child

Context file:

r21:b1e622a3b266

Collapse all files

src/main/ts/declare.ts +2 -1

              import declare = require("dojo/_base/declare");
              import { each } from "@implab/core-amd/safe";
              import { Constructor } from "@implab/core-amd/interfaces";
+             import dojo = require("dojo/_base/kernel");
              // declare const declare: any;
-             type DeclareConstructor<T> = declare.DeclareConstructor<T>;
+             type DeclareConstructor<T> = dojo._base.DeclareConstructor<T>;
              export interface AbstractConstructor<T = {}> {
                  prototype: T;
              }
              interface DjMockConstructor<T = {}> {
                  new(...args: any[]): T;
                  mock: boolean;
                  base: AbstractConstructor;
              }
              export function djbase<T>(
                  b0: AbstractConstructor<T>
              ): DeclareConstructor<T>;
              export function djbase<T0, T1>(
                  b0: AbstractConstructor<T0>,
                  b1: AbstractConstructor<T1>
              ): DeclareConstructor<T0 & T1>;
              export function djbase<T0, T1, T2>(
                  b0: AbstractConstructor<T0>,
                  b1: AbstractConstructor<T1>,
                  b2: AbstractConstructor<T2>
              ): DeclareConstructor<T0 & T1 & T2>;
              export function djbase<T0, T1, T2, T3>(
                  b0: AbstractConstructor<T0>,
                  b1: AbstractConstructor<T1>,
                  b2: AbstractConstructor<T2>,
                  b3: AbstractConstructor<T3>
              ): DeclareConstructor<T0 & T1 & T2 & T3>;
              export function djbase<T0, T1, T2, T3, T4>(
                  b0: AbstractConstructor<T0>,
                  b1: AbstractConstructor<T1>,
                  b2: AbstractConstructor<T2>,
                  b3: AbstractConstructor<T3>,
                  b4: AbstractConstructor<T4>
              ): DeclareConstructor<T0 & T1 & T2 & T3 & T4>;
              export function djbase<T0, T1, T2, T3, T4, T5>(
                  b0: AbstractConstructor<T0>,
                  b1: AbstractConstructor<T1>,
                  b2: AbstractConstructor<T2>,
                  b3: AbstractConstructor<T3>,
                  b4: AbstractConstructor<T4>,
                  b5: AbstractConstructor<T5>
              ): DeclareConstructor<T0 & T1 & T2 & T3 & T4 & T5>;
              export function djbase<T0, T1, T2, T3, T4, T5, T6>(
                  b0: AbstractConstructor<T0>,
                  b1: AbstractConstructor<T1>,
                  b2: AbstractConstructor<T2>,
                  b3: AbstractConstructor<T3>,
                  b4: AbstractConstructor<T4>,
                  b5: AbstractConstructor<T5>,
                  b6: AbstractConstructor<T6>
              ): DeclareConstructor<T0 & T1 & T2 & T3 & T4 & T5 & T6>;
              export function djbase<T0, T1, T2, T3, T4, T5, T6, T7>(
                  b0: AbstractConstructor<T0>,
                  b1: AbstractConstructor<T1>,
                  b2: AbstractConstructor<T2>,
                  b3: AbstractConstructor<T3>,
                  b4: AbstractConstructor<T4>,
                  b5: AbstractConstructor<T5>,
                  b6: AbstractConstructor<T6>,
                  b7: AbstractConstructor<T7>
              ): DeclareConstructor<T0 & T1 & T2 & T3 & T4 & T5 & T6 & T7>;
              /** Создает конструктор-заглушку из списка базовых классов, используется
               * для объявления классов при помощи `dojo/_base/declare`.
               *
               * Создает пустой конструтор, с пустым стандартным прототипом, это нужно,
               * поскольку в унаследованном классе конструктор обязательно должен вызвать
               * `super(...)`, таким образом он вызовет пустую функцию.
               *
               * Созданный конструтор хранит в себе список базовых классов, который будет
               * использован декоратором `djclass`, который вернет класс, объявленный при
               * помощи `dojo/_base/declare`.
               *
               * @param bases список базовых классов, от которых требуется унаследовать
               *  новый класс.
               *
               */
              export function djbase(...bases: any[]): Constructor {
                  const t = class {
                      static mock: boolean;
                      static base: AbstractConstructor;
                  };
                  t.mock = true;
                  t.base = declare(bases);
                  return t as any;
              }
              function isMockConstructor<T extends {}>(v: AbstractConstructor<T>): v is DjMockConstructor<T> {
                  return v && "mock" in v;
              }
              /** Создает класс при помощи `dojo/_base/declare`. Для этого исходный класс
               * должен быть унаследован от `djbase(...)`.
               *
               * @param target Класс, который нужно объявить при помощи `dojo/_base/declare`
               */
              export function djclass<T extends AbstractConstructor>(target: T): T {
                  // получаем базовый конструктор и его прототип
                  let bp = target && target.prototype && Object.getPrototypeOf(target.prototype);
                  const bc = bp && bp.constructor;
                  // проверка того, что класс унаследован от специальной заглушки
                  if (isMockConstructor(bc)) {
                      // t - базовый класс, объявленный при помощи dojo/_base/declare
                      const t = bc.base;
                      // bc - базовый класс, bc.prototype используется как super
                      // при вызове базовых методов. Нужно создать bc.prototype
                      // таким образом, чтобы он вызывал this.inherited().
                      // создаем новый порототип, он не в цепочке прототипов у текущего
                      // класса, но super.some_method будет использовать именно его.
                      // в этом объекте будут размещены прокси для переопределенных
                      // методов.
                      bp = bc.prototype = Object.create(t.prototype);
                      bp.constructor = bc;
                      // proxy - фабрика для создания прокси-методов, которые внутри
                      // себя вызовут this.inherited с правильными параметрами.
                      const proxy = (m: (...args: any[]) => any) => function (this: any) {
                          const f = this.getInherited({ callee: m });
                          return f && f.apply(this, arguments);
                          // так сделать можно только dojo 1.15+
                          // return this.inherited(m, arguments);
                      };
                      // у текущего класса прототип содержит методы, объявленные в этом
                      // классе и его конструктор. Нужно пройти по всем методам и
                      // создать для них прокси.
                      // При этом только те, методы, которые есть в базовых классах
                      // могут быть переопределены.
                      each(target.prototype, (m: any, p: string | number | symbol) => {
                          if (typeof m === "function" &&
                              p !== "constructor" &&
                              target.prototype.hasOwnProperty(p) &&
                              p in t.prototype
                          ) {
                              bp[p] = proxy(m);
                          }
                      });
                      const cls = declare(t, target.prototype);
                      // TODO mixin static members
                      return cls as any;
                  } else {
                      return target as any;
                  }
              }
              function makeSetterName(prop: string) {
                  return [
                      "_set",
                      prop.replace(/^./, x => x.toUpperCase()),
                      "Attr"
                  ].join("");
              }
              function makeGetterName(prop: string) {
                  return [
                      "_get",
                      prop.replace(/^./, x => x.toUpperCase()),
                      "Attr"
                  ].join("");
              }
              interface NodeBindSpec {
                  node: string;
                  type: string;
              }
              /**
               *  Описание привязки свойства виджета к свойству внутреннего объекта.
               */
              interface MemberBindSpec {
                  /**
                   * Имя свойства со ссылкой на объект, к которому .
                   */
                  member: string;
                  /**
                   * Свойство объекта к которому нужно осуществить привязку.
                   */
                  property: string;
                  /**
                   * Привязка осуществляется не только на запись но и на чтение свойства.
                   */
                  getter?: boolean;
              }
              function isNodeBindSpec(v: any): v is NodeBindSpec {
                  return "node" in v;
              }
              function isMemberBindSpec(v: any): v is MemberBindSpec {
                  return "member" in v;
              }
              /** Декорирует свойства виджета для привязки их к внутренним членам, либо DOM
               * элементам, либо свойству внутреннего объекта.
               *
               * @param {NodeBindSpec | MemberBindSpec} params Параметры связывания.
               */
              export function bind(params: NodeBindSpec | MemberBindSpec) {
                  if (isNodeBindSpec(params))
                      return (target: any, name: string) => {
                          target[makeSetterName(name)] = params;
                      };
                  else if (isMemberBindSpec(params)) {
                      return (target: any, name: string) => {
                          target[name] = null;
                          target[makeSetterName(name)] = function (v: any) {
                              this._set(name, v);
                              this[params.member].set(params.property, v);
                          };
                          if (params.getter)
                              target[makeGetterName(name)] = function () {
                                  return this[params.member].get(params.property);
                              };
                      };
                  }
              }

src/typings/dijit/_AttachMixin.d.ts +2 -1

              import { Handle } from "dojo/interfaces";
              import _WidgetBase = require("./_WidgetBase");
              import declare = require("dojo/_base/declare");
+             import dojo = require("dojo/_base/html");
              declare module "./_WidgetBase" {
                  interface _WidgetBase {
                      dojoAttachEvent: string;
                      dojoAttachPoint: string;
                  }
              }
              declare module "dojo/_base/kernel" {
                  interface Dijit {
                      _AttachMixin: _AttachMixinConstructor;
                  }
              }
              interface _AttachMixin {
                  /**
                   * List of widget attribute names associated with data-dojo-attach-point=... in the template, ex: ["containerNode", "labelNode"]
                   */
                  _attachPoints: string[];
                  /**
                   * List of connections associated with data-dojo-attach-event=... in the template
                   */
                  _attachEvents: Handle[];
                  /**
                   * Object to which attach points and events will be scoped.  Defaults to 'this'.
                   */
                  attachScope: any;
                  /**
                   * Search descendants of this.containerNode for data-dojo-attach-point and data-dojo-attach-event.
                   *
                   * Should generally be left false (the default value) both for performance and to avoid failures when this.containerNode holds other _AttachMixin instances with their own attach points and events.
                   */
                  searchContainerNode: boolean;
                  /**
                   * Attach to DOM nodes marked with special attributes.
                   */
                  buildRendering(): void;
                  /**
                   * hook for _WidgetsInTemplateMixin
                   */
                  _beforeFillContent(): void;
                  /**
                   * Iterate through the dom nodes and attach functions and nodes accordingly.
                   *
                   * Map widget properties and functions to the handlers specified in the dom node and it's descendants. This function iterates over all nodes and looks for these properties:
                   * - dojoAttachPoint/data-dojo-attach-point
                   * - dojoAttachEvent/data-dojo-attach-event
                   */
                  _attachTemplateNodes(rootNode: Element | Node): void;
                  /**
                   * Process data-dojo-attach-point and data-dojo-attach-event for given node or widget.
                   *
                   * Returns true if caller should process baseNode's children too.
                   */
                  _processTemplateNode<T extends (Element | Node | _WidgetBase)>(
                      baseNode: T,
                      getAttrFunc: (baseNode: T, attr: string) => string,
                      attachFunc: (node: T, type: string, func?: Function) => Handle
                  ): boolean;
                  /**
                   * Roughly corresponding to dojo/on, this is the default function for processing a data-dojo-attach-event.  Meant to attach to DOMNodes, not to widgets.
                   */
                  _attach(node: Element | Node, type: string, func?: Function): Handle;
                  /**
                   * Detach and clean up the attachments made in _attachtempalteNodes.
                   */
                  _detachTemplateNodes(): void;
                  destroyRendering(preserveDom?: boolean): void;
              }
-             interface _AttachMixinConstructor extends declare.DeclareConstructor<_AttachMixin> { }
+             interface _AttachMixinConstructor extends dojo._base.DeclareConstructor<_AttachMixin> { }
              declare const _AttachMixin: _AttachMixinConstructor;
              export = _AttachMixin;

src/typings/dojo/_base/declare.d.ts +130 -126

		@@ -1,138 +1,142
	1	import dojo = require("./kernel");
	2
1	3	declare module "./kernel" {
2	4	interface Dojo {
3		declare: d~~eclar~~e.Declare;
	5	declare: dojo._base.Declare;
4	6	safeMixin: typeof declare.safeMixin;
5	7	}
6		}
7
8		declare namespace declare {
9		interface DeclareCreatedObject {
10		declaredClass: string;
11
12		/**
13		* Calls a super method.
14		*
15		* This method is used inside method of classes produced with
16		* declare() to call a super method (next in the chain). It is
17		* used for manually controlled chaining. Consider using the regular
18		* chaining, because it is faster. Use "this.inherited()" only in
19		* complex cases.
20		*
21		* This method cannot me called from automatically chained
22		* constructors including the case of a special (legacy)
23		* constructor chaining. It cannot be called from chained methods.
24		*
25		* If "this.inherited()" cannot find the next-in-chain method, it
26		* does nothing and returns "undefined". The last method in chain
27		* can be a default method implemented in Object, which will be
28		* called last.
29		*
30		* If "name" is specified, it is assumed that the method that
31		* received "args" is the parent method for this call. It is looked
32		* up in the chain list and if it is found the next-in-chain method
33		* is called. If it is not found, the first-in-chain method is
34		* called.
35		*
36		* If "name" is not specified, it will be derived from the calling
37		* method (using a methoid property "nom").
38		*/
39		inherited<U>(args: IArguments, newArgs?: any[]): U;
40		inherited(args: IArguments, newArgs?: true): Function \| void;
41		inherited<U>(name: string, args: IArguments, newArgs?: any[]): U;
42		inherited(name: string, args: IArguments, newArgs?: true): Function \| void;
43
44		/**
45		* Returns a super method.
46		*
47		* This method is a convenience method for "this.inherited()".
48		* It uses the same algorithm but instead of executing a super
49		* method, it returns it, or "undefined" if not found.
50		*/
51		getInherited(args: IArguments): Function \| void;
52		getInherited(name: string, args: IArguments): Function \| void;
53
54		/**
55		* Checks the inheritance chain to see if it is inherited from this class.
56		*
57		* This method is used with instances of classes produced with
58		* declare() to determine of they support a certain interface or
59		* not. It models "instanceof" operator.
60		*/
61		isInstanceOf(cls: any): boolean;
62		}
63	8
64		interface DeclareConstructor<T> {
65		~~new(...args~~: ~~any[])~~: T & DeclareCreatedObject;
66		prototype: T;
	9	namespace _base {
	10	interface DeclareCreatedObject {
	11	declaredClass: string;
	12
	13	/**
	14	* Calls a super method.
	15	*
	16	* This method is used inside method of classes produced with
	17	* declare() to call a super method (next in the chain). It is
	18	* used for manually controlled chaining. Consider using the regular
	19	* chaining, because it is faster. Use "this.inherited()" only in
	20	* complex cases.
	21	*
	22	* This method cannot me called from automatically chained
	23	* constructors including the case of a special (legacy)
	24	* constructor chaining. It cannot be called from chained methods.
	25	*
	26	* If "this.inherited()" cannot find the next-in-chain method, it
	27	* does nothing and returns "undefined". The last method in chain
	28	* can be a default method implemented in Object, which will be
	29	* called last.
	30	*
	31	* If "name" is specified, it is assumed that the method that
	32	* received "args" is the parent method for this call. It is looked
	33	* up in the chain list and if it is found the next-in-chain method
	34	* is called. If it is not found, the first-in-chain method is
	35	* called.
	36	*
	37	* If "name" is not specified, it will be derived from the calling
	38	* method (using a methoid property "nom").
	39	*/
	40	inherited<U>(args: IArguments, newArgs?: any[]): U;
	41	inherited(args: IArguments, newArgs?: true): Function \| void;
	42	inherited<U>(name: string, args: IArguments, newArgs?: any[]): U;
	43	inherited(name: string, args: IArguments, newArgs?: true): Function \| void;
	44
	45	/**
	46	* Returns a super method.
	47	*
	48	* This method is a convenience method for "this.inherited()".
	49	* It uses the same algorithm but instead of executing a super
	50	* method, it returns it, or "undefined" if not found.
	51	*/
	52	getInherited(args: IArguments): Function \| void;
	53	getInherited(name: string, args: IArguments): Function \| void;
	54
	55	/**
	56	* Checks the inheritance chain to see if it is inherited from this class.
	57	*
	58	* This method is used with instances of classes produced with
	59	* declare() to determine of they support a certain interface or
	60	* not. It models "instanceof" operator.
	61	*/
	62	isInstanceOf(cls: any): boolean;
	63	}
	64
	65	interface DeclareConstructor<T> {
	66	new(...args: any[]): T & DeclareCreatedObject;
	67	prototype: T;
67	68
68		/**
69		* Adds all properties and methods of source to constructor's
70		* prototype, making them available to all instances created with
71		* constructor. This method is specific to constructors created with
72		* declare().
73		*
74		* Adds source properties to the constructor's prototype. It can
75		* override existing properties.
76		*
77		* This method is similar to dojo.extend function, but it is specific
78		* to constructors produced by declare(). It is implemented
79		* using dojo.safeMixin, and it skips a constructor property,
80		* and properly decorates copied functions.
81		*/
82		extend<U>(source: U): DeclareConstructor<T & U>;
	69	/**
	70	* Adds all properties and methods of source to constructor's
	71	* prototype, making them available to all instances created with
	72	* constructor. This method is specific to constructors created with
	73	* declare().
	74	*
	75	* Adds source properties to the constructor's prototype. It can
	76	* override existing properties.
	77	*
	78	* This method is similar to dojo.extend function, but it is specific
	79	* to constructors produced by declare(). It is implemented
	80	* using dojo.safeMixin, and it skips a constructor property,
	81	* and properly decorates copied functions.
	82	*/
	83	extend<U>(source: U): DeclareConstructor<T & U>;
83	84
84		/**
85		* Create a subclass of the declared class from a list of base classes.
86		*
87		* Create a constructor using a compact notation for inheritance and
88		* prototype extension.
89		*
90		* Mixin ancestors provide a type of multiple inheritance.
91		* Prototypes of mixin ancestors are copied to the new class:
92		* changes to mixin prototypes will not affect classes to which
93		* they have been mixed in.
94		*/
95		createSubclass<U, V, X>(mixins: [DeclareConstructor<U>, DeclareConstructor<V>], props: X): DeclareConstructor<T & U & V & X>;
96		createSubclass<U, V>(mixins: [DeclareConstructor<U>], props: V): DeclareConstructor<T & U & V>;
97		createSubclass<U, V>(mixins: DeclareConstructor<U>, props: V): DeclareConstructor<T & U & V>;
98		createSubclass<U>(mixins: [DeclareConstructor<U>]): DeclareConstructor<T & U>;
99		createSubclass<U>(mixins: DeclareConstructor<U>): DeclareConstructor<T & U>;
100		createSubclass<U>(mixins: any, props: U): DeclareConstructor<T & U>;
	85	/**
	86	* Create a subclass of the declared class from a list of base classes.
	87	*
	88	* Create a constructor using a compact notation for inheritance and
	89	* prototype extension.
	90	*
	91	* Mixin ancestors provide a type of multiple inheritance.
	92	* Prototypes of mixin ancestors are copied to the new class:
	93	* changes to mixin prototypes will not affect classes to which
	94	* they have been mixed in.
	95	*/
	96	createSubclass<U, V, X>(mixins: [DeclareConstructor<U>, DeclareConstructor<V>], props: X): DeclareConstructor<T & U & V & X>;
	97	createSubclass<U, V>(mixins: [DeclareConstructor<U>], props: V): DeclareConstructor<T & U & V>;
	98	createSubclass<U, V>(mixins: DeclareConstructor<U>, props: V): DeclareConstructor<T & U & V>;
	99	createSubclass<U>(mixins: [DeclareConstructor<U>]): DeclareConstructor<T & U>;
	100	createSubclass<U>(mixins: DeclareConstructor<U>): DeclareConstructor<T & U>;
	101	createSubclass<U>(mixins: any, props: U): DeclareConstructor<T & U>;
	102	}
	103
	104	interface Declare {
	105	<A, B, C, D>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>]): DeclareConstructor<A & B & C & D>;
	106	<A, B, C>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>]): DeclareConstructor<A & B & C>;
	107	<A, B>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>]): DeclareConstructor<A & B>;
	108	<A>(superClass: DeclareConstructor<A> \| [DeclareConstructor<A>]): DeclareConstructor<A>;
	109
	110	<A, B, C, D, E>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>], props: E): DeclareConstructor<A & B & C & D & E>;
	111	<A, B, C, D>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>], props: D): DeclareConstructor<A & B & C & D>;
	112	<A, B, C>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>], props: C): DeclareConstructor<A & B & C>;
	113	<A, B>(superClass: DeclareConstructor<A> \| [DeclareConstructor<A>], props: B): DeclareConstructor<A & B>;
	114
	115	<A, B, C, D>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>]): DeclareConstructor<A & B & C & D>;
	116	<A, B, C>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>]): DeclareConstructor<A & B & C>;
	117	<A, B>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>]): DeclareConstructor<A & B>;
	118	<A>(className: string, superClass: DeclareConstructor<A> \| [DeclareConstructor<A>]): DeclareConstructor<A>;
	119
	120	<A, B, C, D, E>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>], props: E): DeclareConstructor<A & B & C & D & E>;
	121	<A, B, C, D>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>], props: D): DeclareConstructor<A & B & C & D>;
	122	<A, B, C>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>], props: C): DeclareConstructor<A & B & C>;
	123	<A, B>(className: string, superClass: DeclareConstructor<A> \| [DeclareConstructor<A>], props: B): DeclareConstructor<A & B>;
	124
	125	<A>(className: string, superClass: any, props: A): DeclareConstructor<A>;
	126	(className: string, superClass: any): DeclareConstructor<any>;
	127	<A>(superClass: any, props: A): DeclareConstructor<A>;
	128	(superClass: any): DeclareConstructor<any>;
	129
	130	/**
	131	* Mix in properties skipping a constructor and decorating functions
	132	* like it is done by declare().
	133	*/
	134	safeMixin<A, B>(target: A, source: B): A & B;
	135	}
101	136	}
102	137
103		interface Declare {
104		<A, B, C, D>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>]): DeclareConstructor<A & B & C & D>;
105		<A, B, C>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>]): DeclareConstructor<A & B & C>;
106		<A, B>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>]): DeclareConstructor<A & B>;
107		<A>(superClass: DeclareConstructor<A> \| [DeclareConstructor<A>]): DeclareConstructor<A>;
108
109		<A, B, C, D, E>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>], props: E): DeclareConstructor<A & B & C & D & E>;
110		<A, B, C, D>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>], props: D): DeclareConstructor<A & B & C & D>;
111		<A, B, C>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>], props: C): DeclareConstructor<A & B & C>;
112		<A, B>(superClass: DeclareConstructor<A> \| [DeclareConstructor<A>], props: B): DeclareConstructor<A & B>;
113
114		<A, B, C, D>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>]): DeclareConstructor<A & B & C & D>;
115		<A, B, C>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>]): DeclareConstructor<A & B & C>;
116		<A, B>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>]): DeclareConstructor<A & B>;
117		<A>(className: string, superClass: DeclareConstructor<A> \| [DeclareConstructor<A>]): DeclareConstructor<A>;
118
119		<A, B, C, D, E>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>], props: E): DeclareConstructor<A & B & C & D & E>;
120		<A, B, C, D>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>], props: D): DeclareConstructor<A & B & C & D>;
121		<A, B, C>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>], props: C): DeclareConstructor<A & B & C>;
122		<A, B>(className: string, superClass: DeclareConstructor<A> \| [DeclareConstructor<A>], props: B): DeclareConstructor<A & B>;
123
124		<A>(className: string, superClass: any, props: A): DeclareConstructor<A>;
125		(className: string, superClass: any): DeclareConstructor<any>;
126		<A>(superClass: any, props: A): DeclareConstructor<A>;
127		(superClass: any): DeclareConstructor<any>;
128
129		/**
130		* Mix in properties skipping a constructor and decorating functions
131		* like it is done by declare().
132		*/
133		safeMixin<A, B>(target: A, source: B): A & B;
134		}
135	138	}
136	139
137		declare const declare: declare.Declare;
	140
	141	declare const declare: dojo._base.Declare;
138	142	export = declare;

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages