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 +8 -4

+            import dojo = require("./kernel");
             declare module "./kernel" {
                 interface Dojo {
-                    declare: declare.Declare;
+                    declare: dojo._base.Declare;
                     safeMixin: typeof declare.safeMixin;
                 }
-            declare namespace declare {
+                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;
                         /**
                          * 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>;
                         /**
                          * 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;
                     }
                 }
-            declare const declare: declare.Declare;
+            declare const declare: dojo._base.Declare;
             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