implab/implabjs-djx Commit - r24:9b77ac3bf8f2

Added @prototype decorator

cin -

r24:9b77ac3bf8f2 v1.0.0-rc11 default

parent child

Context file:

r24:9b77ac3bf8f2

Collapse all files

src/main/ts/declare.ts +15 0

              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> = 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);
                              };
                      };
                  }
              }
+             /** Создает в прототипе указанное свойство со значение `undefined`, данный
+              * декоратор следует использовать для свойств, у которых нет значения по-умолчанию
+              * и они не могут быть `null | undefined`
+              */
+             export function prototype(): (p: any, name: string) => void;
+             /** Создает в прототипе свойство с указанным значением.
+              * @param value Значение, которое будет указано в прототипе
+              */
+             export function prototype<T>(value: T): <P extends { [m in K]: T }, K extends keyof P>(p: P, name: K) => void;
+             export function prototype<T>(value?: T) {
+                 return <P extends { [m in K]: T }, K extends keyof P>(p: P, name: K) => {
+                     p[name] = value as any;
+                 };
+             }

src/main/ts/tsx/DjxFragment.ts +2 0

              import { _Widget } from "./WidgetContext";
              import { MapOf } from "@implab/core-amd/interfaces";
+             import { prototype } from "../declare";
              /** Special widget used to create a document fragment */
              export class DjxFragment implements _Widget {
+                 @prototype()
                  domNode: Node;
                  containerNode?: Node;
                  constructor() {
                      this.domNode = this.containerNode = document.createDocumentFragment();
                  }
                  get(attr: string) {
                      return undefined;
                  }
                  set(attr: string, value: any): void;
                  set(attrs: MapOf<any>): void;
                  set() {
                      /* do nothing */
                  }
              }
  No newline at end of file

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