implab/implabjs-dojo-typings Commit - r2:1e22cac2aaf4

Added events map support to _WidgetBase, corrected attributes map support in _WidgetBase

cin -

r2:1e22cac2aaf4 v1.0.0-rc1 default

parent child

Context file:

r2:1e22cac2aaf4

Collapse all files

dojo-typings/src/test/typings/traits.d.ts created 644 +25 0

@@ -0,0 +1,25
	1	import * as _WidgetBase from "dijit/_WidgetBase";
	2	import * as Stateful from "dojo/Stateful";
	3
	4	export interface IRemovable {
	5	remove(): void;
	6	}
	7
	8	type StatefulAttrs<T> = T extends Stateful<infer A> ? A : never;
	9
	10	interface WatchFn {
	11	<T extends Stateful, K extends keyof StatefulAttrs<T>>(
	12	target: T,
	13	prop: K,
	14	render: (model: StatefulAttrs<T>[K]) => any,
	15	own?: (obj: IRemovable) => void
	16	);
	17	<W extends _WidgetBase, K extends keyof W>(
	18	target: W,
	19	prop: K,
	20	render: (model: W[K]) => any,
	21	own?: (obj: IRemovable) => void
	22	);
	23	}
	24
	25	export declare const watch: WatchFn;

dojo-typings/src/main/typings/dijit/dijit.d.ts +100 -23

                     onClose(): boolean;
                 }
+                interface _WidgetBase {
+                    /**
+                     * Used across all instances a hash to cache attribute names and their getter
+                     * and setter names.
+                     */
+                    _attrPairNames: { [attr: string]: string };
+                    /**
+                     * Helper function for get() and set().
+                     * Caches attribute name values so we don't do the string ops every time.
+                     */
+                    _getAttrNames(name: string): string;
+                    /**
+                     * Internal helper for directly changing an attribute value.
+                     * This method id derived from Stateful and must not be used!
+                     * @deprecated use `_set(name, value)` instead.
+                     */
+                    _changeAttrValue(name: string, value: any): this;
+                    get<K extends keyof this & string>(name: K): this[K];
+                    /**
+                     * Helper function to set new value for specified property, and call handlers
+                     * registered with watch() if the value has changed.
+                     * @param name
+                     * @param value
+                     */
+                    _set<K extends keyof this>(name: K, value: this[K]): void;
+                    /**
+                     * Helper function to get value for specified property stored by this._set(),
+                     * i.e. for properties with custom setters.  Used mainly by custom getters.
+                     *
+                     * For example, CheckBox._getValueAttr() calls this._get("value").
+                     * @param name
+                     */
+                    _get<K extends keyof this>(name: K): this[K];
+                    /**
+                     * Set a property on a Stateful instance
+                     */
+                    set<K extends keyof this & string>(name: K, value: this[K]): this;
+                    set<K extends { [p in keyof this]: this[p] extends any[] ? p : never; }[keyof this & string]>(name: K, ...values: this[K]): this;
+                    set(values: Partial<this>): this;
+                    /**
+                     * Watches a property for changes
+                     */
+                    watch(callback: <K extends keyof any>(prop: K, oldValue: any, newValue: any) => void): dojo.WatchHandle;
+                    watch<K extends keyof this>(name: K, callback: (prop: K, oldValue: this[K], newValue: this[K]) => void): dojo.WatchHandle;
+                }
+                type EventInitArgs<T extends Event> = {
+                    [p in keyof T]?: T[p] extends (...args: any) => any ? never : T[p];
+                };
                 /* dijit/_WidgetBase */
