implab/implabjs-dojo-typings Commit - r8:b71d8639b457

Maintenance release...

cin -

r8:b71d8639b457 v1.0.1 default

parent child

Context file:

r8:b71d8639b457

Collapse all files

dojo-typings/readme.md created 644 +33 0

			@@ -0,0 +1,33
		1	# dojo-typings
		2
		3	This project is forked from the original `dojo-typings` package to
		4	improve it with more tight and customizable type definitions.
		5
		6	The primary aims are
		7
		8	* Parametrize collections with items type.
		9	* Distinguish sync and async methods in stores.
		10	* Parametrize widget typings with event and attribute maps.
		11
		12	## Changes
		13
		14	### 1.0.1
		15
		16	Maintenance release
		17
		18	* `NodeList-fx` added overloads to all methods to distinguish returned values
		19	of different types (`Animation \| this`).
		20	* Added missing signatures to `NodeList` constructor
		21	* Improved `dijit.form._FormWidgetMixin`
		22	* Added module declarations `dijit/form/_FormWidgetMixin`,
		23	`dijit/form/_FormValueMixin`, `dijit/_HasDropDown`
		24
		25	### 1.0.0
		26
		27	Initial release
		28
		29	* Parametrized `dojo/Stateful`, `diji/_WidgetBase`
		30	* split `dojo.store.api.Store` in two `SyncStore` and `AsyncStore` interfaces
		31	* `dojo/store/Memory` implements `SyncStore` and can be used synchronously,
		32	* `dojo/store/Rest` implements `AsyncStore` and all its methods are
		33	returning explicit promises.

dojo-typings/src/test/ts/NodeListFxTests.ts created 644 +8 0

			@@ -0,0 +1,8
		1	import "dojo/NodeList-fx";
		2
		3	declare const nl: dojo.NodeList<Node>;
		4
		5	const anim: dojo._base.Animation = nl.fadeIn();
		6	const anim2: dojo._base.Animation = nl.fadeIn({duration: 500});
		7	const nl2: typeof nl = nl.fadeOut({auto: true, onEnd: () => {}});
		8	const other = nl.fadeOut({auto: false}); No newline at end of file

dojo-typings/src/main/typings/dijit/form.d.ts +47 -68

-             		/* dijit/form/_FormWidgetMixin */
+                     /**
+                      * Mixin for widgets corresponding to native HTML elements such as `<checkbox>` or `<button>`,
+                      * which can be children of a `<form>` node or a `dijit/form/Form` widget.
+                      *
+                      * Represents a single HTML element.
+                      * All these widgets should have these attributes just like native HTML input elements.
+                      * You can set them during widget construction or afterwards, via `dijit/_WidgetBase.set()`.
+                      *
+                      * They also share some common methods.
+                      */
-             		interface _FormWidgetMixin {
              			/**
-             			 * Name used when submitting form; same as "name" attribute or plain HTML elements
              			 */
-             			name: string;
-             			/**
-             			 * Corresponds to the native HTML `<input>` element's attribute.
-             			 */
+                         /** Corresponds to the native HTML `<input>` element's attribute. */
-             			alt: string;
-             			/**
-             			 * Corresponds to the native HTML `<input>` element's attribute.
-             			 */
+                         /** Corresponds to the native HTML `<input>` element's attribute. */
              			value: any;
-             			/**
-             			 * Corresponds to the native HTML `<input>` element's attribute.
-             			 */
+                         /** Corresponds to the native HTML `<input>` element's attribute. */
-             			type: string;
-             			/**
-             			 * Apply aria-label in markup to the widget's focusNode
-             			 */
-             			'aria-label': string;
+                         /** Apply aria-label in markup to the widget's focusNode */
+                         "aria-label": "focusNode";
-             			/**
-             			 * Order fields are traversed when user hits the tab key
-             			 */
+                         /** Order fields are traversed when user hits the tab key */
-             			tabIndex: number;
-             			/**
-             			 * Should this widget respond to user input?
+                         /** Should this widget respond to user input?
-             			 * In markup, this is specified as "disabled='disabled'", or just "disabled".
              			 */
-             			disabled: boolean;
-             			/**
-             			 * Fires onChange for each value change or only on demand
-             			 */
+                         /** Fires onChange for each value change or only on demand */
-             			intermediateChanges: boolean;
-             			/**
-             			 * On focus, should this widget scroll into view?
-             			 */
+                         /** On focus, should this widget scroll into view? */
-             			scrollOnFocus: boolean;
-             			/**
-             			 * Tells if this widget is focusable or not.  Used internally by dijit.
+                         _setDisabledAttr(value: boolean): void;
+                         _onFocus(by: string): void;
+                         /** Tells if this widget is focusable or not.  Used internally by dijit.
+                          * @protected
              			 */
-             			isFocusable(): boolean;
-             			/**
-             			 * Put focus on this widget
-             			 */
+                         /** Put focus on this widget */
-             			focus(): void;
-             			/**
-             			 * Compare 2 values (as returned by get('value') for this widget).
+                         /** Compare 2 values (as returned by get('value') for this widget).
+                          * @protected
              			 */
-             			compare(val1: any, val2: any): number;
-             			/**
-             			 * Callback when this widget's value is changed.
-             			 */
-             			onChange(value: string): void;
+                         onChange(newValue: any): void;
              			/**
-             			 * Overrides _Widget.create()
+                      * Hook so set('value', value) works.
+                      *
+                      * Sets the value of the widget.
+                      * If the value has changed, then fire onChange event, unless priorityChange
+                      * is specified as null (or false?)
+                      *
+                      * @param value
+                      * @param priorityChange
              			 */
-             			create(params?: any, srcNodeRef?: HTMLElement): void;
+                         _setValueAttr(value: any, priorityChange?: boolean);
-             			destroy(preserveDom?: boolean): void;
-             			// set(name: 'disabled', value: boolean): this;
-             			// set(name: string, value: any): this;
-             			// set(values: Object): this;
+                         /**
+                          * Called when the value of the widget has changed.  Saves the new value in this.value,
+                          * and calls onChange() if appropriate.   See _FormWidget._handleOnChange() for details.
+                          *
+                          * @param newValue
+                          * @param priorityChange
+                          */
+                         _handleOnChange(newValue: any, priorityChange?: boolean);
              		}
