implab/implabjs-djx Commit - r7:d14fb562b896

src/main/ts/tsx/BuildContextBase.ts created 644 +64 0

@@ -0,0 +1,64
	1	import { isNull, mixin, argumentNotNull } from "@implab/core-amd/safe";
	2	import { isPlainObject, isNode, isBuildContext } from "./traits";
	3
	4	export abstract class BuildContextBase {
	5	_attrs = {};
	6
	7	_children = new Array();
	8
	9	_created: boolean = false;
	10
	11	visitNext(v: any) {
	12	if (isNull(v))
	13	return;
	14
	15	if (isPlainObject(v)) {
	16
	17	if (this._created)
	18	this._setAttrs(v);
	19	else
	20	mixin(this._attrs, v);
	21
	22	} else {
	23	if (this._created)
	24	this._addChild(v);
	25	else
	26	this._children.push(v);
	27	}
	28	}
	29
	30	getChildDom(v: any) {
	31	const tv = typeof v;
	32	if (tv === "string" \|\| tv === "number" \|\| tv === "boolean" \|\| v instanceof RegExp \|\| v instanceof Date) {
	33	return document.createTextNode(v.toString());
	34	} else if (isNode(v)) {
	35	return v;
	36	} else if (isBuildContext(v)) {
	37	return v.getDomElement();
	38	} else {
	39	throw new Error("Invalid parameter");
	40	}
	41	}
	42
	43	abstract _getDomElement(): HTMLElement;
	44
	45	ensureCreated() {
	46	if (!this._created) {
	47	this._create(this._attrs, this._children);
	48	this._children = [];
	49	this._attrs = {};
	50	this._created = true;
	51	}
	52	}
	53
	54	getDomElement() {
	55	this.ensureCreated();
	56	return this._getDomElement();
	57	}
	58
	59	abstract _addChild(child: any): void;
	60
	61	abstract _setAttrs(attrs: object): void;
	62
	63	abstract _create(attrs: object, children: any[]): void;
	64	}

src/main/ts/tsx/DjxWidgetBase.ts created 644 +51 0

@@ -0,0 +1,51
	1	import { djbase, djclass } from "../declare";
	2	import _WidgetBase = require("dijit/_WidgetBase");
	3	import _AttachMixin = require("dijit/_AttachMixin");
	4	import { BuildContext, isNode } from "./traits";
	5	import registry = require("dijit/registry");
	6	// import { Handle } from "dojo/interfaces";
	7	type Handle = dojo.Handle;
	8
	9	@djclass
	10	export abstract class DjxWidgetBase extends djbase(_WidgetBase, _AttachMixin) {
	11
	12	buildRendering() {
	13	this.domNode = this.render().getDomElement();
	14	super.buildRendering();
	15	}
	16
	17	abstract render(): BuildContext;
	18
	19	_processTemplateNode<T extends (Element \| Node \| _WidgetBase)>(
	20	baseNode: T,
	21	getAttrFunc: (baseNode: T, attr: string) => string,
	22	// tslint:disable-next-line: ban-types
	23	attachFunc: (node: T, type: string, func?: Function) => Handle
	24	): boolean {
	25	if (isNode(baseNode)) {
	26	const w = registry.byNode(baseNode);
	27	if (w) {
	28	// from dijit/_WidgetsInTemplateMixin
	29	this._processTemplateNode(w,
	30	(n, p) => n.get(p), // callback to get a property of a widget
	31	(widget, type, callback) => {
	32	if (!callback)
	33	throw new Error("The callback must be specified");
	34
	35	// callback to do data-dojo-attach-event to a widget
	36	if (type in widget) {
	37	// back-compat, remove for 2.0
	38	return widget.connect(widget, type, callback as EventListener);
	39	} else {
	40	// 1.x may never hit this branch, but it's the default for 2.0
	41	return widget.on(type, callback);
	42	}
	43
	44	});
	45	// don't process widgets internals
	46	return false;
	47	}
	48	}
	49	return super._processTemplateNode(baseNode, getAttrFunc, attachFunc);
	50	}
	51	}

src/main/ts/tsx/HtmlElementContext.ts created 644 +45 0

@@ -0,0 +1,45
	1	import dom = require("dojo/dom-construct");
	2	import attr = require("dojo/dom-attr");
	3	import { argumentNotEmptyString } from "@implab/core-amd/safe";
	4	import { BuildContextBase } from "./BuildContextBase";
	5
	6	export class HtmlElementContext extends BuildContextBase {
	7	elementType: string;
	8
	9	_element: HTMLElement \| undefined;
	10
	11	constructor(elementType: string) {
	12	argumentNotEmptyString(elementType, "elementType");
	13	super();
	14
	15	this.elementType = elementType;
	16	}
	17
	18	_addChild(child: any): void {
	19	if (!this._element)
	20	throw new Error("The HTML element isn't created");
	21	dom.place(this.getChildDom(child), this._element);
	22	}
	23
	24	_setAttrs(attrs: object): void {
	25	if (!this._element)
	26	throw new Error("The HTML element isn't created");
	27
	28	attr.set(this._element, attrs);
	29	}
	30
	31	_create(attrs: object, children: any[]) {
	32	this._element = dom.create(this.elementType, attrs);
	33
	34	if (children)
	35	children.forEach(v => this._addChild(v));
	36	}
	37
	38	_getDomElement() {
	39	if (!this._element)
	40	throw new Error("The HTML element isn't created");
	41
	42	return this._element;
	43	}
	44
	45	}

