implab/implabjs-djx Commit - r22:a1ab2b5975ad

Switched to dojo-typings...

cin -

r22:a1ab2b5975ad v1.0.0-rc10 default

parent child

Context file:

r22:a1ab2b5975ad

Collapse all files

build.gradle +3 -3

             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"
+                    /*baseUrl = "$projectDir/src"
                     paths = [
                         "dojo/*" : [ "typings/dojo/*" ],
                         "dijit/*" : [ "typings/dijit/*" ]
+                    ]*/
-                    types = ["requirejs", "$projectDir/src/typings/dojo/index" /*, "dojo-typings"*/]
+                    types = ["requirejs", "dojo-typings"]
                 }
             }
             configureTsTest {
                 compilerOptions {
                     baseUrl = "."
                     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/tsx/BuildContextBase.ts +2 -2

             import { isNull, mixin } from "@implab/core-amd/safe";
             import { isPlainObject, isNode, isBuildContext, DojoNodePosition, BuildContext } from "./traits";
             import dom = require("dojo/dom-construct");
-            export abstract class BuildContextBase implements BuildContext {
+            export abstract class BuildContextBase<TNode extends Node> implements BuildContext<TNode> {
                 _attrs = {};
                 _children = new Array();
                 _created: boolean = false;
                 visitNext(v: any) {
                     if (isNull(v))
                         return;
                     if (isPlainObject(v)) {
                         if (this._created)
                             this._setAttrs(v);
                         else
                             mixin(this._attrs, v);
                     } else if (v instanceof Array) {
                         v.forEach(x => this._addChild(x));
                     } else {
                         if (this._created)
                             this._addChild(v);
                         else
                             this._children.push(v);
                     }
                 }
                 getChildDom(v: any) {
                     const tv = typeof v;
                     if (tv === "string" || tv === "number" || tv === "boolean" || v instanceof RegExp || v instanceof Date) {
                         return document.createTextNode(v.toString());
                     } else if (isNode(v)) {
                         return v;
                     } else if (isBuildContext(v)) {
                         return v.getDomNode();
                     } else {
                         throw new Error("Invalid parameter");
                     }
                 }
-                abstract _getDomNode(): Node;
+                abstract _getDomNode(): TNode;
                 ensureCreated() {
                     if (!this._created) {
                         this._create(this._attrs, this._children);
                         this._children = [];
                         this._attrs = {};
                         this._created = true;
                     }
                 }
                 /** @deprecated use getDomNode() */
                 getDomElement() {
                     return this.getDomNode();
                 }
                 getDomNode() {
                     this.ensureCreated();
                     return this._getDomNode();
                 }
                 placeAt(refNode: string | Node, position?: DojoNodePosition) {
                     dom.place(this.getDomNode(), refNode, position);
                 }
                 abstract _addChild(child: any): void;
                 abstract _setAttrs(attrs: object): void;
                 abstract _create(attrs: object, children: any[]): void;
             }

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

             import { djbase, djclass } from "../declare";
             import _WidgetBase = require("dijit/_WidgetBase");
             import _AttachMixin = require("dijit/_AttachMixin");
             import { BuildContext, isNode } from "./traits";
             import registry = require("dijit/registry");
-            import { Handle } from "dojo/interfaces";
             // type Handle = dojo.Handle;
             @djclass
             export abstract class DjxWidgetBase extends djbase(_WidgetBase, _AttachMixin) {
                 buildRendering() {
                     this.domNode = this.render().getDomNode();
                     super.buildRendering();
                 }
-                abstract render(): BuildContext;
+                abstract render(): BuildContext<HTMLElement>;
                 _processTemplateNode<T extends (Element | Node | _WidgetBase)>(
                     baseNode: T,
                     getAttrFunc: (baseNode: T, attr: string) => string,
                     // tslint:disable-next-line: ban-types
-                    attachFunc: (node: T, type: string, func?: Function) => Handle
+                    attachFunc: (node: T, type: string, func?: Function) => dojo.Handle
                 ): boolean {
                     if (isNode(baseNode)) {
                         const w = registry.byNode(baseNode);
                         if (w) {
                             // from dijit/_WidgetsInTemplateMixin
                             this._processTemplateNode(w,
                                 (n, p) => n.get(p), // callback to get a property of a widget
                                 (widget, type, callback) => {
                                     if (!callback)
                                         throw new Error("The callback must be specified");
                                     // callback to do data-dojo-attach-event to a widget
                                     if (type in widget) {
                                         // back-compat, remove for 2.0
                                         return widget.connect(widget, type, callback as EventListener);
                                     } else {
                                         // 1.x may never hit this branch, but it's the default for 2.0
                                         return widget.on(type, callback);
                                     }
                                 });
                             // don't process widgets internals
                             return false;
                         }
                     }
                     return super._processTemplateNode(baseNode, getAttrFunc, attachFunc);
                 }
             }

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

             import dom = require("dojo/dom-construct");
             import attr = require("dojo/dom-attr");
             import { argumentNotEmptyString } from "@implab/core-amd/safe";
             import { BuildContextBase } from "./BuildContextBase";
-            export class HtmlElementContext extends BuildContextBase {
+            export class HtmlElementContext extends BuildContextBase<HTMLElement> {
                 elementType: string;
                 _element: HTMLElement | undefined;
                 constructor(elementType: string) {
                     argumentNotEmptyString(elementType, "elementType");
                     super();
                     this.elementType = elementType;
                 }
                 _addChild(child: any): void {
                     if (!this._element)
                         throw new Error("The HTML element isn't created");
                     dom.place(this.getChildDom(child), this._element);
                 }
                 _setAttrs(attrs: object): void {
                     if (!this._element)
                         throw new Error("The HTML element isn't created");
                     attr.set(this._element, attrs);
                 }
                 _create(attrs: object, children: any[]) {
                     this._element = dom.create(this.elementType, attrs);
                     if (children)
                         children.forEach(v => this._addChild(v));
                 }
                 _getDomNode() {
                     if (!this._element)
                         throw new Error("The HTML element isn't created");
                     return this._element;
                 }
             }

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

             import dom = require("dojo/dom-construct");
             import { argumentNotNull } from "@implab/core-amd/safe";
             import { BuildContextBase } from "./BuildContextBase";
             import { MapOf } from "@implab/core-amd/interfaces";
             // 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 {
+            export class WidgetContext extends BuildContextBase<Node> {
                 widgetClass: _WidgetCtor;
                 _instance: _Widget | undefined;
                 constructor(widgetClass: _WidgetCtor) {
                     super();
                     argumentNotNull(widgetClass, "widgetClass");
                     this.widgetClass = widgetClass;
                 }
                 _addChild(child: any): void {
                     if (!this._instance || !this._instance.containerNode)
                         throw new Error("Widget doesn't support adding children");
                     dom.place(this.getChildDom(child), this._instance.containerNode);
                 }
                 _setAttrs(attrs: object): void {
                     this._instance?.set(attrs);
                 }
                 _create(attrs: object, children: any[]) {
                     this._instance = new this.widgetClass(this._attrs);
                     if (children)
                         children.forEach(x => this._addChild(x));
                 }
                 _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 +2 -2

             import _WidgetBase = require("dijit/_WidgetBase");
             type _WidgetBaseConstructor = typeof _WidgetBase;
             export type DojoNodePosition = "first" | "after" | "before" | "last" | "replace" | "only" | number;
-            export interface BuildContext {
+            export interface BuildContext<TNode extends Node = Node> {
-                getDomNode(): Node;
+                getDomNode(): TNode;
                 placeAt(refNode: string | Node, position?: DojoNodePosition): void;
             }
             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;
             }
             export function isBuildContext(v: any): v is BuildContext {
                 return typeof v === "object" && typeof v.getDomElement === "function";
             }
             export function isPlainObject(v: object) {
                 if (typeof v !== "object")
                     return false;
                 const vp = Object.getPrototypeOf(v);
                 return !vp || vp === Object.prototype;
             }
             export function isWidgetConstructor(v: any): v is _WidgetBaseConstructor {
                 return typeof v === "function" && v.prototype && "domNode" in v.prototype;
             }

src/main/tsconfig.json +1 -6

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

src/typings/dijit/_AttachMixin.d.ts +1 -2

             import { Handle } from "dojo/interfaces";
             import _WidgetBase = require("./_WidgetBase");
-            import declare = require("dojo/_base/declare");
+            import dojo = require("dojo/_base/kernel");
-            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 dojo._base.DeclareConstructor<_AttachMixin> { }
             declare const _AttachMixin: _AttachMixinConstructor;
             export = _AttachMixin;

src/typings/dijit/_WidgetBase.d.ts +2 -1

             import Stateful = require("dojo/Stateful");
             import Destroyable = require("./Destroyable");
             import { ExtensionEvent } from "dojo/on";
             import { NodeFragmentOrString, Handle, NodeOrString, WatchHandle } from "dojo/interfaces";
+            import dojo = require("dojo/_base/kernel");
             declare namespace _WidgetBase {
                 interface _WidgetBase extends Stateful, Destroyable {
                     /**
                      * A unique, opaque ID string that can be assigned by users or by the
                      * system. If the developer passes an ID which is known not to be
                      * unique, the specified ID is ignored and the system-generated ID is
                      * used instead.
                      */
                     id: string;
                     /**
                      * Rarely used.  Overrides the default Dojo locale used to render this widget,
                      * as defined by the [HTML LANG](http://www.w3.org/TR/html401/struct/dirlang.html#adef-lang) attribute.
                      * Value must be among the list of locales specified during by the Dojo bootstrap,
                      * formatted according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt) (like en-us).
                      */
                     lang: string;
                     /**
                      * Bi-directional support, as defined by the [HTML DIR](http://www.w3.org/TR/html401/struct/dirlang.html#adef-dir)
                      * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
                      * default direction.
                      */
                     dir: string;
                     /**
                      * HTML class attribute
                      */
                     class: string;
                     /**
                      * HTML style attributes as cssText string or name/value hash
                      */
                     style: string;
                     /**
                      * HTML title attribute.
                      *
                      * For form widgets this specifies a tooltip to display when hovering over
                      * the widget (just like the native HTML title attribute).
                      *
                      * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
                      * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
                      * interpreted as HTML.
                      */
                     title: string;
                     /**
                      * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
                      * this specifies the tooltip to appear when the mouse is hovered over that text.
                      */
                     tooltip: string;
                     /**
                      * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
                      * widget state.
                      */
                     baseClass: string;
                     /**
                      * pointer to original DOM node
                      */
                     srcNodeRef: HTMLElement;
                     /**
                      * This is our visible representation of the widget! Other DOM
                      * Nodes may by assigned to other properties, usually through the
                      * template system's data-dojo-attach-point syntax, but the domNode
                      * property is the canonical "top level" node in widget UI.
                      */
                     domNode: HTMLElement;
                     /**
                      * Designates where children of the source DOM node will be placed.
                      * "Children" in this case refers to both DOM nodes and widgets.
                      */
                     containerNode: HTMLElement;
                     /**
                      * The document this widget belongs to.  If not specified to constructor, will default to
                      * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
                      */
                     ownerDocument: HTMLElement;
                     /**
                      * Deprecated.	Instead of attributeMap, widget should have a _setXXXAttr attribute
                      * for each XXX attribute to be mapped to the DOM.
                      */
                     attributeMap: { [attribute: string]: any };
                     /**
                      * Bi-directional support,	the main variable which is responsible for the direction of the text.
                      * The text direction can be different than the GUI direction by using this parameter in creation
                      * of a widget.
                      */
                     textDir: string;
                     /**
                      * Kicks off widget instantiation.  See create() for details.
                      */
                     postscript(params?: any, srcNodeRef?: HTMLElement): void;
                     /**
                      * Kick off the life-cycle of a widget
                      */
                     create(params?: any, srcNodeRef?: HTMLElement): void;
                     /**
                      * Called after the parameters to the widget have been read-in,
                      * but before the widget template is instantiated. Especially
                      * useful to set properties that are referenced in the widget
                      * template.
                      */
                     postMixInProperties(): void;
                     /**
                      * Construct the UI for this widget, setting this.domNode.
                      * Most widgets will mixin `dijit._TemplatedMixin`, which implements this method.
                      */
                     buildRendering(): void;
                     /**
                      * Processing after the DOM fragment is created
                      */
                     postCreate(): void;
                     /**
                      * Processing after the DOM fragment is added to the document
                      */
                     startup(): void;
                     /**
                      * Destroy this widget and its descendants
                      */
                     destroyRecursive(preserveDom?: boolean): void;
                     /**
                      * Destroys the DOM nodes associated with this widget.
                      */
                     destroyRendering(preserveDom?: boolean): void;
                     /**
                      * Recursively destroy the children of this widget and their
                      * descendants.
                      */
                     destroyDescendants(preserveDom?: boolean): void;
                     /**
                      * Deprecated. Override destroy() instead to implement custom widget tear-down
                      * behavior.
                      */
                     uninitialize(): boolean;
                     /**
                      * Used by widgets to signal that a synthetic event occurred, ex:
                      * |	myWidget.emit("attrmodified-selectedChildWidget", {}).
                      */
                     emit(type: string, eventObj?: any, callbackArgs?: any[]): any;
                     /**
                      * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
                      */
                     on(type: string | ExtensionEvent, func: EventListener | Function): WatchHandle;
                     /**
                      * Returns a string that represents the widget.
                      */
                     toString(): string;
                     /**
                      * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
                      * is this widget.   Note that it does not return all descendants, but rather just direct children.
                      */
                     getChildren<T extends _WidgetBase>(): T[];
                     /**
                      * Returns the parent widget of this widget.
                      */
                     getParent<T extends _WidgetBase>(): T;
                     /**
                      * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                      */
                     connect(obj: any, event: string | ExtensionEvent, method: string | EventListener): WatchHandle;
                     /**
                      * Deprecated, will be removed in 2.0, use handle.remove() instead.
                      */
                     disconnect(handle: WatchHandle): void;
                     /**
                      * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                      */
                     subscribe(t: string, method: EventListener): WatchHandle;
                     /**
                      * Deprecated, will be removed in 2.0, use handle.remove() instead.
                      */
                     unsubscribe(handle: WatchHandle): void;
                     /**
                      * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                      */
                     isLeftToRight(): boolean;
                     /**
                      * Return true if this widget can currently be focused
                      * and false if not
                      */
                     isFocusable(): boolean;
                     /**
                      * Place this widget somewhere in the DOM based
                      * on standard domConstruct.place() conventions.
                      */
                     placeAt<T extends _WidgetBase>(reference: NodeFragmentOrString | T, position?: string | number): this;
                     /**
                      * Wrapper to setTimeout to avoid deferred functions executing
                      * after the originating widget has been destroyed.
                      * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                      */
                     defer(fcn: Function, delay?: number): Handle;
                 }
-                interface _WidgetBaseConstructor<W = _WidgetBase> extends DeclareConstructor<W> {
+                interface _WidgetBaseConstructor<W = _WidgetBase> extends dojo._base.DeclareConstructor<W> {
                     new(params: Object, srcNodeRef?: NodeOrString): W;
                 }
             }
             type _WidgetBase = _WidgetBase._WidgetBase;
             declare const _WidgetBase: _WidgetBase._WidgetBaseConstructor;
             export = _WidgetBase;

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