implab/implabjs-djx Commit - r28:b88fac0e76c0

fixed strict mode @bind decorator

cin -

r28:b88fac0e76c0 v1.0.0-rc13 default

parent child

Context file:

r28:b88fac0e76c0

Collapse all files

src/test/ts/view/MyWidget.tsx created 644 +22 0

@@ -0,0 +1,22
	1	import { djbase, djclass, bind, prototype } from "../declare";
	2
	3	import { DjxWidgetBase } from "../tsx/DjxWidgetBase";
	4	import { createElement } from "../tsx";
	5
	6
	7	@djclass
	8	export class MyWidget extends djbase(DjxWidgetBase) {
	9
	10	@bind({node: "titleNode", type:"innerHTML"})
	11	title = "";
	12
	13	@prototype()
	14	counter = 0;
	15
	16	render() {
	17	return <div>
	18	<h1 data-dojo-attach-point="titleNode"></h1>
	19	</div>;
	20	}
	21
	22	}

build.gradle +1 -5

             plugins {
                 id "org.implab.gradle-typescript" version "1.3.3"
                 id "ivy-publish"
             }
             typescript {
                 compilerOptions {
                     lib = ["es5", "dom", "scripthost", "es2015.promise", "es2015.symbol", "es2015.iterable"]
                     //listFiles = true
                     declaration = true
                     strict = true
                     types = []
                     module = "amd"
                     it.target = "es5"
                     experimentalDecorators = true
                     jsx = "react"
                     jsxFactory = "createElement"
                     moduleResolution = "node"
                     // dojo-typings are sick
                     skipLibCheck = true
                     // traceResolution = true
                     // baseUrl = "./"
                     // paths = [ "*": [ "$projectDir/src/typings/*" ] ]
                     // baseUrl = "$projectDir/src/typings"
                     // typeRoots = ["$projectDir/src/typings"]
                 }
                 tscCmd = "$projectDir/node_modules/.bin/tsc"
                 tsLintCmd = "$projectDir/node_modules/.bin/tslint"
             	esLintCmd = "$projectDir/node_modules/.bin/eslint"
             }
             configureTsMain {
                 compilerOptions {
                     /*baseUrl = "$projectDir/src"
                     paths = [
                         "dojo/*" : [ "typings/dojo/*" ],
                         "dijit/*" : [ "typings/dijit/*" ]
                     ]*/
                     types = ["requirejs", "dojo-typings"]
                 }
             }
             configureTsTest {
                 compilerOptions {
-                    baseUrl = "."
+                    typeRoots = []
-                    paths = [
-                        "@implab/djx" : [ sources.main.output.typingsDir.get().toString() ],
-                        "@implab/djx/*" : [ "${sources.main.output.typingsDir.get().toString()}/*" ]
                     types = ["requirejs", sources.main.output.typingsDir.get().toString() ]
                 }
             }
             npmPackMeta {
                 meta {
                     name = "@$npmScope/$project.name"
                 }
             }
             task npmPackTypings(type: Copy) {
                 dependsOn typings
                 npmPackContents.dependsOn it
                 from typescript.typingsDir
                 into npm.packageDir
             }
             task printVersion {
                 doLast {
                     println "packageName: ${npmPackMeta.metadata.get().name}";
                     println "version: $version";
                     println "target: $typescript.compilerOptions.target";
                     println "module: $typescript.compilerOptions.module";
                     println "symbols: $symbols";
                 }
             }

src/main/ts/declare.ts +4 -8

             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: "attribute" | "innerText" | "textContent" | "innerHTML" | "class" | "toggleClass";
                 attribute?: string;
                 className?: 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))
+                if (isNodeBindSpec(params)) {
                     return (target: any, name: string) => {
                         target[makeSetterName(name)] = params;
                     };
-                else if (isMemberBindSpec(params)) {
+                } else {
                     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/tsconfig.json +2 -2

             {
                 "extends": "../tsconfig",
                 "compilerOptions": {
                     "rootDir": "ts",
                     "rootDirs": [
                         "ts",
                         "typings"
                     ],
                     "types": [
-                        "requirejs", "./typings/index", "dojo-typings"
+                        "requirejs", "./typings", "dojo-typings"
                     ]
                 }
-            }
  No newline at end of file

src/main/typings/index.d.ts +6 0

@@ -1,4 +1,10
1	declare module "@implab/djx/css!*" {	1	declare module "@implab/djx/css!*" {
2	const result: { url: string };	2	const result: { url: string };
3	export = result;	3	export = result;
4	}	4	}
		5
		6	declare namespace JSX {
		7	interface IntrinsicElements {
		8	[name: string]: any;
		9	}
		10	}

src/test/ts/dummy.ts +1 -2

             import { test } from "./TestTraits";
             import { delay } from "@implab/core-amd/safe";
             import { assert } from "chai";
-            import css = require("@implab/djx/css!my,css");
+            import css = require("@implab/djx/css!my.css");
-            import {} from "@implab/djx/i18n";
             test("simple", (ok, fail, log) => {
                 setTimeout(() => {
                     // end should be called after the last assertion
                     ok("async assert");
                 }, 100);
             });
             test("simple", async (log, fail) => {
                 await delay(0);
                 assert.ok(true); // everything is fine
             });

src/test/tsconfig.json +1 -6

             {
                 "extends": "../tsconfig",
                 "compilerOptions": {
-                    "baseUrl": ".",
                     //"rootDir": "ts",
                     "rootDirs": [
                         "ts",
                         "typings",
                         "../main/ts",
                         "../main/typings"
                     ],
-                    "paths": {
+                    "types": ["requirejs", "../main/typings", "dojo-typings"]
-                        "@implab/djx" : ["../main/ts", "../main/typings"],
-                        "@implab/djx/*" : ["../main/ts/*", "../main/typings/*" ]
-                    },
-                    "types": ["requirejs", "../main/typings"]
                 }
             }

src/tsconfig.json +1 -1

             {
                 "compilerOptions": {
                     "moduleResolution": "node",
                     "noEmitOnError": true,
                     "strict": true,
                     "types": [],
                     "experimentalDecorators": true,
                     "jsxFactory": "createElement",
-                    //"skipLibCheck": true,
+                    "skipLibCheck": true,
                     "jsx": "react",
                     "lib": ["es5", "es2015.promise", "es2015.symbol", "es2015.iterable", "dom", "scripthost"]
                 }
             }

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