-            	interface _WidgetBase<Attrs = any> extends dojo.Stateful<Attrs & _WidgetBase>, Destroyable {
+                interface _WidgetBase<Events extends { [name in keyof Events]: Event } = GlobalEventHandlersEventMap> extends Destroyable {
                     /**
                      * A unique, opaque ID string that can be assigned by users or by the
                      */
                     textDir: string;
+                    _started?: boolean;
                     /**
                      * Kicks off widget instantiation.  See create() for details.
                      */
                     /**
                      * Deprecated. Override destroy() instead to implement custom widget tear-down
                      * behavior.
+                     * @deprecated
                      */
                     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;
+                    emit<K extends keyof Events>(eventName: K, evt: EventInitArgs<Events[K]>): void;
+                    /**
+                     * @param type
+                     * @param eventObj
+                     * @param callbackArgs
+                     */
+                    emit<K extends string>(
+                        type: K,
+                        eventObj?: K extends keyof Events ? EventInitArgs<Events[K]> : any,
+                        callbackArgs?: any[]
+                    ): any;
                     /**
                      * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
                      */
+                    on<K extends keyof Events>(eventName: K, cb: (evt: Events[K]) => void): dojo.WatchHandle;
                     on(type: string | dojo.ExtensionEvent, func: dojo.EventListener | Function): dojo.WatchHandle;
                     /**
                     /**
                      * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
+                     * @deprecated
                      */
                     connect(obj: any, event: string | dojo.ExtensionEvent, method: string | dojo.EventListener): dojo.WatchHandle;
                     /**
                      * Deprecated, will be removed in 2.0, use handle.remove() instead.
+                     * @deprecated
                      */
                     disconnect(handle: dojo.WatchHandle): void;
                     /**
                      * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
+                     * @deprecated
                      */
                     subscribe(t: string, method: dojo.EventListener): dojo.WatchHandle;
                     /**
                      * Deprecated, will be removed in 2.0, use handle.remove() instead.
+                     * @deprecated
                      */
                     unsubscribe(handle: dojo.WatchHandle): void;
                     onMonthSelect(): void;
                     postCreate(): void;
-            		set(name: 'month', value: number): this;
+                    //set(name: 'month', value: number): this;
-            		set(name: string, value: any): this;
+                    //set(name: string, value: any): this;
-            		set(values: Object): this;
+                    //set(values: Object): this;
                 }
                 interface _MonthDropDownButtonConstructor extends _WidgetBaseConstructor<_MonthDropDownButton> { }
                      */
                     onChange(month: number): void;
-            		set(name: 'months', value: string[]): this;
+                    //set(name: 'months', value: string[]): this;
-            		set(name: string, value: any): this;
+                    //set(name: string, value: any): this;
-            		set(values: Object): this;
+                    //set(values: Object): this;
                 }
                 interface _MonthDropDownConstructor extends _WidgetBaseConstructor<_MonthDropDown> { }
                      */
                     getClassForDate(dateObject: Date, locale?: string): string;
-            		get(name: 'value'): Date;
+                    // get(name: 'value'): Date;
-            		get(name: string): any;
+                    // get(name: string): any;
-            		set(name: 'value', value: number | Date): this;
+                    // set(name: 'value', value: number | Date): this;
-            		set(name: string, value: any): this;
+                    // set(name: string, value: any): this;
-            		set(values: Object): this;
+                    // set(values: Object): this;
                 }
                 interface CalendarConstructor extends _WidgetBaseConstructor<Calendar> {
                 /* dijit/CalendarLite */
                 interface _MonthWidget extends _WidgetBase {
-            		set(name: 'month', value: Date): this;
+                    // set(name: 'month', value: Date): this;
-            		set(name: string, value: any): this;
+                    // set(name: string, value: any): this;
-            		set(values: Object): this;
+                    // set(values: Object): this;
                 }
                 interface _MonthWidgetConstructor extends _WidgetBaseConstructor<_MonthWidget> { }
                      */
                     getClassForDate(dateObject: Date, locale?: string): string;
-            		get(name: 'value'): Date;
+                    // get(name: 'value'): Date;
-            		get(name: string): any;
+                    // get(name: string): any;
-            		set(name: 'value', value: number | Date): this;
+                    // set(name: 'value', value: number | Date): this;
-            		set(name: string, value: any): this;
+                    // set(name: string, value: any): this;
-            		set(values: Object): this;
+                    // set(values: Object): this;
                 }
                 interface CalendarLiteConstructor extends _WidgetBaseConstructor<CalendarLite> {

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

             }
             declare module 'dijit/_WidgetBase' {
-            	type _WidgetBase<A = any> = dijit._WidgetBase<A>;
+            	type _WidgetBase<E extends { [k in keyof E]: Event } = {}> = dijit._WidgetBase<E & GlobalEventHandlersEventMap>;
                 // individual _WidgetBase constructor to keep type parameters
                 interface _WidgetBaseConstructor {
-                    new <A = any>(params?: Partial<_WidgetBase<A> & A>, srcNodeRef?: dojo.NodeOrString): _WidgetBase<A> & dojo._base.DeclareCreatedObject;
+                    new <A = {}, E extends { [k in keyof E]: Event } = {}>(params?: Partial<_WidgetBase<E> & A>, srcNodeRef?: dojo.NodeOrString): _WidgetBase<E> & dojo._base.DeclareCreatedObject;
-                    prototype: _WidgetBase;
+                    prototype: _WidgetBase<any>;
                 }
             	const _WidgetBase: _WidgetBaseConstructor;
             	export = _WidgetBase;

dojo-typings/src/main/typings/dojo/dojo.d.ts +1 -1

             		/**
             		 * Watches a property for changes
             		 */
-            		watch(callback: <K extends keyof T>(prop: K, oldValue: T[K], newValue: T[K]) => void): WatchHandle;
+            		watch(callback:(prop: keyof any, oldValue: any, newValue: any) => void): WatchHandle;
             		watch<K extends keyof T>(name: K, callback: (prop: K, oldValue: T[K], newValue: T[K]) => void): WatchHandle;
             	}

