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