implab/implabjs-djx Commit - r19:8f4d5e2c719a

Added DjxFragment...

cin -

r19:8f4d5e2c719a v1.0.0-rc8 default

parent child

Context file:

r19:8f4d5e2c719a

Collapse all files

src/main/ts/tsx/DjxFragment.ts created 644 +23 0

			@@ -0,0 +1,23
		1	import { _Widget } from "./WidgetContext";
		2	import { MapOf } from "@implab/core-amd/interfaces";
		3
		4	/** Special widget used to create a document fragment */
		5	export class DjxFragment implements _Widget {
		6
		7	domNode: Node;
		8
		9	containerNode?: Node;
		10
		11	constructor() {
		12	this.domNode = this.containerNode = document.createDocumentFragment();
		13	}
		14
		15	get(attr: string) {
		16	return undefined;
		17	}
		18	set(attr: string, value: any): void;
		19	set(attrs: MapOf<any>): void;
		20	set() {
		21	/* do nothing */
		22	}
		23	} No newline at end of file

src/main/ts/dom-inject.ts +2 0

                          trace.log("done {0}", url);
                      } catch (e) {
                          trace.error("failed {0}: {1}", url, e);
+                         throw e;
                      }
                  }
                          trace.log("done {0}", url);
                      } catch (e) {
                          trace.error("failed {0}: {1}", url, e);
+                         throw e;
                      }
                  }
              };

src/main/ts/tsx/BuildContextBase.ts +10 -5

-             import { isNull, mixin, argumentNotNull } from "@implab/core-amd/safe";
+             import { isNull, mixin } from "@implab/core-amd/safe";
              import { isPlainObject, isNode, isBuildContext, DojoNodePosition, BuildContext } from "./traits";
              import dom = require("dojo/dom-construct");
                      } else if (isNode(v)) {
                          return v;
                      } else if (isBuildContext(v)) {
-                         return v.getDomElement();
+                         return v.getDomNode();
                      } else {
                          throw new Error("Invalid parameter");
                      }
                  }
-                 abstract _getDomElement(): HTMLElement;
+                 abstract _getDomNode(): Node;
                  ensureCreated() {
                      if (!this._created) {
                      }
                  }
+                 /** @deprecated use getDomNode() */
                  getDomElement() {
+                     return this.getDomNode();
+                 }
+                 getDomNode() {
                      this.ensureCreated();
-                     return this._getDomElement();
+                     return this._getDomNode();
                  }
                  placeAt(refNode: string | Node, position?: DojoNodePosition) {
-                     dom.place(this.getDomElement(), refNode, position);
+                     dom.place(this.getDomNode(), refNode, position);
                  }
                  abstract _addChild(child: any): void;

src/main/ts/tsx/DjxWidgetBase.ts +1 -1

              export abstract class DjxWidgetBase extends djbase(_WidgetBase, _AttachMixin) {
                  buildRendering() {
-                     this.domNode = this.render().getDomElement();
+                     this.domNode = this.render().getDomNode();
                      super.buildRendering();
                  }

src/main/ts/tsx/HtmlElementContext.ts +1 -1

                          children.forEach(v => this._addChild(v));
                  }
-                 _getDomElement() {
+                 _getDomNode() {
                      if (!this._element)
                          throw new Error("The HTML element isn't created");

src/main/ts/tsx/WidgetContext.ts +18 -6

              import dom = require("dojo/dom-construct");
              import { argumentNotNull } from "@implab/core-amd/safe";
-             import _WidgetBase = require("dijit/_WidgetBase");
              import { BuildContextBase } from "./BuildContextBase";
+             import { MapOf } from "@implab/core-amd/interfaces";
-             type _WidgetBaseConstructor = typeof _WidgetBase;
+             // tslint:disable-next-line: class-name
+             export interface _Widget {
+                 domNode: Node;
+                 get(attr: string): any;
+                 set(attr: string, value: any): void;
+                 set(attrs: MapOf<any>): void;
+                 containerNode?: Node
+             }
+             export type _WidgetCtor = new (attrs: any, srcNode?: string | Node) => _Widget;
              export class WidgetContext extends BuildContextBase {
-                 widgetClass: _WidgetBaseConstructor;
+                 widgetClass: _WidgetCtor;
-                 _instance: _WidgetBase | undefined;
+                 _instance: _Widget | undefined;
-                 constructor(widgetClass: _WidgetBaseConstructor) {
+                 constructor(widgetClass: _WidgetCtor) {
                      super();
                      argumentNotNull(widgetClass, "widgetClass");
                          children.forEach(x => this._addChild(x));
                  }
-                 _getDomElement() {
+                 _getDomNode() {
                      if (!this._instance)
                          throw new Error("The instance of the widget isn't created");
                      return this._instance.domNode;

src/main/ts/tsx/traits.ts +30 -2

              export type DojoNodePosition = "first" | "after" | "before" | "last" | "replace" | "only" | number;
              export interface BuildContext {
-                 getDomElement(): HTMLElement;
+                 getDomNode(): Node;
                  placeAt(refNode: string | Node, position?: DojoNodePosition): void;
              }
-             export function isNode(el: any): el is HTMLElement {
+             export function isNode(el: any): el is Node {
                  return el && el.nodeName && el.nodeType;
              }
+             export function isElementNode(el: any): el is Element {
+                 return isNode(el) && el.nodeType === 1;
+             }
+             export function isTextNode(el: any): el is Text {
+                 return isNode(el) && el.nodeType === 3;
+             }
+             export function isProcessingInstructionNode(el: any): el is ProcessingInstruction {
+                 return isNode(el) && el.nodeType === 7;
+             }
+             export function isCommentNode(el: any): el is Comment {
+                 return isNode(el) && el.nodeType === 8;
+             }
+             export function isDocumentNode(el: any): el is Document {
+                 return isNode(el) && el.nodeType === 9;
+             }
+             export function isDocumentTypeNode(el: any): el is DocumentType {
+                 return isNode(el) && el.nodeType === 10;
+             }
+             export function isDocumentFragmentNode(el: any): el is DocumentFragment {
+                 return isNode(el) && el.nodeType === 11;
+             }
              export function isWidget(v: any): v is _WidgetBase {
                  return v && "domNode" in v;
              }

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