dojo-typings/src/main/typings/dojo/modules.d.ts +1 -1

             }
             declare module 'dojo/Stateful' {
-            	type Stateful<T = any> = dojo.Stateful<any>;
+            	type Stateful<T = any> = dojo.Stateful<T>;
             	const Stateful: dojo.StatefulConstructor;
             	export = Stateful;
             }

dojo-typings/src/test/ts/StatefulTests.ts +7 -2

-            import Stateful = require("dojo/Stateful");
+            import * as Stateful from "dojo/Stateful";
+            import { StatefulAttrs, watch } from "./traits";
             interface ScheduleAttrs {
                 title: string;
             model.get("title");
             model.get("duration");
-            model.set("duration", 12);
  No newline at end of file
+            model.set("duration", 12);
+            watch(model, "duration", v => v);
+            declare const o : StatefulAttrs<Schedule>;
  No newline at end of file

dojo-typings/src/test/ts/StoreTests.ts +2 -4

-            import Memory = require("dojo/store/Memory");
+            import * as Memory from "dojo/store/Memory";
-            import Observable = require("dojo/store/Observable");
+            import * as Observable from "dojo/store/Observable";
             interface Schedule {
             const mem = new Memory<Schedule>();
-            (async () => {
             observable.query().observe(() => { });
             store.query().forEach(() => { });
             const total = await store.query().total;
             mem.query();
             mem.add({ duration: 10, title: "Test event" });
-            })();
  No newline at end of file

dojo-typings/src/test/ts/_WidgetTests.ts +30 -6

@@ -1,17 +1,41
1	import _WidgetBase = ~~require~~("dijit/_WidgetBase");	1	import * as _WidgetBase from "dijit/_WidgetBase";
		2	import { watch } from "./traits";
2		3
3	interface ScheduleWidgetAttrs {	4	interface ScheduleWidgetAttrs {
4	data: string[];	5	data: string[];
5	}	6	}
6		7
7	declare const w0: _WidgetBase<ScheduleWidgetAttrs>;	8	interface ScheduleWidgetEvents {
		9	"scheduled": Event & {
		10	detail: {
		11	startDate: Date,
		12	endDate: Date
		13	}
		14	};
		15	}
8		16
9	w0.get("data");	17	declare class ScheduleWidget extends _WidgetBase<ScheduleWidgetAttrs, ScheduleWidgetEvents> {
10
11	declare class ScheduleWidget extends _WidgetBase {
12	data: string[];	18	data: string[];
13	}	19	}
14		20
15	const w = new ScheduleWidget({title: "Year schedule", data: ["a", "b"] });	21	const w = new ScheduleWidget({title: "Year schedule", data: ["a", "b"] });
16		22
17	w.get("data"); No newline at end of file	23	w.get("data");
		24
		25	w.watch((p, o, n) => [p,o,n]);
		26
		27	w.watch("data", (p, o, n) => [p,o,n]);
		28
		29	watch(w, "title", v => String(v) );
		30	watch(w, "data", v => String(v) );
		31
		32	w.emit("scheduled", { detail: { startDate: new Date(), endDate: new Date()} });
		33
		34	w.emit("click", {} );
		35
		36	w.emit("click", {} );
		37
		38	w.emit("some-extra-event", {});
		39
		40	w.on("click", e => e);
		41	w.on("some-extra-event", e => e);

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

                     "rootDir": "ts",
                     "rootDirs": [
                         "ts",
+                        "typings",
                         "../main/ts"
                     ],
                     "types": [
                         "../main/typings/dojo/modules",
                         "../main/typings/dijit/modules"
                     ],
-                    "module": "amd"
+                    "module": "ESNext",
+                    "target": "ESNext"
                 },
                 "include": [
                     "typings/**/*.ts",

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