-             		/* dijit/form/_ListBase */
-             		/* dijit/form/TextBox */
-             		interface TextBox extends _FormValueWidget, _TextBoxMixin<Constraints> {
-             			// set(name: 'displayedValue', value: string): this;
-             			// set(name: 'disabled', value: boolean): this;
-             			// set(name: 'value', value: string): this;
-             			// set(name: string, value: any): this;
-             			// set(values: Object): this;
-             			// get(name: 'displayedValue'): string;
-             			// get(name: 'value'): string;
-             			// get(name: string): any;
              		}
-             		interface TextBoxConstructor extends _WidgetBaseConstructor<TextBox> { }
-             			baseClass: string;
-             			setChecked(checked: boolean): void;
-             			// set(name: 'checked', value: boolean): this;
-             			// set(name: string, value: any): this;
-             			// set(values: Object): this;
              		}
-             		interface ToggleButtonConstructor extends _WidgetBaseConstructor<ToggleButton> { }
-             			reset(): void;
-             			destroy(preserveDom?: boolean): void;
-             			// set(name: 'constraints', value: Constraints): this;
-             			// set(name: 'disabled', value: boolean): this;
-             			// set(name: 'message', value: string): this;
-             			// set(name: 'pattern', value: string | ConstraintsToRegExpString<C>): this;
-             			// set(name: 'regExp', value: string): this;
-             			// set(name: 'regExpGen', value: Constraints): this;
-             			// set(name: 'required', value: boolean): this;
-             			// set(name: 'value', value: string): this;
-             			// set(name: string, value: any): this;
-             			// set(values: Object): this;
-             			// get(name: 'pattern'): string | ConstraintsToRegExpString<C>;
-             			// get(name: string): any;
              		}
-             		interface ValidationTextBoxConstructor extends _WidgetBaseConstructor<ValidationTextBox<Constraints>> {

dojo-typings/src/main/typings/dijit/modules.d.ts +19 0

              	export = Dialog;
              }
+             declare module "dijit/_HasDropDown" {
+                 type _HasDropDown<T extends dijit._WidgetBase = dijit._WidgetBase> = dijit._HasDropDown<T>;
+                 const _HasDropDown: dijit._WidgetBaseConstructor<_HasDropDown>;
+                 export = _HasDropDown;
+             }
              declare module 'dijit/DropDownMenu' {
              	type DropDownMenu = dijit.DropDownMenu;
              	const DropDownMenu: dijit.DropDownMenuConstructor;
              	export = _FormMixin;
              }