src/main/ts/tsx/WidgetContext.ts created 644 +43 0

@@ -0,0 +1,43
	1	import dom = require("dojo/dom-construct");
	2	import { argumentNotNull } from "@implab/core-amd/safe";
	3	import _WidgetBase = require("dijit/_WidgetBase");
	4	import { BuildContextBase } from "./BuildContextBase";
	5
	6	type _WidgetBaseConstructor = typeof _WidgetBase;
	7
	8	export class WidgetContext extends BuildContextBase {
	9	widgetClass: _WidgetBaseConstructor;
	10
	11	_instance: _WidgetBase \| undefined;
	12
	13	constructor(widgetClass: _WidgetBaseConstructor) {
	14	super();
	15	argumentNotNull(widgetClass, "widgetClass");
	16
	17	this.widgetClass = widgetClass;
	18	}
	19
	20	_addChild(child: any): void {
	21	if (!this._instance \|\| !this._instance.containerNode)
	22	throw new Error("Widget doesn't support adding children");
	23
	24	dom.place(this.getChildDom(child), this._instance.containerNode);
	25	}
	26
	27	_setAttrs(attrs: object): void {
	28	this._instance?.set(attrs);
	29	}
	30
	31	_create(attrs: object, children: any[]) {
	32	this._instance = new this.widgetClass(this._attrs);
	33	if (children)
	34	children.forEach(x => this._addChild(x));
	35	}
	36
	37	_getDomElement() {
	38	if (!this._instance)
	39	throw new Error("The instance of the widget isn't created");
	40	return this._instance.domNode;
	41	}
	42
	43	}

src/main/ts/tsx/traits.ts created 644 +32 0

@@ -0,0 +1,32
	1	import _WidgetBase = require("dijit/_WidgetBase");
	2
	3	type _WidgetBaseConstructor = typeof _WidgetBase;
	4
	5
	6	export interface BuildContext {
	7	getDomElement(): HTMLElement;
	8	}
	9
	10	export function isNode(el: any): el is HTMLElement {
	11	return el && el.nodeName && el.nodeType;
	12	}
	13
	14	export function isWidget(v: any): v is _WidgetBase {
	15	return v && "domNode" in v;
	16	}
	17
	18	export function isBuildContext(v: any): v is BuildContext {
	19	return typeof v === "object" && typeof v.getDomElement === "function";
	20	}
	21
	22	export function isPlainObject(v: object) {
	23	if (typeof v !== "object")
	24	return false;
	25
	26	const vp = Object.getPrototypeOf(v);
	27	return !vp \|\| vp === Object.prototype;
	28	}
	29
	30	export function isWidgetConstructor(v: any): v is _WidgetBaseConstructor {
	31	return typeof v === "function" && v.prototype && "domNode" in v.prototype;
	32	}

src/main/typings/index.d.ts created 644 +4 0

@@ -0,0 +1,4
	1	declare module "@implab/djx/css!*" {
	2	declare const result: { url: string };
	3	export = result;
	4	}

build.gradle +3 -3

             plugins {
-                id "org.implab.gradle-typescript" version "1.3.1"
+                id "org.implab.gradle-typescript" version "1.3.2"
                 id "ivy-publish"
             }
             }
             task npmPackTypings(type: Copy) {
-                dependsOn sources.main.output
+                dependsOn typings
                 npmPackContents.dependsOn it
-                from sources.main.output.typingsDir
+                from typescript.typingsDir
                 into npm.packageDir
             }

src/main/ts/css.ts +1 -1

-            import inject = require("./inject");
+            import inject = require("./dom-inject");
             import { id as mid} from "module";
             import { TraceSource } from "@implab/core-amd/log/TraceSource";
             const log = TraceSource.get(mid);

src/main/ts/tsx.ts +3 -3

             import { Constructor } from "@implab/core-amd/interfaces";
-            import { HtmlElementContext } from "./djx/HtmlElementContext";
+            import { HtmlElementContext } from "./tsx/HtmlElementContext";
-            import { WidgetContext } from "./djx/WidgetContext";
+            import { WidgetContext } from "./tsx/WidgetContext";
-            import { isWidgetConstructor, BuildContext } from "./djx/traits";
+            import { isWidgetConstructor, BuildContext } from "./tsx/traits";
             export function createElement<T extends Constructor>(elementType: string | T, ...args: any[]): BuildContext {
                 if (typeof elementType === "string") {

src/test/ts/dummy.ts +2 0

             import { test } from "./TestTraits";
             import { delay } from "@implab/core-amd/safe";
             import { assert } from "chai";
+            import "@implab/djx";
+            import css = require("@implab/djx/css!my,css");
             test("simple", (ok, fail, log) => {
                 setTimeout(() => {

src/test/tsconfig.json +8 -1

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

src/main/ts/djx/BuildContextBase.ts removed 0 -64

NO CONTENT: file was removed

src/main/ts/djx/DjxWidgetBase.ts removed 0 -51

NO CONTENT: file was removed

src/main/ts/djx/HtmlElementContext.ts removed 0 -45

NO CONTENT: file was removed

src/main/ts/djx/WidgetContext.ts removed 0 -43

NO CONTENT: file was removed

src/main/ts/djx/traits.ts removed 0 -32

NO CONTENT: file was removed

	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