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: string, value: any): this;
-             		set(values: Object): this;
+                     //set(name: 'month', value: number): this;
+                     //set(name: string, value: any): this;
+                     //set(values: Object): this;
              	}
-             	interface _MonthDropDownButtonConstructor extends _WidgetBaseConstructor<_MonthDropDownButton> { }
              		 */
-             		onChange(month: number): void;
-             		set(name: 'months', value: string[]): this;
-             		set(name: string, value: any): this;
-             		set(values: Object): this;
+                     //set(name: 'months', value: string[]): this;
+                     //set(name: string, value: any): this;
+                     //set(values: Object): this;
              	}
-             	interface _MonthDropDownConstructor extends _WidgetBaseConstructor<_MonthDropDown> { }
              		 */
-             		getClassForDate(dateObject: Date, locale?: string): string;
-             		get(name: 'value'): Date;
-             		get(name: string): any;
-             		set(name: 'value', value: number | Date): this;
-             		set(name: string, value: any): this;
-             		set(values: Object): this;
+                     // get(name: 'value'): Date;
+                     // get(name: string): any;
+                     // set(name: 'value', value: number | Date): this;
+                     // set(name: string, value: any): this;
+                     // set(values: Object): this;
              	}
-             	interface CalendarConstructor extends _WidgetBaseConstructor<Calendar> {
-             	/* dijit/CalendarLite */
-             	interface _MonthWidget extends _WidgetBase {
-             		set(name: 'month', value: Date): this;
-             		set(name: string, value: any): this;
-             		set(values: Object): this;
+                     // set(name: 'month', value: Date): this;
+                     // set(name: string, value: any): this;
+                     // set(values: Object): this;
              	}
-             	interface _MonthWidgetConstructor extends _WidgetBaseConstructor<_MonthWidget> { }
              		 */
-             		getClassForDate(dateObject: Date, locale?: string): string;
-             		get(name: 'value'): Date;
-             		get(name: string): any;
-             		set(name: 'value', value: number | Date): this;
-             		set(name: string, value: any): this;
-             		set(values: Object): this;
+                     // get(name: 'value'): Date;
+                     // get(name: string): any;
+                     // set(name: 'value', value: number | Date): this;
+                     // set(name: string, value: any): 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;
-                     prototype: _WidgetBase;
+                     new <A = {}, E extends { [k in keyof E]: Event } = {}>(params?: Partial<_WidgetBase<E> & A>, srcNodeRef?: dojo.NodeOrString): _WidgetBase<E> & dojo._base.DeclareCreatedObject;
+                     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 Observable = require("dojo/store/Observable");
+             import * as Memory from "dojo/store/Memory";
+             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

-             import _WidgetBase = require("dijit/_WidgetBase");
+             import * as _WidgetBase from "dijit/_WidgetBase";
+             import { watch } from "./traits";
              interface ScheduleWidgetAttrs {
                  data: string[];
              }
-             declare const w0: _WidgetBase<ScheduleWidgetAttrs>;
+             interface ScheduleWidgetEvents {
+                 "scheduled": Event & {
+                     detail: {
+                         startDate: Date,
+                         endDate: Date
+                     }
+                 };
+             }
-             w0.get("data");
-             declare class ScheduleWidget extends _WidgetBase {
+             declare class ScheduleWidget extends _WidgetBase<ScheduleWidgetAttrs, ScheduleWidgetEvents> {
                  data: string[];
              }
              const w = new ScheduleWidget({title: "Year schedule", data: ["a", "b"] });
-             w.get("data");
  No newline at end of file
+             w.get("data");
+             w.watch((p, o, n) => [p,o,n]);
+             w.watch("data", (p, o, n) => [p,o,n]);
+             watch(w, "title", v => String(v) );
+             watch(w, "data", v => String(v) );
+             w.emit("scheduled", { detail: { startDate: new Date(), endDate: new Date()} });
+             w.emit("click", {} );
+             w.emit("click", {} );
+             w.emit("some-extra-event", {});
+             w.on("click", e => e);
+             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