+             declare module "dijit/form/_FormWidgetMixin" {
+                 type _FormWidgetMixin = dijit.form._FormWidgetMixin;
+                 const _FormWidgetMixin: dijit._WidgetBaseConstructor<_FormWidgetMixin>;
+                 export = _FormWidgetMixin;
+             }
+             declare module "dijit/form/_FormValueMixin" {
+                 type _FormValueMixin = dijit.form._FormValueMixin;
+                 const _FormValueMixin: dijit._WidgetBaseConstructor<_FormValueMixin>;
+                 export = _FormValueMixin;
+             }
              declare module 'dijit/form/_FormValueWidget' {
              	type _FormValueWidget = dijit.form._FormValueWidget;
              	const _FormValueWidget: dijit.form._FormValueWidgetConstructor;

dojo-typings/src/main/typings/dojo/NodeList-fx.d.ts +21 -9

              declare namespace dojo {
-             	interface NodeListAnimationArgs extends _base.AnimationArguments {
-             		auto?: boolean;
+                 interface NodeListAnimationArgs extends Omit<_base.AnimationArguments, "node"> {
+                     auto?: false;
+                 }
+                 interface NodeListAutoAnimationArgs extends Omit<_base.AnimationArguments, "node"> {
+                     auto: true;
              	}
-             	interface NodeList<T extends Node> {
-             		_anim(obj: any, method: string, args?: NodeListAnimationArgs): _base.Animation | this;
+                     _anim(obj: any, method: string, args?: NodeListAnimationArgs): _base.Animation;
+                     _anim(obj: any, method: string, args: NodeListAutoAnimationArgs): this;
              		/**
-             		 * wipe in all elements of this NodeList via `dojo/fx.wipeIn()`
              		 */
-             		wipeIn(args: NodeListAnimationArgs): _base.Animation | this;
+                     wipeIn(args?: NodeListAnimationArgs): _base.Animation;
+                     wipeIn(args: NodeListAutoAnimationArgs): this;
              		/**
-             		 * wipe out all elements of this NodeList via `dojo/fx.wipeOut()`
              		 */
-             		wipeOut(args: NodeListAnimationArgs): _base.Animation | this;
+                     wipeOut(args?: NodeListAnimationArgs): _base.Animation;
+                     wipeOut(args: NodeListAutoAnimationArgs): this;
              		/**
-             		 * slide all elements of the node list to the specified place via `dojo/fx.slideTo()`
              		 */
-             		slideTo(args: NodeListAnimationArgs): _base.Animation | this;
+                     slideTo(args?: NodeListAnimationArgs): _base.Animation;
+                     slideTo(args: NodeListAutoAnimationArgs): this;
              		/**
-             		 * fade in all elements of this NodeList via `dojo.fadeIn`
              		 */
-             		fadeIn(args: NodeListAnimationArgs): _base.Animation | this;
+                     fadeIn(args?: NodeListAnimationArgs): _base.Animation;
+                     fadeIn(args: NodeListAutoAnimationArgs): this;
              		/**
-             		 * fade out all elements of this NodeList via `dojo.fadeOut`
              		 */
-             		fadeOut(args: NodeListAnimationArgs): _base.Animation | this;
+                     fadeOut(args?: NodeListAnimationArgs): _base.Animation;
+                     fadeOut(args: NodeListAutoAnimationArgs): this;
              		/**
-             		 * Animate all elements of this NodeList across the properties specified.
-             		 * syntax identical to `dojo.animateProperty`
              		 */
-             		animateProperty(args: NodeListAnimationArgs): _base.Animation | this;
+                     animateProperty(args?: NodeListAnimationArgs): _base.Animation;
+                     animateProperty(args: NodeListAutoAnimationArgs): this;
              		/**
-             		 * Animate one or more CSS properties for all nodes in this list.

dojo-typings/src/main/typings/dojo/dojo.d.ts +5 -2

              	}
              	interface NodeListConstructor {
-             		new <T extends Node>(array: number | Array<T>): NodeList<T>;
+             		new <T extends Node>(array: number | Array<T> | NodeListOf<T>): NodeList<T>;
              		new <T extends Node>(...args: T[]): NodeList<T>;
-             		<T extends Node>(array: number | Array<T>): NodeList<T>;
+             		<T extends Node>(array: number | Array<T> | NodeListOf<T>): NodeList<T>;
              		<T extends Node>(...args: T[]): NodeList<T>;
              		prototype: NodeList<any>;
              		 * the search by. Returns an instance of NodeList.
              		 */
              		<T extends Node>(query: string, root?: NodeOrString): NodeList<T>;
+                     <T extends Node>(root: Node): NodeList<T>;
+                     NodeList: NodeListConstructor;
              		/**
              		 * Test to see if a node matches a selector

dojo-typings/src/test/tsconfig.json +2 -1

                      ],
                      "types": [
                          "requirejs",
-                         "../main/typings"
+                         "../main/typings",
+                         "../main/typings/dojo/NodeList-fx"
                      ],
                      "module": "ESNext",
                      "target": "ESNext"

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