@@ -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; |
This diff has been collapsed as it changes many lines, (4671 lines changed) Show them Hide them | |||||
@@ -1,2303 +1,2380 | |||||
1 | /// <reference path="../dojo/index.d.ts" /> |
|
1 | /// <reference path="../dojo/index.d.ts" /> | |
2 | /// <reference path="form.d.ts" /> |
|
2 | /// <reference path="form.d.ts" /> | |
3 | /// <reference path="layout.d.ts" /> |
|
3 | /// <reference path="layout.d.ts" /> | |
4 |
|
4 | |||
5 | declare namespace dijit { |
|
5 | declare namespace dijit { | |
6 |
|
|
6 | /* Global Dijit Interface */ | |
7 |
|
|
7 | interface Dijit { } | |
8 |
|
8 | |||
9 |
|
|
9 | /* dijit/_AttachMixin */ | |
10 |
|
10 | |||
11 |
|
|
11 | /* tslint:disable:class-name */ | |
12 |
|
12 | |||
13 |
|
|
13 | interface _WidgetBase { | |
14 |
|
|
14 | dojoAttachEvent: string; | |
15 |
|
|
15 | dojoAttachPoint: string; | |
16 | } |
|
16 | } | |
17 |
|
17 | |||
18 |
|
|
18 | interface _AttachMixin { | |
19 | /** |
|
19 | /** | |
20 |
|
|
20 | * List of widget attribute names associated with data-dojo-attach-point=... in the template, ex: ["containerNode", "labelNode"] | |
21 | */ |
|
21 | */ | |
22 |
|
|
22 | _attachPoints: string[]; | |
23 |
|
23 | |||
24 | /** |
|
24 | /** | |
25 |
|
|
25 | * List of connections associated with data-dojo-attach-event=... in the template | |
26 | */ |
|
26 | */ | |
27 |
|
|
27 | _attachEvents: dojo.Handle[]; | |
28 |
|
28 | |||
29 | /** |
|
29 | /** | |
30 |
|
|
30 | * Object to which attach points and events will be scoped. Defaults to 'this'. | |
31 | */ |
|
31 | */ | |
32 |
|
|
32 | attachScope: any; | |
33 |
|
33 | |||
34 | /** |
|
34 | /** | |
35 |
|
|
35 | * Search descendants of this.containerNode for data-dojo-attach-point and data-dojo-attach-event. | |
36 | * |
|
36 | * | |
37 |
|
|
37 | * 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. | |
38 | */ |
|
38 | */ | |
39 |
|
|
39 | searchContainerNode: boolean; | |
40 |
|
40 | |||
41 | /** |
|
41 | /** | |
42 |
|
|
42 | * Attach to DOM nodes marked with special attributes. | |
43 | */ |
|
43 | */ | |
44 |
|
|
44 | buildRendering(): void; | |
45 |
|
45 | |||
46 | /** |
|
46 | /** | |
47 |
|
|
47 | * hook for _WidgetsInTemplateMixin | |
48 | */ |
|
48 | */ | |
49 |
|
|
49 | _beforeFillContent(): void; | |
50 |
|
50 | |||
51 | /** |
|
51 | /** | |
52 |
|
|
52 | * Iterate through the dom nodes and attach functions and nodes accordingly. | |
53 | * |
|
53 | * | |
54 |
|
|
54 | * 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: | |
55 |
|
|
55 | * - dojoAttachPoint/data-dojo-attach-point | |
56 |
|
|
56 | * - dojoAttachEvent/data-dojo-attach-event | |
57 | */ |
|
57 | */ | |
58 |
|
|
58 | _attachTemplateNodes(rootNode: Element | Node): void; | |
59 |
|
59 | |||
60 | /** |
|
60 | /** | |
61 |
|
|
61 | * Process data-dojo-attach-point and data-dojo-attach-event for given node or widget. | |
62 | * |
|
62 | * | |
63 |
|
|
63 | * Returns true if caller should process baseNode's children too. | |
64 | */ |
|
64 | */ | |
65 |
|
|
65 | _processTemplateNode<T extends (Element | Node | _WidgetBase)>( | |
66 |
|
|
66 | baseNode: T, | |
67 |
|
|
67 | getAttrFunc: (baseNode: T, attr: string) => string, | |
68 |
|
|
68 | attachFunc: (node: T, type: string, func?: Function) => dojo.Handle | |
69 |
|
|
69 | ): boolean; | |
70 |
|
70 | |||
71 | /** |
|
71 | /** | |
72 |
|
|
72 | * 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. | |
73 | */ |
|
73 | */ | |
74 |
|
|
74 | _attach(node: Element | Node, type: string, func?: Function): dojo.Handle; | |
75 |
|
75 | |||
76 | /** |
|
76 | /** | |
77 |
|
|
77 | * Detach and clean up the attachments made in _attachtempalteNodes. | |
78 | */ |
|
78 | */ | |
79 |
|
|
79 | _detachTemplateNodes(): void; | |
80 |
|
80 | |||
81 |
|
|
81 | destroyRendering(preserveDom?: boolean): void; | |
82 | } |
|
82 | } | |
83 |
|
83 | |||
84 |
|
|
84 | interface _AttachMixinConstructor extends dojo._base.DeclareConstructor<_AttachMixin> { } | |
85 |
|
85 | |||
86 |
|
|
86 | /* dijit/_BidiMixin */ | |
87 |
|
87 | |||
88 |
|
|
88 | interface _WidgetBase { | |
89 |
|
89 | |||
90 | /** |
|
90 | /** | |
91 |
|
|
91 | * Gets the right direction of text. | |
92 | */ |
|
92 | */ | |
93 |
|
|
93 | getTextDir(text: string): string; | |
94 |
|
94 | |||
95 | /** |
|
95 | /** | |
96 |
|
|
96 | * Set element.dir according to this.textDir, assuming this.textDir has a value. | |
97 | */ |
|
97 | */ | |
98 |
|
|
98 | applyTextDir(element: HTMLElement, text?: string): void; | |
99 |
|
99 | |||
100 | /** |
|
100 | /** | |
101 |
|
|
101 | * Wraps by UCC (Unicode control characters) option's text according to this.textDir | |
102 | */ |
|
102 | */ | |
103 |
|
|
103 | enforceTextDirWithUcc(option: HTMLOptionElement, text: string): string; | |
104 |
|
104 | |||
105 | /** |
|
105 | /** | |
106 |
|
|
106 | * Restores the text of origObj, if needed, after enforceTextDirWithUcc, e.g. set("textDir", textDir). | |
107 | */ |
|
107 | */ | |
108 |
|
|
108 | restoreOriginalText(origObj: HTMLOptionElement): HTMLOptionElement; | |
109 | } |
|
109 | } | |
110 |
|
110 | |||
111 |
|
|
111 | /* dijit/_ConfirmDialogMixin */ | |
112 |
|
112 | |||
113 |
|
|
113 | interface _ConfirmDialogMixin extends _WidgetsInTemplateMixin { | |
114 | /** |
|
114 | /** | |
115 |
|
|
115 | * HTML snippet for action bar, overrides _DialogMixin.actionBarTemplate | |
116 | */ |
|
116 | */ | |
117 |
|
|
117 | actionBarTemplate: string; | |
118 |
|
118 | |||
119 | /** |
|
119 | /** | |
120 |
|
|
120 | * Label of OK button. | |
121 | */ |
|
121 | */ | |
122 |
|
|
122 | buttonOk: string; | |
123 |
|
123 | |||
124 | /** |
|
124 | /** | |
125 |
|
|
125 | * Label of cancel button. | |
126 | */ |
|
126 | */ | |
127 |
|
|
127 | buttonCancel: string; | |
128 | } |
|
128 | } | |
129 |
|
129 | |||
130 |
|
|
130 | /* dijit/_Contained */ | |
131 |
|
131 | |||
132 |
|
|
132 | interface _Contained { | |
133 | /** |
|
133 | /** | |
134 |
|
|
134 | * Returns the previous child of the parent or null if this is the | |
135 |
|
|
135 | * first child of the parent. | |
136 | */ |
|
136 | */ | |
137 |
|
|
137 | getPreviousSibling<T extends _WidgetBase>(): T; | |
138 |
|
138 | |||
139 | /** |
|
139 | /** | |
140 |
|
|
140 | * Returns the next child of the parent or null if this is the last | |
141 |
|
|
141 | * child of the parent. | |
142 | */ |
|
142 | */ | |
143 |
|
|
143 | getNextSibling<T extends _WidgetBase>(): T; | |
144 |
|
144 | |||
145 | /** |
|
145 | /** | |
146 |
|
|
146 | * Returns the index of this widget within its container parent. | |
147 |
|
|
147 | * It returns -1 if the parent does not exist or if the parent is | |
148 |
|
|
148 | * not a dijit/_Container. | |
149 | */ |
|
149 | */ | |
150 |
|
|
150 | getIndexInParent(): number; | |
151 | } |
|
151 | } | |
152 |
|
152 | |||
153 |
|
|
153 | interface _ContainedConstructor extends dojo._base.DeclareConstructor<_Contained> { } | |
154 |
|
154 | |||
155 |
|
|
155 | /* dijit/_Container */ | |
156 |
|
156 | |||
157 |
|
|
157 | interface _Container { | |
158 |
|
|
158 | buildRendering(): void; | |
159 |
|
159 | |||
160 | /** |
|
160 | /** | |
161 |
|
|
161 | * Makes the given widget a child of this widget. | |
162 | */ |
|
162 | */ | |
163 |
|
|
163 | addChild<T extends _WidgetBase>(widget: T, insertIndex?: number): void; | |
164 |
|
164 | |||
165 | /** |
|
165 | /** | |
166 |
|
|
166 | * Removes the passed widget instance from this widget but does | |
167 |
|
|
167 | * not destroy it. You can also pass in an integer indicating | |
168 |
|
|
168 | * the index within the container to remove (ie, removeChild(5) removes the sixth widget) | |
169 | */ |
|
169 | */ | |
170 |
|
|
170 | removeChild<T extends _WidgetBase>(widget: T): void; | |
171 |
|
|
171 | removeChild<T extends number>(widget: number): void; | |
172 |
|
172 | |||
173 | /** |
|
173 | /** | |
174 |
|
|
174 | * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets. | |
175 | */ |
|
175 | */ | |
176 |
|
|
176 | hasChildren(): boolean; | |
177 |
|
177 | |||
178 | /** |
|
178 | /** | |
179 |
|
|
179 | * Gets the index of the child in this container or -1 if not found | |
180 | */ |
|
180 | */ | |
181 |
|
|
181 | getIndexOfChild<T extends _WidgetBase>(widget: T): number; | |
182 | } |
|
182 | } | |
183 |
|
183 | |||
184 |
|
|
184 | interface _ContainerConstructor extends dojo._base.DeclareConstructor<_Container> { } | |
185 |
|
185 | |||
186 |
|
|
186 | /* dijit/_CssStateMixin */ | |
187 |
|
187 | |||
188 |
|
|
188 | interface CSSStateNodes { | |
189 |
|
|
189 | [node: string]: string; | |
190 | } |
|
190 | } | |
191 |
|
191 | |||
192 |
|
|
192 | interface _CssStateMixin { | |
193 | /** |
|
193 | /** | |
194 |
|
|
194 | * True if cursor is over this widget | |
195 | */ |
|
195 | */ | |
196 |
|
|
196 | hovering: boolean; | |
197 |
|
197 | |||
198 | /** |
|
198 | /** | |
199 |
|
|
199 | * True if mouse was pressed while over this widget, and hasn't been released yet | |
200 | */ |
|
200 | */ | |
201 |
|
|
201 | active: boolean; | |
202 | } |
|
202 | } | |
203 |
|
203 | |||
204 |
|
|
204 | interface _CssStateMixinConstructor extends dojo._base.DeclareConstructor<_CssStateMixin> { } | |
205 |
|
205 | |||
206 |
|
|
206 | /* dijit/_DialogMixin */ | |
207 |
|
207 | |||
208 |
|
|
208 | interface _DialogMixin { | |
209 | /** |
|
209 | /** | |
210 |
|
|
210 | * HTML snippet to show the action bar (gray bar with OK/cancel buttons). | |
211 |
|
|
211 | * Blank by default, but used by ConfirmDialog/ConfirmTooltipDialog subclasses. | |
212 | */ |
|
212 | */ | |
213 |
|
|
213 | actionBarTemplate: string; | |
214 |
|
214 | |||
215 | /** |
|
215 | /** | |
216 |
|
|
216 | * Callback when the user hits the submit button. | |
217 |
|
|
217 | * Override this method to handle Dialog execution. | |
218 | */ |
|
218 | */ | |
219 |
|
|
219 | execute(formContents?: any): void; | |
220 |
|
220 | |||
221 | /** |
|
221 | /** | |
222 |
|
|
222 | * Called when user has pressed the Dialog's cancel button, to notify container. | |
223 | */ |
|
223 | */ | |
224 |
|
|
224 | onCancel(): void; | |
225 |
|
225 | |||
226 | /** |
|
226 | /** | |
227 |
|
|
227 | * Called when user has pressed the dialog's OK button, to notify container. | |
228 | */ |
|
228 | */ | |
229 |
|
|
229 | onExecute(): void; | |
230 | } |
|
230 | } | |
231 |
|
231 | |||
232 |
|
|
232 | /* dijit/_FocusMixin */ | |
233 |
|
|
233 | interface _FocusMixin { } | |
234 |
|
234 | |||
235 |
|
|
235 | interface _WidgetBase { | |
236 | /** |
|
236 | /** | |
237 |
|
|
237 | * Called when the widget becomes "active" because | |
238 |
|
|
238 | * it or a widget inside of it either has focus, or has recently | |
239 |
|
|
239 | * been clicked. | |
240 | */ |
|
240 | */ | |
241 |
|
|
241 | onFocus(): void; | |
242 |
|
242 | |||
243 | /** |
|
243 | /** | |
244 |
|
|
244 | * Called when the widget stops being "active" because | |
245 |
|
|
245 | * focus moved to something outside of it, or the user | |
246 |
|
|
246 | * clicked somewhere outside of it, or the widget was | |
247 |
|
|
247 | * hidden. | |
248 | */ |
|
248 | */ | |
249 |
|
|
249 | onBlur(): void; | |
250 | } |
|
250 | } | |
251 |
|
251 | |||
252 |
|
|
252 | /* dijit/_HasDropDown */ | |
253 |
|
253 | |||
254 |
|
|
254 | interface _HasDropDown<T extends _WidgetBase> extends _FocusMixin { | |
255 | /** |
|
255 | /** | |
256 |
|
|
256 | * The button/icon/node to click to display the drop down. | |
257 |
|
|
257 | * Can be set via a data-dojo-attach-point assignment. | |
258 |
|
|
258 | * If missing, then either focusNode or domNode (if focusNode is also missing) will be used. | |
259 | */ |
|
259 | */ | |
260 |
|
|
260 | _buttonNode: HTMLElement; | |
261 |
|
261 | |||
262 | /** |
|
262 | /** | |
263 |
|
|
263 | * Will set CSS class dijitUpArrow, dijitDownArrow, dijitRightArrow etc. on this node depending | |
264 |
|
|
264 | * on where the drop down is set to be positioned. | |
265 |
|
|
265 | * Can be set via a data-dojo-attach-point assignment. | |
266 |
|
|
266 | * If missing, then _buttonNode will be used. | |
267 | */ |
|
267 | */ | |
268 |
|
|
268 | _arrowWrapperNode: HTMLElement; | |
269 |
|
269 | |||
270 | /** |
|
270 | /** | |
271 |
|
|
271 | * The node to set the aria-expanded class on. | |
272 |
|
|
272 | * Also sets popupActive class but that will be removed in 2.0. | |
273 |
|
|
273 | * Can be set via a data-dojo-attach-point assignment. | |
274 |
|
|
274 | * If missing, then focusNode or _buttonNode (if focusNode is missing) will be used. | |
275 | */ |
|
275 | */ | |
276 |
|
|
276 | _popupStateNode: HTMLElement; | |
277 |
|
277 | |||
278 | /** |
|
278 | /** | |
279 |
|
|
279 | * The node to display the popup around. | |
280 |
|
|
280 | * Can be set via a data-dojo-attach-point assignment. | |
281 |
|
|
281 | * If missing, then domNode will be used. | |
282 | */ |
|
282 | */ | |
283 |
|
|
283 | _aroundNode: HTMLElement; | |
284 |
|
284 | |||
285 | /** |
|
285 | /** | |
286 |
|
|
286 | * The widget to display as a popup. This widget *must* be | |
287 |
|
|
287 | * defined before the startup function is called. | |
288 | */ |
|
288 | */ | |
289 |
|
|
289 | dropDown: T; | |
290 |
|
290 | |||
291 | /** |
|
291 | /** | |
292 |
|
|
292 | * Set to true to make the drop down at least as wide as this | |
293 |
|
|
293 | * widget. Set to false if the drop down should just be its | |
294 |
|
|
294 | * default width. | |
295 | */ |
|
295 | */ | |
296 |
|
|
296 | autoWidth: boolean; | |
297 |
|
297 | |||
298 | /** |
|
298 | /** | |
299 |
|
|
299 | * Set to true to make the drop down exactly as wide as this | |
300 |
|
|
300 | * widget. Overrides autoWidth. | |
301 | */ |
|
301 | */ | |
302 |
|
|
302 | forceWidth: boolean; | |
303 |
|
303 | |||
304 | /** |
|
304 | /** | |
305 |
|
|
305 | * The max height for our dropdown. | |
306 |
|
|
306 | * Any dropdown taller than this will have scrollbars. | |
307 |
|
|
307 | * Set to 0 for no max height, or -1 to limit height to available space in viewport | |
308 | */ |
|
308 | */ | |
309 |
|
|
309 | maxHeight: number; | |
310 |
|
310 | |||
311 | /** |
|
311 | /** | |
312 |
|
|
312 | * This variable controls the position of the drop down. | |
313 |
|
|
313 | * It's an array of strings | |
314 | */ |
|
314 | */ | |
315 |
|
|
315 | dropDownPosition: string[]; | |
316 |
|
|
316 | /* TODO remove for TS 1.8 */ | |
317 |
|
|
317 | /* dropDownPosition: ('before' | 'after' | 'above' | 'below')[]; */ | |
318 |
|
318 | |||
319 | /** |
|
319 | /** | |
320 |
|
|
320 | * When set to false, the click events will not be stopped, in | |
321 |
|
|
321 | * case you want to use them in your subclass | |
322 | */ |
|
322 | */ | |
323 |
|
|
323 | _stopClickEvents: boolean; | |
324 |
|
324 | |||
325 | /** |
|
325 | /** | |
326 |
|
|
326 | * Callback when the user mousedown/touchstart on the arrow icon. | |
327 | */ |
|
327 | */ | |
328 |
|
|
328 | _onDropDownMouseDown(e: MouseEvent): void; | |
329 |
|
329 | |||
330 | /** |
|
330 | /** | |
331 |
|
|
331 | * Callback on mouseup/touchend after mousedown/touchstart on the arrow icon. | |
332 |
|
|
332 | * Note that this function is called regardless of what node the event occurred on (but only after | |
333 |
|
|
333 | * a mousedown/touchstart on the arrow). | |
334 | */ |
|
334 | */ | |
335 |
|
|
335 | _onDropDownMouseUp(e?: MouseEvent): void; | |
336 |
|
336 | |||
337 | /** |
|
337 | /** | |
338 |
|
|
338 | * The drop down was already opened on mousedown/keydown; just need to stop the event | |
339 | */ |
|
339 | */ | |
340 |
|
|
340 | _onDropDownClick(e: MouseEvent): void; | |
341 |
|
341 | |||
342 |
|
|
342 | buildRendering(): void; | |
343 |
|
|
343 | postCreate(): void; | |
344 |
|
|
344 | destroy(preserveDom?: boolean): void; | |
345 |
|
345 | |||
346 | /** |
|
346 | /** | |
347 |
|
|
347 | * Returns true if the dropdown exists and it's data is loaded. This can | |
348 |
|
|
348 | * be overridden in order to force a call to loadDropDown(). | |
349 | */ |
|
349 | */ | |
350 |
|
|
350 | isLoaded(): boolean; | |
351 |
|
351 | |||
352 | /** |
|
352 | /** | |
353 |
|
|
353 | * Creates the drop down if it doesn't exist, loads the data | |
354 |
|
|
354 | * if there's an href and it hasn't been loaded yet, and then calls | |
355 |
|
|
355 | * the given callback. | |
356 | */ |
|
356 | */ | |
357 |
|
|
357 | loadDropDown(loadCallback: () => void): void; | |
358 |
|
358 | |||
359 | /** |
|
359 | /** | |
360 |
|
|
360 | * Creates the drop down if it doesn't exist, loads the data | |
361 |
|
|
361 | * if there's an href and it hasn't been loaded yet, and | |
362 |
|
|
362 | * then opens the drop down. This is basically a callback when the | |
363 |
|
|
363 | * user presses the down arrow button to open the drop down. | |
364 | */ |
|
364 | */ | |
365 |
|
|
365 | loadAndOpenDropDown(): dojo.Deferred<T>; | |
366 |
|
366 | |||
367 | /** |
|
367 | /** | |
368 |
|
|
368 | * Callback when the user presses the down arrow button or presses | |
369 |
|
|
369 | * the down arrow key to open/close the drop down. | |
370 |
|
|
370 | * Toggle the drop-down widget; if it is up, close it, if not, open it | |
371 | */ |
|
371 | */ | |
372 |
|
|
372 | toggleDropDown(): void; | |
373 |
|
373 | |||
374 | /** |
|
374 | /** | |
375 |
|
|
375 | * Opens the dropdown for this widget. To be called only when this.dropDown | |
376 |
|
|
376 | * has been created and is ready to display (ie, it's data is loaded). | |
377 | */ |
|
377 | */ | |
378 |
|
|
378 | openDropDown(): PlaceLocation; | |
379 |
|
379 | |||
380 | /** |
|
380 | /** | |
381 |
|
|
381 | * Closes the drop down on this widget | |
382 | */ |
|
382 | */ | |
383 |
|
|
383 | closeDropDown(focus?: boolean): void; | |
384 | } |
|
384 | } | |
385 |
|
385 | |||
386 |
|
|
386 | /* dijit/_OnDijitClickMixin */ | |
387 |
|
387 | |||
388 |
|
|
388 | interface _OnDijitClickMixin { | |
389 | /** |
|
389 | /** | |
390 |
|
|
390 | * override _WidgetBase.connect() to make this.connect(node, "ondijitclick", ...) work | |
391 | */ |
|
391 | */ | |
392 |
|
|
392 | connect(obj: any, event: string | dojo.ExtensionEvent, method: string | dojo.EventListener): dojo.WatchHandle; | |
393 | } |
|
393 | } | |
394 |
|
394 | |||
395 |
|
|
395 | interface _OnDijitClickMixinConstructor { | |
396 | /** |
|
396 | /** | |
397 |
|
|
397 | * Deprecated. New code should access the dijit/a11yclick event directly, ex: | |
398 |
|
|
398 | * | this.own(on(node, a11yclick, function(){ ... })); | |
399 | * |
|
399 | * | |
400 |
|
|
400 | * Mixing in this class will make _WidgetBase.connect(node, "ondijitclick", ...) work. | |
401 |
|
|
401 | * It also used to be necessary to make templates with ondijitclick work, but now you can just require | |
402 |
|
|
402 | * dijit/a11yclick. | |
403 | */ |
|
403 | */ | |
404 |
|
|
404 | new(): _OnDijitClickMixin; | |
405 |
|
|
405 | a11yclick: A11yClick; | |
406 | } |
|
406 | } | |
407 |
|
407 | |||
408 |
|
|
408 | /* dijit/_TemplatedMixin */ | |
409 |
|
409 | |||
410 |
|
|
410 | interface _TemplatedMixin extends _AttachMixin { | |
411 |
|
411 | |||
412 | /** |
|
412 | /** | |
413 |
|
|
413 | * A string that represents the widget template. | |
414 |
|
|
414 | * Use in conjunction with dojo.cache() to load from a file. | |
415 | */ |
|
415 | */ | |
416 |
|
|
416 | templateString: string; | |
417 |
|
417 | |||
418 | /** |
|
418 | /** | |
419 |
|
|
419 | * Path to template (HTML file) for this widget relative to dojo.baseUrl. | |
420 |
|
|
420 | * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead | |
421 | */ |
|
421 | */ | |
422 |
|
|
422 | templatePath: string; | |
423 |
|
423 | |||
424 | /** |
|
424 | /** | |
425 |
|
|
425 | * Set _AttachMixin.searchContainerNode to true for back-compat for widgets that have data-dojo-attach-point's | |
426 |
|
|
426 | * and events inside this.containerNode. Remove for 2.0. | |
427 | */ |
|
427 | */ | |
428 |
|
|
428 | searchContainerNode: boolean; | |
429 |
|
429 | |||
430 | /** |
|
430 | /** | |
431 |
|
|
431 | * Construct the UI for this widget from a template, setting this.domNode. | |
432 | */ |
|
432 | */ | |
433 |
|
|
433 | buildRendering(): void; | |
434 | } |
|
434 | } | |
435 |
|
435 | |||
436 |
|
|
436 | interface _TemplatedMixinConstructor extends _WidgetBaseConstructor<_TemplatedMixin> { | |
437 | /** |
|
437 | /** | |
438 |
|
|
438 | * Static method to get a template based on the templatePath or | |
439 |
|
|
439 | * templateString key | |
440 | */ |
|
440 | */ | |
441 |
|
|
441 | getCachedTemplate(templateString: string, alwaysUseString: string, doc?: Document): string | HTMLElement; | |
442 | } |
|
442 | } | |
443 |
|
443 | |||
444 |
|
|
444 | /* dijit/_Widget */ | |
445 |
|
|
445 | interface _Widget extends _WidgetBase, _OnDijitClickMixin, _FocusMixin { | |
446 | /** |
|
446 | /** | |
447 |
|
|
447 | * Connect to this function to receive notifications of mouse click events. | |
448 | */ |
|
448 | */ | |
449 |
|
|
449 | onClick(event: MouseEvent): void; | |
450 |
|
450 | |||
451 | /** |
|
451 | /** | |
452 |
|
|
452 | * Connect to this function to receive notifications of mouse double click events. | |
453 | */ |
|
453 | */ | |
454 |
|
|
454 | onDblClick(event: MouseEvent): void; | |
455 |
|
455 | |||
456 | /** |
|
456 | /** | |
457 |
|
|
457 | * Connect to this function to receive notifications of keys being pressed down. | |
458 | */ |
|
458 | */ | |
459 |
|
|
459 | onKeyDown(event: KeyboardEvent): void; | |
460 |
|
460 | |||
461 | /** |
|
461 | /** | |
462 |
|
|
462 | * Connect to this function to receive notifications of printable keys being typed. | |
463 | */ |
|
463 | */ | |
464 |
|
|
464 | onKeyPress(event: KeyboardEvent): void; | |
465 |
|
465 | |||
466 | /** |
|
466 | /** | |
467 |
|
|
467 | * Connect to this function to receive notifications of keys being released. | |
468 | */ |
|
468 | */ | |
469 |
|
|
469 | onKeyUp(event: KeyboardEvent): void; | |
470 |
|
470 | |||
471 | /** |
|
471 | /** | |
472 |
|
|
472 | * Connect to this function to receive notifications of when the mouse button is pressed down. | |
473 | */ |
|
473 | */ | |
474 |
|
|
474 | onMouseDown(event: MouseEvent): void; | |
475 |
|
475 | |||
476 | /** |
|
476 | /** | |
477 |
|
|
477 | * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget. | |
478 | */ |
|
478 | */ | |
479 |
|
|
479 | onMouseMove(event: MouseEvent): void; | |
480 |
|
480 | |||
481 | /** |
|
481 | /** | |
482 |
|
|
482 | * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget. | |
483 | */ |
|
483 | */ | |
484 |
|
|
484 | onMouseOut(event: MouseEvent): void; | |
485 |
|
485 | |||
486 | /** |
|
486 | /** | |
487 |
|
|
487 | * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget. | |
488 | */ |
|
488 | */ | |
489 |
|
|
489 | onMouseOver(event: MouseEvent): void; | |
490 |
|
490 | |||
491 | /** |
|
491 | /** | |
492 |
|
|
492 | * Connect to this function to receive notifications of when the mouse moves off of this widget. | |
493 | */ |
|
493 | */ | |
494 |
|
|
494 | onMouseLeave(event: MouseEvent): void; | |
495 |
|
495 | |||
496 | /** |
|
496 | /** | |
497 |
|
|
497 | * Connect to this function to receive notifications of when the mouse moves onto this widget. | |
498 | */ |
|
498 | */ | |
499 |
|
|
499 | onMouseEnter(event: MouseEvent): void; | |
500 |
|
500 | |||
501 | /** |
|
501 | /** | |
502 |
|
|
502 | * Connect to this function to receive notifications of when the mouse button is released. | |
503 | */ |
|
503 | */ | |
504 |
|
|
504 | onMouseUp(event: MouseEvent): void; | |
505 |
|
505 | |||
506 |
|
|
506 | postCreate(): void; | |
507 |
|
507 | |||
508 | /** |
|
508 | /** | |
509 |
|
|
509 | * Deprecated. Use set() instead. | |
510 | */ |
|
510 | */ | |
511 |
|
|
511 | setAttribute(attr: string, value: any): void; | |
512 |
|
512 | |||
513 | /** |
|
513 | /** | |
514 |
|
|
514 | * This method is deprecated, use get() or set() directly. | |
515 | */ |
|
515 | */ | |
516 |
|
|
516 | attr(name: string | { [attr: string]: any }, value?: any): any; | |
517 |
|
517 | |||
518 | /** |
|
518 | /** | |
519 |
|
|
519 | * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode. | |
520 | */ |
|
520 | */ | |
521 |
|
|
521 | getDescendants(): _Widget[]; | |
522 |
|
522 | |||
523 | /** |
|
523 | /** | |
524 |
|
|
524 | * Called when this widget becomes the selected pane in a | |
525 |
|
|
525 | * `dijit/layout/TabContainer`, `dijit/layout/StackContainer`, | |
526 |
|
|
526 | * `dijit/layout/AccordionContainer`, etc. | |
527 | * |
|
527 | * | |
528 |
|
|
528 | * Also called to indicate display of a `dijit.Dialog`, `dijit.TooltipDialog`, or `dijit.TitlePane`. | |
529 | */ |
|
529 | */ | |
530 |
|
|
530 | onShow(): void; | |
531 |
|
531 | |||
532 | /** |
|
532 | /** | |
533 |
|
|
533 | * Called when another widget becomes the selected pane in a | |
534 |
|
|
534 | * `dijit/layout/TabContainer`, `dijit/layout/StackContainer`, | |
535 |
|
|
535 | * `dijit/layout/AccordionContainer`, etc. | |
536 | * |
|
536 | * | |
537 |
|
|
537 | * Also called to indicate hide of a `dijit.Dialog`, `dijit.TooltipDialog`, or `dijit.TitlePane`. | |
538 | */ |
|
538 | */ | |
539 |
|
|
539 | onHide(): void; | |
540 |
|
540 | |||
541 | /** |
|
541 | /** | |
542 |
|
|
542 | * Called when this widget is being displayed as a popup (ex: a Calendar popped | |
543 |
|
|
543 | * up from a DateTextBox), and it is hidden. | |
544 |
|
|
544 | * This is called from the dijit.popup code, and should not be called directly. | |
545 | * |
|
545 | * | |
546 |
|
|
546 | * Also used as a parameter for children of `dijit/layout/StackContainer` or subclasses. | |
547 |
|
|
547 | * Callback if a user tries to close the child. Child will be closed if this function returns true. | |
548 | */ |
|
548 | */ | |
549 |
|
|
549 | onClose(): boolean; | |
550 | } |
|
550 | } | |
551 |
|
551 | |||
552 | /* dijit/_WidgetBase */ |
|
552 | interface _WidgetBase { | |
553 | interface _WidgetBase<Attrs = any> extends dojo.Stateful<Attrs & _WidgetBase>, Destroyable { |
|
553 | /** | |
554 |
|
554 | * Used across all instances a hash to cache attribute names and their getter | ||
555 | /** |
|
555 | * and setter names. | |
556 | * A unique, opaque ID string that can be assigned by users or by the |
|
556 | */ | |
557 | * system. If the developer passes an ID which is known not to be |
|
557 | _attrPairNames: { [attr: string]: string }; | |
558 | * unique, the specified ID is ignored and the system-generated ID is |
|
558 | ||
559 | * used instead. |
|
559 | /** | |
560 | */ |
|
560 | * Helper function for get() and set(). | |
561 | id: string; |
|
561 | * Caches attribute name values so we don't do the string ops every time. | |
562 |
|
562 | */ | ||
563 | /** |
|
563 | _getAttrNames(name: string): string; | |
564 | * Rarely used. Overrides the default Dojo locale used to render this widget, |
|
564 | ||
565 | * as defined by the [HTML LANG](http://www.w3.org/TR/html401/struct/dirlang.html#adef-lang) attribute. |
|
565 | /** | |
566 | * Value must be among the list of locales specified during by the Dojo bootstrap, |
|
566 | * Internal helper for directly changing an attribute value. | |
567 | * formatted according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt) (like en-us). |
|
567 | * This method id derived from Stateful and must not be used! | |
568 | */ |
|
568 | * @deprecated use `_set(name, value)` instead. | |
569 | lang: string; |
|
569 | */ | |
570 |
|
570 | _changeAttrValue(name: string, value: any): this; | ||
571 | /** |
|
571 | ||
572 | * Bi-directional support, as defined by the [HTML DIR](http://www.w3.org/TR/html401/struct/dirlang.html#adef-dir) |
|
572 | get<K extends keyof this & string>(name: K): this[K]; | |
573 | * attribute. Either left-to-right "ltr" or right-to-left "rtl". If undefined, widgets renders in page's |
|
573 | ||
574 | * default direction. |
|
574 | /** | |
575 | */ |
|
575 | * Helper function to set new value for specified property, and call handlers | |
576 | dir: string; |
|
576 | * registered with watch() if the value has changed. | |
577 |
|
577 | * @param name | ||
578 | /** |
|
578 | * @param value | |
579 | * HTML class attribute |
|
579 | */ | |
580 | */ |
|
580 | _set<K extends keyof this>(name: K, value: this[K]): void; | |
581 | class: string; |
|
581 | ||
582 |
|
582 | /** | ||
583 | /** |
|
583 | * Helper function to get value for specified property stored by this._set(), | |
584 | * HTML style attributes as cssText string or name/value hash |
|
584 | * i.e. for properties with custom setters. Used mainly by custom getters. | |
585 | */ |
|
585 | * | |
586 | style: string; |
|
586 | * For example, CheckBox._getValueAttr() calls this._get("value"). | |
587 |
|
587 | * @param name | ||
588 | /** |
|
588 | */ | |
589 | * HTML title attribute. |
|
589 | _get<K extends keyof this>(name: K): this[K]; | |
590 | * |
|
590 | ||
591 | * For form widgets this specifies a tooltip to display when hovering over |
|
591 | /** | |
592 | * the widget (just like the native HTML title attribute). |
|
592 | * Set a property on a Stateful instance | |
593 | * |
|
593 | */ | |
594 | * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer, |
|
594 | set<K extends keyof this & string>(name: K, value: this[K]): this; | |
595 | * etc., it's used to specify the tab label, accordion pane title, etc. In this case it's |
|
595 | set<K extends { [p in keyof this]: this[p] extends any[] ? p : never; }[keyof this & string]>(name: K, ...values: this[K]): this; | |
596 | * interpreted as HTML. |
|
596 | set(values: Partial<this>): this; | |
597 | */ |
|
597 | ||
598 | title: string; |
|
598 | /** | |
599 |
|
599 | * Watches a property for changes | ||
600 | /** |
|
600 | */ | |
601 | * When this widget's title attribute is used to for a tab label, accordion pane title, etc., |
|
601 | watch(callback: <K extends keyof any>(prop: K, oldValue: any, newValue: any) => void): dojo.WatchHandle; | |
602 | * this specifies the tooltip to appear when the mouse is hovered over that text. |
|
602 | watch<K extends keyof this>(name: K, callback: (prop: K, oldValue: this[K], newValue: this[K]) => void): dojo.WatchHandle; | |
603 | */ |
|
603 | } | |
604 | tooltip: string; |
|
604 | ||
605 |
|
605 | type EventInitArgs<T extends Event> = { | ||
606 | /** |
|
606 | [p in keyof T]?: T[p] extends (...args: any) => any ? never : T[p]; | |
607 | * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate |
|
607 | }; | |
608 | * widget state. |
|
608 | ||
609 | */ |
|
609 | /* dijit/_WidgetBase */ | |
610 | baseClass: string; |
|
610 | interface _WidgetBase<Events extends { [name in keyof Events]: Event } = GlobalEventHandlersEventMap> extends Destroyable { | |
611 |
|
611 | |||
612 | /** |
|
612 | /** | |
613 | * pointer to original DOM node |
|
613 | * A unique, opaque ID string that can be assigned by users or by the | |
614 | */ |
|
614 | * system. If the developer passes an ID which is known not to be | |
615 | srcNodeRef: HTMLElement; |
|
615 | * unique, the specified ID is ignored and the system-generated ID is | |
616 |
|
616 | * used instead. | ||
617 | /** |
|
617 | */ | |
618 | * This is our visible representation of the widget! Other DOM |
|
618 | id: string; | |
619 | * Nodes may by assigned to other properties, usually through the |
|
619 | ||
620 | * template system's data-dojo-attach-point syntax, but the domNode |
|
620 | /** | |
621 | * property is the canonical "top level" node in widget UI. |
|
621 | * Rarely used. Overrides the default Dojo locale used to render this widget, | |
622 | */ |
|
622 | * as defined by the [HTML LANG](http://www.w3.org/TR/html401/struct/dirlang.html#adef-lang) attribute. | |
623 | domNode: HTMLElement; |
|
623 | * Value must be among the list of locales specified during by the Dojo bootstrap, | |
624 |
|
624 | * formatted according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt) (like en-us). | ||
625 | /** |
|
625 | */ | |
626 | * Designates where children of the source DOM node will be placed. |
|
626 | lang: string; | |
627 | * "Children" in this case refers to both DOM nodes and widgets. |
|
627 | ||
628 | */ |
|
628 | /** | |
629 | containerNode: HTMLElement; |
|
629 | * Bi-directional support, as defined by the [HTML DIR](http://www.w3.org/TR/html401/struct/dirlang.html#adef-dir) | |
630 |
|
630 | * attribute. Either left-to-right "ltr" or right-to-left "rtl". If undefined, widgets renders in page's | ||
631 | /** |
|
631 | * default direction. | |
632 | * The document this widget belongs to. If not specified to constructor, will default to |
|
632 | */ | |
633 | * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global |
|
633 | dir: string; | |
634 | */ |
|
634 | ||
635 | ownerDocument: HTMLElement; |
|
635 | /** | |
636 |
|
636 | * HTML class attribute | ||
637 | /** |
|
637 | */ | |
638 | * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute |
|
638 | class: string; | |
639 | * for each XXX attribute to be mapped to the DOM. |
|
639 | ||
640 | */ |
|
640 | /** | |
641 | attributeMap: { [attribute: string]: any }; |
|
641 | * HTML style attributes as cssText string or name/value hash | |
642 |
|
642 | */ | ||
643 | /** |
|
643 | style: string; | |
644 | * Bi-directional support, the main variable which is responsible for the direction of the text. |
|
644 | ||
645 | * The text direction can be different than the GUI direction by using this parameter in creation |
|
645 | /** | |
646 | * of a widget. |
|
646 | * HTML title attribute. | |
647 | */ |
|
647 | * | |
648 | textDir: string; |
|
648 | * For form widgets this specifies a tooltip to display when hovering over | |
649 |
|
649 | * the widget (just like the native HTML title attribute). | ||
650 | /** |
|
650 | * | |
651 | * Kicks off widget instantiation. See create() for details. |
|
651 | * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer, | |
652 | */ |
|
652 | * etc., it's used to specify the tab label, accordion pane title, etc. In this case it's | |
653 | postscript(params?: any, srcNodeRef?: HTMLElement): void; |
|
653 | * interpreted as HTML. | |
654 |
|
654 | */ | ||
655 | /** |
|
655 | title: string; | |
656 | * Kick off the life-cycle of a widget |
|
656 | ||
657 | */ |
|
657 | /** | |
658 | create(params?: any, srcNodeRef?: HTMLElement): void; |
|
658 | * When this widget's title attribute is used to for a tab label, accordion pane title, etc., | |
659 |
|
659 | * this specifies the tooltip to appear when the mouse is hovered over that text. | ||
660 | /** |
|
660 | */ | |
661 | * Called after the parameters to the widget have been read-in, |
|
661 | tooltip: string; | |
662 | * but before the widget template is instantiated. Especially |
|
662 | ||
663 | * useful to set properties that are referenced in the widget |
|
663 | /** | |
664 | * template. |
|
664 | * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate | |
665 | */ |
|
665 | * widget state. | |
666 | postMixInProperties(): void; |
|
666 | */ | |
667 |
|
667 | baseClass: string; | ||
668 | /** |
|
668 | ||
669 | * Construct the UI for this widget, setting this.domNode. |
|
669 | /** | |
670 | * Most widgets will mixin `dijit._TemplatedMixin`, which implements this method. |
|
670 | * pointer to original DOM node | |
671 | */ |
|
671 | */ | |
672 | buildRendering(): void; |
|
672 | srcNodeRef: HTMLElement; | |
673 |
|
673 | |||
674 | /** |
|
674 | /** | |
675 | * Processing after the DOM fragment is created |
|
675 | * This is our visible representation of the widget! Other DOM | |
676 | */ |
|
676 | * Nodes may by assigned to other properties, usually through the | |
677 | postCreate(): void; |
|
677 | * template system's data-dojo-attach-point syntax, but the domNode | |
678 |
|
678 | * property is the canonical "top level" node in widget UI. | ||
679 | /** |
|
679 | */ | |
680 | * Processing after the DOM fragment is added to the document |
|
680 | domNode: HTMLElement; | |
681 | */ |
|
681 | ||
682 | startup(): void; |
|
682 | /** | |
683 |
|
683 | * Designates where children of the source DOM node will be placed. | ||
684 | /** |
|
684 | * "Children" in this case refers to both DOM nodes and widgets. | |
685 | * Destroy this widget and its descendants |
|
685 | */ | |
686 | */ |
|
686 | containerNode: HTMLElement; | |
687 | destroyRecursive(preserveDom?: boolean): void; |
|
687 | ||
688 |
|
688 | /** | ||
689 | /** |
|
689 | * The document this widget belongs to. If not specified to constructor, will default to | |
690 | * Destroys the DOM nodes associated with this widget. |
|
690 | * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global | |
691 | */ |
|
691 | */ | |
692 | destroyRendering(preserveDom?: boolean): void; |
|
692 | ownerDocument: HTMLElement; | |
693 |
|
693 | |||
694 | /** |
|
694 | /** | |
695 | * Recursively destroy the children of this widget and their |
|
695 | * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute | |
696 | * descendants. |
|
696 | * for each XXX attribute to be mapped to the DOM. | |
697 | */ |
|
697 | */ | |
698 | destroyDescendants(preserveDom?: boolean): void; |
|
698 | attributeMap: { [attribute: string]: any }; | |
699 |
|
699 | |||
700 | /** |
|
700 | /** | |
701 | * Deprecated. Override destroy() instead to implement custom widget tear-down |
|
701 | * Bi-directional support, the main variable which is responsible for the direction of the text. | |
702 | * behavior. |
|
702 | * The text direction can be different than the GUI direction by using this parameter in creation | |
703 | */ |
|
703 | * of a widget. | |
704 | uninitialize(): boolean; |
|
704 | */ | |
705 |
|
705 | textDir: string; | ||
706 | /** |
|
706 | ||
707 | * Used by widgets to signal that a synthetic event occurred, ex: |
|
707 | _started?: boolean; | |
708 | * | myWidget.emit("attrmodified-selectedChildWidget", {}). |
|
708 | ||
709 | */ |
|
709 | /** | |
710 | emit(type: string, eventObj?: any, callbackArgs?: any[]): any; |
|
710 | * Kicks off widget instantiation. See create() for details. | |
711 |
|
711 | */ | ||
712 | /** |
|
712 | postscript(params?: any, srcNodeRef?: HTMLElement): void; | |
713 | * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }). |
|
713 | ||
714 | */ |
|
714 | /** | |
715 | on(type: string | dojo.ExtensionEvent, func: dojo.EventListener | Function): dojo.WatchHandle; |
|
715 | * Kick off the life-cycle of a widget | |
716 |
|
716 | */ | ||
717 | /** |
|
717 | create(params?: any, srcNodeRef?: HTMLElement): void; | |
718 | * Returns a string that represents the widget. |
|
718 | ||
719 | */ |
|
719 | /** | |
720 | toString(): string; |
|
720 | * Called after the parameters to the widget have been read-in, | |
721 |
|
721 | * but before the widget template is instantiated. Especially | ||
722 | /** |
|
722 | * useful to set properties that are referenced in the widget | |
723 | * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent |
|
723 | * template. | |
724 | * is this widget. Note that it does not return all descendants, but rather just direct children. |
|
724 | */ | |
725 | */ |
|
725 | postMixInProperties(): void; | |
726 | getChildren<T extends _WidgetBase>(): T[]; |
|
726 | ||
727 |
|
727 | /** | ||
728 | /** |
|
728 | * Construct the UI for this widget, setting this.domNode. | |
729 | * Returns the parent widget of this widget. |
|
729 | * Most widgets will mixin `dijit._TemplatedMixin`, which implements this method. | |
730 | */ |
|
730 | */ | |
731 | getParent<T extends _WidgetBase>(): T; |
|
731 | buildRendering(): void; | |
732 |
|
732 | |||
733 | /** |
|
733 | /** | |
734 | * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead. |
|
734 | * Processing after the DOM fragment is created | |
735 | */ |
|
735 | */ | |
736 | connect(obj: any, event: string | dojo.ExtensionEvent, method: string | dojo.EventListener): dojo.WatchHandle; |
|
736 | postCreate(): void; | |
737 |
|
737 | |||
738 | /** |
|
738 | /** | |
739 | * Deprecated, will be removed in 2.0, use handle.remove() instead. |
|
739 | * Processing after the DOM fragment is added to the document | |
740 | */ |
|
740 | */ | |
741 | disconnect(handle: dojo.WatchHandle): void; |
|
741 | startup(): void; | |
742 |
|
742 | |||
743 | /** |
|
743 | /** | |
744 | * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead. |
|
744 | * Destroy this widget and its descendants | |
745 | */ |
|
745 | */ | |
746 | subscribe(t: string, method: dojo.EventListener): dojo.WatchHandle; |
|
746 | destroyRecursive(preserveDom?: boolean): void; | |
747 |
|
747 | |||
748 | /** |
|
748 | /** | |
749 | * Deprecated, will be removed in 2.0, use handle.remove() instead. |
|
749 | * Destroys the DOM nodes associated with this widget. | |
750 | */ |
|
750 | */ | |
751 | unsubscribe(handle: dojo.WatchHandle): void; |
|
751 | destroyRendering(preserveDom?: boolean): void; | |
752 |
|
752 | |||
753 | /** |
|
753 | /** | |
754 | * Return this widget's explicit or implicit orientation (true for LTR, false for RTL) |
|
754 | * Recursively destroy the children of this widget and their | |
755 | */ |
|
755 | * descendants. | |
756 | isLeftToRight(): boolean; |
|
756 | */ | |
757 |
|
757 | destroyDescendants(preserveDom?: boolean): void; | ||
758 | /** |
|
758 | ||
759 | * Return true if this widget can currently be focused |
|
759 | /** | |
760 | * and false if not |
|
760 | * Deprecated. Override destroy() instead to implement custom widget tear-down | |
761 | */ |
|
761 | * behavior. | |
762 | isFocusable(): boolean; |
|
762 | * @deprecated | |
763 |
|
763 | */ | ||
764 | /** |
|
764 | uninitialize(): boolean; | |
765 | * Place this widget somewhere in the DOM based |
|
765 | ||
766 | * on standard domConstruct.place() conventions. |
|
766 | /** | |
767 | */ |
|
767 | * Used by widgets to signal that a synthetic event occurred, ex: | |
768 | placeAt<T extends _WidgetBase>(reference: dojo.NodeFragmentOrString | T, position?: string | number): this; |
|
768 | * | myWidget.emit("attrmodified-selectedChildWidget", {}). | |
769 |
|
769 | */ | ||
770 | /** |
|
770 | emit<K extends keyof Events>(eventName: K, evt: EventInitArgs<Events[K]>): void; | |
771 | * Wrapper to setTimeout to avoid deferred functions executing |
|
771 | ||
772 | * after the originating widget has been destroyed. |
|
772 | /** | |
773 | * Returns an object handle with a remove method (that returns null) (replaces clearTimeout). |
|
773 | * @param type | |
774 | */ |
|
774 | * @param eventObj | |
775 | defer(fcn: Function, delay?: number): dojo.Handle; |
|
775 | * @param callbackArgs | |
776 | } |
|
776 | */ | |
777 |
|
777 | emit<K extends string>( | ||
778 | interface _WidgetBaseConstructor<W> extends Pick<dojo._base.DeclareConstructor<W>, Exclude<keyof dojo._base.DeclareConstructor<W>, 'new'>> { |
|
778 | type: K, | |
779 | new (params?: Partial<W> & ThisType<W>, srcNodeRef?: dojo.NodeOrString): W & dojo._base.DeclareCreatedObject; |
|
779 | eventObj?: K extends keyof Events ? EventInitArgs<Events[K]> : any, | |
780 | } |
|
780 | callbackArgs?: any[] | |
781 |
|
781 | ): any; | ||
782 | /* dijit/_WidgetsInTemplateMixin */ |
|
782 | ||
783 |
|
783 | /** | ||
784 | interface _WidgetsInTemplateMixin { |
|
784 | * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }). | |
785 | /** |
|
785 | */ | |
786 | * Used to provide a context require to dojo/parser in order to be |
|
786 | on<K extends keyof Events>(eventName: K, cb: (evt: Events[K]) => void): dojo.WatchHandle; | |
787 | * able to use relative MIDs (e.g. `./Widget`) in the widget's template. |
|
787 | ||
788 | */ |
|
788 | on(type: string | dojo.ExtensionEvent, func: dojo.EventListener | Function): dojo.WatchHandle; | |
789 | contextRequire: Function; |
|
789 | ||
790 |
|
790 | /** | ||
791 | startup(): void; |
|
791 | * Returns a string that represents the widget. | |
792 | } |
|
792 | */ | |
793 |
|
793 | toString(): string; | ||
794 | interface _WidgetsInTemplateMixinConstructor extends dojo._base.DeclareConstructor<_WidgetsInTemplateMixin> { |
|
794 | ||
795 | new (params: Object, srcNodeRef: dojo.NodeOrString): _WidgetsInTemplateMixin; |
|
795 | /** | |
796 | } |
|
796 | * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent | |
797 |
|
797 | * is this widget. Note that it does not return all descendants, but rather just direct children. | ||
798 | /* dijit/a11yclick */ |
|
798 | */ | |
799 |
|
799 | getChildren<T extends _WidgetBase>(): T[]; | ||
800 | interface A11yClick { |
|
800 | ||
801 |
|
801 | /** | ||
802 | /** |
|
802 | * Returns the parent widget of this widget. | |
803 | * Custom press, release, and click synthetic events |
|
803 | */ | |
804 | * which trigger on a left mouse click, touch, or space/enter keyup. |
|
804 | getParent<T extends _WidgetBase>(): T; | |
805 | */ |
|
805 | ||
806 | (node: HTMLElement, listener: Function): dojo.Handle; |
|
806 | /** | |
807 |
|
807 | * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead. | ||
808 | /** |
|
808 | * @deprecated | |
809 | * Mousedown (left button), touchstart, or keydown (space or enter) corresponding to logical click operation. |
|
809 | */ | |
810 | */ |
|
810 | connect(obj: any, event: string | dojo.ExtensionEvent, method: string | dojo.EventListener): dojo.WatchHandle; | |
811 | press: dojo.ExtensionEvent; |
|
811 | ||
812 |
|
812 | /** | ||
813 | /** |
|
813 | * Deprecated, will be removed in 2.0, use handle.remove() instead. | |
814 | * Mouseup (left button), touchend, or keyup (space or enter) corresponding to logical click operation. |
|
814 | * @deprecated | |
815 | */ |
|
815 | */ | |
816 | release: dojo.ExtensionEvent; |
|
816 | disconnect(handle: dojo.WatchHandle): void; | |
817 |
|
817 | |||
818 | /** |
|
818 | /** | |
819 | * Mouse cursor or a finger is dragged over the given node. |
|
819 | * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead. | |
820 | */ |
|
820 | * @deprecated | |
821 | move: dojo.ExtensionEvent; |
|
821 | */ | |
822 | } |
|
822 | subscribe(t: string, method: dojo.EventListener): dojo.WatchHandle; | |
823 |
|
823 | |||
824 | /* dijit/Calendar */ |
|
824 | /** | |
825 |
|
825 | * Deprecated, will be removed in 2.0, use handle.remove() instead. | ||
826 | interface _MonthDropDownButton extends form.DropDownButton<_MonthDropDown> { |
|
826 | * @deprecated | |
827 | onMonthSelect(): void; |
|
827 | */ | |
828 | postCreate(): void; |
|
828 | unsubscribe(handle: dojo.WatchHandle): void; | |
829 |
|
829 | |||
830 | set(name: 'month', value: number): this; |
|
830 | /** | |
831 | set(name: string, value: any): this; |
|
831 | * Return this widget's explicit or implicit orientation (true for LTR, false for RTL) | |
832 | set(values: Object): this; |
|
832 | */ | |
833 | } |
|
833 | isLeftToRight(): boolean; | |
834 |
|
834 | |||
835 | interface _MonthDropDownButtonConstructor extends _WidgetBaseConstructor<_MonthDropDownButton> { } |
|
835 | /** | |
836 |
|
836 | * Return true if this widget can currently be focused | ||
837 | interface _MonthDropDown extends _Widget, _TemplatedMixin, _CssStateMixin { |
|
837 | * and false if not | |
838 | months: string[]; |
|
838 | */ | |
839 | baseClass: string; |
|
839 | isFocusable(): boolean; | |
840 | templateString: string; |
|
840 | ||
841 |
|
841 | /** | ||
842 | /** |
|
842 | * Place this widget somewhere in the DOM based | |
843 | * Callback when month is selected from drop down |
|
843 | * on standard domConstruct.place() conventions. | |
844 | */ |
|
844 | */ | |
845 | onChange(month: number): void; |
|
845 | placeAt<T extends _WidgetBase>(reference: dojo.NodeFragmentOrString | T, position?: string | number): this; | |
846 |
|
846 | |||
847 | set(name: 'months', value: string[]): this; |
|
847 | /** | |
848 | set(name: string, value: any): this; |
|
848 | * Wrapper to setTimeout to avoid deferred functions executing | |
849 | set(values: Object): this; |
|
849 | * after the originating widget has been destroyed. | |
850 | } |
|
850 | * Returns an object handle with a remove method (that returns null) (replaces clearTimeout). | |
851 |
|
851 | */ | ||
852 | interface _MonthDropDownConstructor extends _WidgetBaseConstructor<_MonthDropDown> { } |
|
852 | defer(fcn: Function, delay?: number): dojo.Handle; | |
853 |
|
853 | } | ||
854 | interface Calendar extends CalendarLite, _Widget, _CssStateMixin { |
|
854 | ||
855 |
|
855 | interface _WidgetBaseConstructor<W> extends Pick<dojo._base.DeclareConstructor<W>, Exclude<keyof dojo._base.DeclareConstructor<W>, 'new'>> { | ||
856 | baseClass: string; |
|
856 | new(params?: Partial<W> & ThisType<W>, srcNodeRef?: dojo.NodeOrString): W & dojo._base.DeclareCreatedObject; | |
857 |
|
857 | } | ||
858 | /** |
|
858 | ||
859 | * Set node classes for various mouse events, see dijit._CssStateMixin for more details |
|
859 | /* dijit/_WidgetsInTemplateMixin */ | |
860 | */ |
|
860 | ||
861 | cssStateNodes: CSSStateNodes; |
|
861 | interface _WidgetsInTemplateMixin { | |
862 |
|
862 | /** | ||
863 | /** |
|
863 | * Used to provide a context require to dojo/parser in order to be | |
864 | * Creates the drop down button that displays the current month and lets user pick a new one |
|
864 | * able to use relative MIDs (e.g. `./Widget`) in the widget's template. | |
865 | */ |
|
865 | */ | |
866 | _createMonthWidget(): _MonthDropDownButton; |
|
866 | contextRequire: Function; | |
867 |
|
867 | |||
868 | postCreate(): void; |
|
868 | startup(): void; | |
869 |
|
869 | } | ||
870 | /** |
|
870 | ||
871 | * Handler for when user selects a month from the drop down list |
|
871 | interface _WidgetsInTemplateMixinConstructor extends dojo._base.DeclareConstructor<_WidgetsInTemplateMixin> { | |
872 | */ |
|
872 | new(params: Object, srcNodeRef: dojo.NodeOrString): _WidgetsInTemplateMixin; | |
873 | _onMonthSelect(newMonth: number): void; |
|
873 | } | |
874 |
|
874 | |||
875 | /** |
|
875 | /* dijit/a11yclick */ | |
876 | * Handler for mouse over events on days, sets hovered style |
|
876 | ||
877 | */ |
|
877 | interface A11yClick { | |
878 | _onDayMouseOver(evt: MouseEvent): void; |
|
878 | ||
879 |
|
879 | /** | ||
880 | /** |
|
880 | * Custom press, release, and click synthetic events | |
881 | * Handler for mouse out events on days, clears hovered style |
|
881 | * which trigger on a left mouse click, touch, or space/enter keyup. | |
882 | */ |
|
882 | */ | |
883 | _onDayMouseOut(evt: MouseEvent): void; |
|
883 | (node: HTMLElement, listener: Function): dojo.Handle; | |
884 | _onDayMouseDown(evt: MouseEvent): void; |
|
884 | ||
885 | _onDayMouseUp(evt: MouseEvent): void; |
|
885 | /** | |
886 |
|
886 | * Mousedown (left button), touchstart, or keydown (space or enter) corresponding to logical click operation. | ||
887 | /** |
|
887 | */ | |
888 | * Provides keyboard navigation of calendar. |
|
888 | press: dojo.ExtensionEvent; | |
889 | */ |
|
889 | ||
890 | handleKey(evt: KeyboardEvent): void; |
|
890 | /** | |
891 |
|
891 | * Mouseup (left button), touchend, or keyup (space or enter) corresponding to logical click operation. | ||
892 | /** |
|
892 | */ | |
893 | * For handling keydown events on a stand alone calendar |
|
893 | release: dojo.ExtensionEvent; | |
894 | */ |
|
894 | ||
895 | _onKeyDown(evt: KeyboardEvent): void; |
|
895 | /** | |
896 |
|
896 | * Mouse cursor or a finger is dragged over the given node. | ||
897 | /** |
|
897 | */ | |
898 | * Deprecated. Notification that a date cell was selected. It may be the same as the previous value. |
|
898 | move: dojo.ExtensionEvent; | |
899 | */ |
|
899 | } | |
900 | onValueSelected(date: Date): void; |
|
900 | ||
901 |
|
901 | /* dijit/Calendar */ | ||
902 | onChange(date: Date): void; |
|
902 | ||
903 |
|
903 | interface _MonthDropDownButton extends form.DropDownButton<_MonthDropDown> { | ||
904 | /** |
|
904 | onMonthSelect(): void; | |
905 | * May be overridden to return CSS classes to associate with the date entry for the given dateObject |
|
905 | postCreate(): void; | |
906 | * for example to indicate a holiday in specified locale. |
|
906 | ||
907 | */ |
|
907 | //set(name: 'month', value: number): this; | |
908 | getClassForDate(dateObject: Date, locale?: string): string; |
|
908 | //set(name: string, value: any): this; | |
909 |
|
909 | //set(values: Object): this; | ||
910 | get(name: 'value'): Date; |
|
910 | } | |
911 | get(name: string): any; |
|
911 | ||
912 |
|
912 | interface _MonthDropDownButtonConstructor extends _WidgetBaseConstructor<_MonthDropDownButton> { } | ||
913 | set(name: 'value', value: number | Date): this; |
|
913 | ||
914 | set(name: string, value: any): this; |
|
914 | interface _MonthDropDown extends _Widget, _TemplatedMixin, _CssStateMixin { | |
915 | set(values: Object): this; |
|
915 | months: string[]; | |
916 | } |
|
916 | baseClass: string; | |
917 |
|
917 | templateString: string; | ||
918 | interface CalendarConstructor extends _WidgetBaseConstructor<Calendar> { |
|
918 | ||
919 | _MonthWidget: _MonthWidgetConstructor; |
|
919 | /** | |
920 | _MonthDropDown: _MonthDropDownButtonConstructor; |
|
920 | * Callback when month is selected from drop down | |
921 | _MonthDropDownButton: _MonthDropDownButtonConstructor; |
|
921 | */ | |
922 | } |
|
922 | onChange(month: number): void; | |
923 |
|
923 | |||
924 | /* dijit/CalendarLite */ |
|
924 | //set(name: 'months', value: string[]): this; | |
925 |
|
925 | //set(name: string, value: any): this; | ||
926 | interface _MonthWidget extends _WidgetBase { |
|
926 | //set(values: Object): this; | |
927 | set(name: 'month', value: Date): this; |
|
927 | } | |
928 | set(name: string, value: any): this; |
|
928 | ||
929 | set(values: Object): this; |
|
929 | interface _MonthDropDownConstructor extends _WidgetBaseConstructor<_MonthDropDown> { } | |
930 | } |
|
930 | ||
931 |
|
931 | interface Calendar extends CalendarLite, _Widget, _CssStateMixin { | ||
932 | interface _MonthWidgetConstructor extends _WidgetBaseConstructor<_MonthWidget> { } |
|
932 | ||
933 |
|
933 | baseClass: string; | ||
934 | interface CalendarLite extends _WidgetBase, _TemplatedMixin { |
|
934 | ||
935 | /** |
|
935 | /** | |
936 | * Template for main calendar |
|
936 | * Set node classes for various mouse events, see dijit._CssStateMixin for more details | |
937 | */ |
|
937 | */ | |
938 | templateString: string; |
|
938 | cssStateNodes: CSSStateNodes; | |
939 |
|
939 | |||
940 | /** |
|
940 | /** | |
941 | * Template for cell for a day of the week (ex: M) |
|
941 | * Creates the drop down button that displays the current month and lets user pick a new one | |
942 | */ |
|
942 | */ | |
943 | dowTemplateString: string; |
|
943 | _createMonthWidget(): _MonthDropDownButton; | |
944 |
|
944 | |||
945 | dateTemplateString: string; |
|
945 | postCreate(): void; | |
946 | weekTemplateString: string; |
|
946 | ||
947 |
|
947 | /** | ||
948 | /** |
|
948 | * Handler for when user selects a month from the drop down list | |
949 | * The currently selected Date, initially set to invalid date to indicate no selection. |
|
949 | */ | |
950 | */ |
|
950 | _onMonthSelect(newMonth: number): void; | |
951 | value: Date; |
|
951 | ||
952 |
|
952 | /** | ||
953 | /** |
|
953 | * Handler for mouse over events on days, sets hovered style | |
954 | * JavaScript namespace to find calendar routines. If unspecified, uses Gregorian calendar routines |
|
954 | */ | |
955 | * at dojo/date and dojo/date/locale. |
|
955 | _onDayMouseOver(evt: MouseEvent): void; | |
956 | */ |
|
956 | ||
957 | datePackage: string; |
|
957 | /** | |
958 |
|
958 | * Handler for mouse out events on days, clears hovered style | ||
959 | /** |
|
959 | */ | |
960 | * How to represent the days of the week in the calendar header. See locale |
|
960 | _onDayMouseOut(evt: MouseEvent): void; | |
961 | */ |
|
961 | _onDayMouseDown(evt: MouseEvent): void; | |
962 | dayWidth: string; |
|
962 | _onDayMouseUp(evt: MouseEvent): void; | |
963 |
|
963 | |||
964 | /** |
|
964 | /** | |
965 | * Order fields are traversed when user hits the tab key |
|
965 | * Provides keyboard navigation of calendar. | |
966 | */ |
|
966 | */ | |
967 | tabIndex: string; |
|
967 | handleKey(evt: KeyboardEvent): void; | |
968 |
|
968 | |||
969 | /** |
|
969 | /** | |
970 | * (Optional) The first day of week override. By default the first day of week is determined |
|
970 | * For handling keydown events on a stand alone calendar | |
971 | * for the current locale (extracted from the CLDR). |
|
971 | */ | |
972 | * Special value -1 (default value), means use locale dependent value. |
|
972 | _onKeyDown(evt: KeyboardEvent): void; | |
973 | */ |
|
973 | ||
974 | dayOffset: number; |
|
974 | /** | |
975 |
|
975 | * Deprecated. Notification that a date cell was selected. It may be the same as the previous value. | ||
976 | /** |
|
976 | */ | |
977 | * Date object containing the currently focused date, or the date which would be focused |
|
977 | onValueSelected(date: Date): void; | |
978 | * if the calendar itself was focused. Also indicates which year and month to display, |
|
978 | ||
979 | * i.e. the current "page" the calendar is on. |
|
979 | onChange(date: Date): void; | |
980 | */ |
|
980 | ||
981 | currentFocus: Date; |
|
981 | /** | |
982 |
|
982 | * May be overridden to return CSS classes to associate with the date entry for the given dateObject | ||
983 | /** |
|
983 | * for example to indicate a holiday in specified locale. | |
984 | * Put the summary to the node with role=grid |
|
984 | */ | |
985 | */ |
|
985 | getClassForDate(dateObject: Date, locale?: string): string; | |
986 | _setSummaryAttr: string; |
|
986 | ||
987 |
|
987 | // get(name: 'value'): Date; | ||
988 | baseClass: string; |
|
988 | // get(name: string): any; | |
989 |
|
989 | |||
990 | /** |
|
990 | // set(name: 'value', value: number | Date): this; | |
991 | * Runs various tests on the value, checking that it's a valid date, rather |
|
991 | // set(name: string, value: any): this; | |
992 | * than blank or NaN. |
|
992 | // set(values: Object): this; | |
993 | */ |
|
993 | } | |
994 | _isValidDate(value: Date): boolean; |
|
994 | ||
995 |
|
995 | interface CalendarConstructor extends _WidgetBaseConstructor<Calendar> { | ||
996 | /** |
|
996 | _MonthWidget: _MonthWidgetConstructor; | |
997 | * Convert Number into Date, or copy Date object. Then, round to nearest day, |
|
997 | _MonthDropDown: _MonthDropDownButtonConstructor; | |
998 | * setting to 1am to avoid issues when DST shift occurs at midnight, see #8521, #9366) |
|
998 | _MonthDropDownButton: _MonthDropDownButtonConstructor; | |
999 | */ |
|
999 | } | |
1000 | _patchDate(value: number | Date): Date; |
|
1000 | ||
1001 |
|
1001 | /* dijit/CalendarLite */ | ||
1002 | /** |
|
1002 | ||
1003 | * This just sets the content of node to the specified text. |
|
1003 | interface _MonthWidget extends _WidgetBase { | |
1004 | * Can't do "node.innerHTML=text" because of an IE bug w/tables, see #3434. |
|
1004 | // set(name: 'month', value: Date): this; | |
1005 | */ |
|
1005 | // set(name: string, value: any): this; | |
1006 | _setText(node: HTMLElement, text?: string): void; |
|
1006 | // set(values: Object): this; | |
1007 |
|
1007 | } | ||
1008 | /** |
|
1008 | ||
1009 | * Fills in the calendar grid with each day (1-31). |
|
1009 | interface _MonthWidgetConstructor extends _WidgetBaseConstructor<_MonthWidget> { } | |
1010 | * Call this on creation, when moving to a new month. |
|
1010 | ||
1011 | */ |
|
1011 | interface CalendarLite extends _WidgetBase, _TemplatedMixin { | |
1012 | _populateGrid(): void; |
|
1012 | /** | |
1013 |
|
1013 | * Template for main calendar | ||
1014 | /** |
|
1014 | */ | |
1015 | * Fill in localized month, and prev/current/next years |
|
1015 | templateString: string; | |
1016 | */ |
|
1016 | ||
1017 | _populateControls(): void; |
|
1017 | /** | |
1018 |
|
1018 | * Template for cell for a day of the week (ex: M) | ||
1019 | /** |
|
1019 | */ | |
1020 | * Sets calendar's value to today's date |
|
1020 | dowTemplateString: string; | |
1021 | */ |
|
1021 | ||
1022 | goToToday(): void; |
|
1022 | dateTemplateString: string; | |
1023 |
|
1023 | weekTemplateString: string; | ||
1024 | /** |
|
1024 | ||
1025 | * Creates the drop down button that displays the current month and lets user pick a new one |
|
1025 | /** | |
1026 | */ |
|
1026 | * The currently selected Date, initially set to invalid date to indicate no selection. | |
1027 | _createMonthWidget(): void; |
|
1027 | */ | |
1028 |
|
1028 | value: Date; | ||
1029 | buildRendering(): void; |
|
1029 | ||
1030 | postCreate(): void; |
|
1030 | /** | |
1031 |
|
1031 | * JavaScript namespace to find calendar routines. If unspecified, uses Gregorian calendar routines | ||
1032 | /** |
|
1032 | * at dojo/date and dojo/date/locale. | |
1033 | * Set up connects for increment/decrement of months/years |
|
1033 | */ | |
1034 | */ |
|
1034 | datePackage: string; | |
1035 | _connectControls(): void; |
|
1035 | ||
1036 |
|
1036 | /** | ||
1037 | /** |
|
1037 | * How to represent the days of the week in the calendar header. See locale | |
1038 | * If the calendar currently has focus, then focuses specified date, |
|
1038 | */ | |
1039 | * changing the currently displayed month/year if necessary. |
|
1039 | dayWidth: string; | |
1040 | * If the calendar doesn't have focus, updates currently |
|
1040 | ||
1041 | * displayed month/year, and sets the cell that will get focus |
|
1041 | /** | |
1042 | * when Calendar is focused. |
|
1042 | * Order fields are traversed when user hits the tab key | |
1043 | */ |
|
1043 | */ | |
1044 | _setCurrentFocusAttr(date: Date, forceFocus?: boolean): void; |
|
1044 | tabIndex: string; | |
1045 |
|
1045 | |||
1046 | /** |
|
1046 | /** | |
1047 | * Focus the calendar by focusing one of the calendar cells |
|
1047 | * (Optional) The first day of week override. By default the first day of week is determined | |
1048 | */ |
|
1048 | * for the current locale (extracted from the CLDR). | |
1049 | focus(): void; |
|
1049 | * Special value -1 (default value), means use locale dependent value. | |
1050 |
|
1050 | */ | ||
1051 | /** |
|
1051 | dayOffset: number; | |
1052 | * Handler for day clicks, selects the date if appropriate |
|
1052 | ||
1053 | */ |
|
1053 | /** | |
1054 | _onDayClick(evt: MouseEvent): void; |
|
1054 | * Date object containing the currently focused date, or the date which would be focused | |
1055 |
|
1055 | * if the calendar itself was focused. Also indicates which year and month to display, | ||
1056 | /** |
|
1056 | * i.e. the current "page" the calendar is on. | |
1057 | * Returns the cell corresponding to the date, or null if the date is not within the currently |
|
1057 | */ | |
1058 | * displayed month. |
|
1058 | currentFocus: Date; | |
1059 | */ |
|
1059 | ||
1060 | _getNodeByDate(value: Date): HTMLElement; |
|
1060 | /** | |
1061 |
|
1061 | * Put the summary to the node with role=grid | ||
1062 | /** |
|
1062 | */ | |
1063 | * Marks the specified cells as selected, and clears cells previously marked as selected. |
|
1063 | _setSummaryAttr: string; | |
1064 | * For CalendarLite at most one cell is selected at any point, but this allows an array |
|
1064 | ||
1065 | * for easy subclassing. |
|
1065 | baseClass: string; | |
1066 | */ |
|
1066 | ||
1067 | _markSelectedDates(dates: Date[]): void; |
|
1067 | /** | |
1068 |
|
1068 | * Runs various tests on the value, checking that it's a valid date, rather | ||
1069 | /** |
|
1069 | * than blank or NaN. | |
1070 | * Called only when the selected date has changed |
|
1070 | */ | |
1071 | */ |
|
1071 | _isValidDate(value: Date): boolean; | |
1072 | onChange(date: Date): void; |
|
1072 | ||
1073 |
|
1073 | /** | ||
1074 | /** |
|
1074 | * Convert Number into Date, or copy Date object. Then, round to nearest day, | |
1075 | * May be overridden to disable certain dates in the calendar e.g. `isDisabledDate=dojo.date.locale.isWeekend` |
|
1075 | * setting to 1am to avoid issues when DST shift occurs at midnight, see #8521, #9366) | |
1076 | */ |
|
1076 | */ | |
1077 | isDisabledDate(dateObject: Date, locale?: string): boolean; |
|
1077 | _patchDate(value: number | Date): Date; | |
1078 |
|
1078 | |||
1079 | /** |
|
1079 | /** | |
1080 | * May be overridden to return CSS classes to associate with the date entry for the given dateObject, |
|
1080 | * This just sets the content of node to the specified text. | |
1081 | * for example to indicate a holiday in specified locale. |
|
1081 | * Can't do "node.innerHTML=text" because of an IE bug w/tables, see #3434. | |
1082 | */ |
|
1082 | */ | |
1083 | getClassForDate(dateObject: Date, locale?: string): string; |
|
1083 | _setText(node: HTMLElement, text?: string): void; | |
1084 |
|
1084 | |||
1085 | get(name: 'value'): Date; |
|
1085 | /** | |
1086 | get(name: string): any; |
|
1086 | * Fills in the calendar grid with each day (1-31). | |
1087 |
|
1087 | * Call this on creation, when moving to a new month. | ||
1088 | set(name: 'value', value: number | Date): this; |
|
1088 | */ | |
1089 | set(name: string, value: any): this; |
|
1089 | _populateGrid(): void; | |
1090 | set(values: Object): this; |
|
1090 | ||
1091 | } |
|
1091 | /** | |
1092 |
|
1092 | * Fill in localized month, and prev/current/next years | ||
1093 | interface CalendarLiteConstructor extends _WidgetBaseConstructor<CalendarLite> { |
|
1093 | */ | |
1094 | _MonthWidget: _MonthWidgetConstructor; |
|
1094 | _populateControls(): void; | |
1095 | } |
|
1095 | ||
1096 |
|
1096 | /** | ||
1097 | /* dijit/Destroyable */ |
|
1097 | * Sets calendar's value to today's date | |
1098 |
|
1098 | */ | ||
1099 | interface Destroyable { |
|
1099 | goToToday(): void; | |
1100 | _destroyed?: true; |
|
1100 | ||
1101 |
|
1101 | /** | ||
1102 | /** |
|
1102 | * Creates the drop down button that displays the current month and lets user pick a new one | |
1103 | * Destroy this class, releasing any resources registered via own(). |
|
1103 | */ | |
1104 | */ |
|
1104 | _createMonthWidget(): void; | |
1105 | destroy(preserveDom?: boolean): void; |
|
1105 | ||
1106 |
|
1106 | buildRendering(): void; | ||
1107 | /** |
|
1107 | postCreate(): void; | |
1108 | * Track specified handles and remove/destroy them when this instance is destroyed, unless they were |
|
1108 | ||
1109 | * already removed/destroyed manually. |
|
1109 | /** | |
1110 | */ |
|
1110 | * Set up connects for increment/decrement of months/years | |
1111 | own(...args: any[]): any[]; |
|
1111 | */ | |
1112 | } |
|
1112 | _connectControls(): void; | |
1113 |
|
1113 | |||
1114 | /** |
|
1114 | /** | |
1115 | * Mixin to track handles and release them when instance is destroyed. |
|
1115 | * If the calendar currently has focus, then focuses specified date, | |
1116 | */ |
|
1116 | * changing the currently displayed month/year if necessary. | |
1117 | interface DestroyableConstructor extends dojo._base.DeclareConstructor<Destroyable> { } |
|
1117 | * If the calendar doesn't have focus, updates currently | |
1118 |
|
1118 | * displayed month/year, and sets the cell that will get focus | ||
1119 | /** dijit/_KeyNavMixin */ |
|
1119 | * when Calendar is focused. | |
1120 |
|
1120 | */ | ||
1121 | /** |
|
1121 | _setCurrentFocusAttr(date: Date, forceFocus?: boolean): void; | |
1122 | * A mixin to allow arrow key and letter key navigation of child or descendant widgets. |
|
1122 | ||
1123 | * It can be used by dijit/_Container based widgets with a flat list of children, or more complex widgets like dijit/Tree. |
|
1123 | /** | |
1124 | * |
|
1124 | * Focus the calendar by focusing one of the calendar cells | |
1125 | * To use this mixin, the subclass must: |
|
1125 | */ | |
1126 | * |
|
1126 | focus(): void; | |
1127 | * - Implement _getNext(), _getFirst(), _getLast(), _onLeftArrow(), _onRightArrow() _onDownArrow(), _onUpArrow() methods to handle home/end/left/right/up/down keystrokes. Next and previous in this context refer to a linear ordering of the descendants used by letter key search. |
|
1127 | ||
1128 | * - Set all descendants' initial tabIndex to "-1"; both initial descendants and any descendants added later, by for example addChild() |
|
1128 | /** | |
1129 | * - Define childSelector to a function or string that identifies focusable descendant widgets |
|
1129 | * Handler for day clicks, selects the date if appropriate | |
1130 | * |
|
1130 | */ | |
1131 | * Also, child widgets must implement a focus() method. |
|
1131 | _onDayClick(evt: MouseEvent): void; | |
1132 | */ |
|
1132 | ||
1133 | interface _KeyNavMixin extends _FocusMixin { |
|
1133 | /** | |
1134 | /** |
|
1134 | * Returns the cell corresponding to the date, or null if the date is not within the currently | |
1135 | * Tab index of the container; same as HTML tabIndex attribute. |
|
1135 | * displayed month. | |
1136 | * Note then when user tabs into the container, focus is immediately moved to the first item in the container. |
|
1136 | */ | |
1137 | */ |
|
1137 | _getNodeByDate(value: Date): HTMLElement; | |
1138 | tabIndex: string; |
|
1138 | ||
1139 |
|
1139 | /** | ||
1140 | /** |
|
1140 | * Marks the specified cells as selected, and clears cells previously marked as selected. | |
1141 | * Selector (passed to on.selector()) used to identify what to treat as a child widget. Used to monitor focus events and set this.focusedChild. Must be set by implementing class. If this is a string (ex: "> *") then the implementing class must require dojo/query. |
|
1141 | * For CalendarLite at most one cell is selected at any point, but this allows an array | |
1142 | */ |
|
1142 | * for easy subclassing. | |
1143 | childSelector: string | Function | null; |
|
1143 | */ | |
1144 |
|
1144 | _markSelectedDates(dates: Date[]): void; | ||
1145 | /** |
|
1145 | ||
1146 | * Called on left arrow key, or right arrow key if widget is in RTL mode. |
|
1146 | /** | |
1147 | * Should go back to the previous child in horizontal container widgets like Toolbar. |
|
1147 | * Called only when the selected date has changed | |
1148 | */ |
|
1148 | */ | |
1149 | _onLeftArrow(evt?: KeyboardEvent): void; |
|
1149 | onChange(date: Date): void; | |
1150 |
|
1150 | |||
1151 | /** |
|
1151 | /** | |
1152 | * Called on right arrow key, or left arrow key if widget is in RTL mode. |
|
1152 | * May be overridden to disable certain dates in the calendar e.g. `isDisabledDate=dojo.date.locale.isWeekend` | |
1153 | * Should go to the next child in horizontal container widgets like Toolbar. |
|
1153 | */ | |
1154 | */ |
|
1154 | isDisabledDate(dateObject: Date, locale?: string): boolean; | |
1155 | _onRightArrow(evt?: KeyboardEvent): void; |
|
1155 | ||
1156 |
|
1156 | /** | ||
1157 | /** |
|
1157 | * May be overridden to return CSS classes to associate with the date entry for the given dateObject, | |
1158 | * Called on up arrow key. Should go to the previous child in vertical container widgets like Menu. |
|
1158 | * for example to indicate a holiday in specified locale. | |
1159 | */ |
|
1159 | */ | |
1160 | _onUpArrow(evt?: KeyboardEvent): void; |
|
1160 | getClassForDate(dateObject: Date, locale?: string): string; | |
1161 |
|
1161 | |||
1162 | /** |
|
1162 | // get(name: 'value'): Date; | |
1163 | * Called on down arrow key. Should go to the next child in vertical container widgets like Menu. |
|
1163 | // get(name: string): any; | |
1164 | */ |
|
1164 | ||
1165 | _onDownArrow(evt?: KeyboardEvent): void; |
|
1165 | // set(name: 'value', value: number | Date): this; | |
1166 |
|
1166 | // set(name: string, value: any): this; | ||
1167 | /** |
|
1167 | // set(values: Object): this; | |
1168 | * Default focus() implementation: focus the first child. |
|
1168 | } | |
1169 | */ |
|
1169 | ||
1170 | focus(): void; |
|
1170 | interface CalendarLiteConstructor extends _WidgetBaseConstructor<CalendarLite> { | |
1171 |
|
1171 | _MonthWidget: _MonthWidgetConstructor; | ||
1172 | /** |
|
1172 | } | |
1173 | * Returns first child that can be focused. |
|
1173 | ||
1174 | */ |
|
1174 | /* dijit/Destroyable */ | |
1175 | _getFirstFocusableChild(): _WidgetBase; |
|
1175 | ||
1176 |
|
1176 | interface Destroyable { | ||
1177 | /** |
|
1177 | _destroyed?: true; | |
1178 | * Returns last child that can be focused. |
|
1178 | ||
1179 | */ |
|
1179 | /** | |
1180 | _getLastFocusableChild(): _WidgetBase; |
|
1180 | * Destroy this class, releasing any resources registered via own(). | |
1181 |
|
1181 | */ | ||
1182 | /** |
|
1182 | destroy(preserveDom?: boolean): void; | |
1183 | * Focus the first focusable child in the container. |
|
1183 | ||
1184 | */ |
|
1184 | /** | |
1185 | focusFirstChild(): void; |
|
1185 | * Track specified handles and remove/destroy them when this instance is destroyed, unless they were | |
1186 |
|
1186 | * already removed/destroyed manually. | ||
1187 | /** |
|
1187 | */ | |
1188 | * Focus the last focusable child in the container. |
|
1188 | own(...args: any[]): any[]; | |
1189 | */ |
|
1189 | } | |
1190 | focusLastChild(): void; |
|
1190 | ||
1191 |
|
1191 | /** | ||
1192 | /** |
|
1192 | * Mixin to track handles and release them when instance is destroyed. | |
1193 | * Focus specified child widget. |
|
1193 | */ | |
1194 | * |
|
1194 | interface DestroyableConstructor extends dojo._base.DeclareConstructor<Destroyable> { } | |
1195 | * @param widget Reference to container's child widget |
|
1195 | ||
1196 | * @param last If true and if widget has multiple focusable nodes, focus the last one instead of the first one |
|
1196 | /** dijit/_KeyNavMixin */ | |
1197 | */ |
|
1197 | ||
1198 | focusChild(widget: _WidgetBase, last?: boolean): void; |
|
1198 | /** | |
1199 |
|
1199 | * A mixin to allow arrow key and letter key navigation of child or descendant widgets. | ||
1200 | /** |
|
1200 | * It can be used by dijit/_Container based widgets with a flat list of children, or more complex widgets like dijit/Tree. | |
1201 | * Handler for when the container itself gets focus. |
|
1201 | * | |
1202 | * |
|
1202 | * To use this mixin, the subclass must: | |
1203 | * Initially the container itself has a tabIndex, but when it gets focus, switch focus to first child. |
|
1203 | * | |
1204 | */ |
|
1204 | * - Implement _getNext(), _getFirst(), _getLast(), _onLeftArrow(), _onRightArrow() _onDownArrow(), _onUpArrow() methods to handle home/end/left/right/up/down keystrokes. Next and previous in this context refer to a linear ordering of the descendants used by letter key search. | |
1205 | _onContainerFocus(evt: Event): void; |
|
1205 | * - Set all descendants' initial tabIndex to "-1"; both initial descendants and any descendants added later, by for example addChild() | |
1206 |
|
1206 | * - Define childSelector to a function or string that identifies focusable descendant widgets | ||
1207 | /** |
|
1207 | * | |
1208 | * Called when a child widget gets focus, either by user clicking it, or programatically by arrow key handling code. |
|
1208 | * Also, child widgets must implement a focus() method. | |
1209 | * |
|
1209 | */ | |
1210 | * It marks that the current node is the selected one, and the previously selected node no longer is. |
|
1210 | interface _KeyNavMixin extends _FocusMixin { | |
1211 | */ |
|
1211 | /** | |
1212 | _onChildFocus(child?: _WidgetBase): void; |
|
1212 | * Tab index of the container; same as HTML tabIndex attribute. | |
1213 |
|
1213 | * Note then when user tabs into the container, focus is immediately moved to the first item in the container. | ||
1214 | _searchString: string; |
|
1214 | */ | |
1215 |
|
1215 | tabIndex: string; | ||
1216 | multiCharSearchDuration: number; |
|
1216 | ||
1217 |
|
1217 | /** | ||
1218 | /** |
|
1218 | * Selector (passed to on.selector()) used to identify what to treat as a child widget. Used to monitor focus events and set this.focusedChild. Must be set by implementing class. If this is a string (ex: "> *") then the implementing class must require dojo/query. | |
1219 | * When a key is pressed that matches a child item, this method is called so that a widget can take appropriate action is necessary. |
|
1219 | */ | |
1220 | */ |
|
1220 | childSelector: string | Function | null; | |
1221 | onKeyboardSearch(tem: _WidgetBase, evt: Event, searchString: string, numMatches: number): void; |
|
1221 | ||
1222 |
|
1222 | /** | ||
1223 | /** |
|
1223 | * Called on left arrow key, or right arrow key if widget is in RTL mode. | |
1224 | * Compares the searchString to the widget's text label, returning: |
|
1224 | * Should go back to the previous child in horizontal container widgets like Toolbar. | |
1225 | * |
|
1225 | */ | |
1226 | * * -1: a high priority match and stop searching |
|
1226 | _onLeftArrow(evt?: KeyboardEvent): void; | |
1227 | * * 0: not a match |
|
1227 | ||
1228 | * * 1: a match but keep looking for a higher priority match |
|
1228 | /** | |
1229 | */ |
|
1229 | * Called on right arrow key, or left arrow key if widget is in RTL mode. | |
1230 | _keyboardSearchCompare(item: _WidgetBase, searchString: string): -1 | 0 | 1; |
|
1230 | * Should go to the next child in horizontal container widgets like Toolbar. | |
1231 |
|
1231 | */ | ||
1232 | /** |
|
1232 | _onRightArrow(evt?: KeyboardEvent): void; | |
1233 | * When a key is pressed, if it's an arrow key etc. then it's handled here. |
|
1233 | ||
1234 | */ |
|
1234 | /** | |
1235 | _onContainerKeydown(evt: Event): void; |
|
1235 | * Called on up arrow key. Should go to the previous child in vertical container widgets like Menu. | |
1236 |
|
1236 | */ | ||
1237 | /** |
|
1237 | _onUpArrow(evt?: KeyboardEvent): void; | |
1238 | * When a printable key is pressed, it's handled here, searching by letter. |
|
1238 | ||
1239 | */ |
|
1239 | /** | |
1240 | _onContainerKeypress(evt: Event): void; |
|
1240 | * Called on down arrow key. Should go to the next child in vertical container widgets like Menu. | |
1241 |
|
1241 | */ | ||
1242 | /** |
|
1242 | _onDownArrow(evt?: KeyboardEvent): void; | |
1243 | * Perform a search of the widget's options based on the user's keyboard activity |
|
1243 | ||
1244 | * |
|
1244 | /** | |
1245 | * Called on keypress (and sometimes keydown), searches through this widget's children looking for items that match the user's typed search string. Multiple characters typed within 1 sec of each other are combined for multicharacter searching. |
|
1245 | * Default focus() implementation: focus the first child. | |
1246 | */ |
|
1246 | */ | |
1247 | _keyboardSearch(evt: Event, keyChar: string): void; |
|
1247 | focus(): void; | |
1248 |
|
1248 | |||
1249 | /** |
|
1249 | /** | |
1250 | * Called when focus leaves a child widget to go to a sibling widget. |
|
1250 | * Returns first child that can be focused. | |
1251 | */ |
|
1251 | */ | |
1252 | _onChildBlur(widget: _WidgetBase): void; |
|
1252 | _getFirstFocusableChild(): _WidgetBase; | |
1253 |
|
1253 | |||
1254 | /** |
|
1254 | /** | |
1255 | * Returns the next or previous focusable descendant, compared to "child". |
|
1255 | * Returns last child that can be focused. | |
1256 | * Implements and extends _KeyNavMixin._getNextFocusableChild() for a _Container. |
|
1256 | */ | |
1257 | */ |
|
1257 | _getLastFocusableChild(): _WidgetBase; | |
1258 | _getNextFocusableChild(child: _WidgetBase, dir: 1 | -1): _WidgetBase | null; |
|
1258 | ||
1259 |
|
1259 | /** | ||
1260 | /** |
|
1260 | * Focus the first focusable child in the container. | |
1261 | * Returns the first child. |
|
1261 | */ | |
1262 | */ |
|
1262 | focusFirstChild(): void; | |
1263 | _getFirst(): _WidgetBase | null; |
|
1263 | ||
1264 |
|
1264 | /** | ||
1265 | /** |
|
1265 | * Focus the last focusable child in the container. | |
1266 | * Returns the last descendant. |
|
1266 | */ | |
1267 | */ |
|
1267 | focusLastChild(): void; | |
1268 | _getLast(): _WidgetBase | null; |
|
1268 | ||
1269 |
|
1269 | /** | ||
1270 | /** |
|
1270 | * Focus specified child widget. | |
1271 | * Returns the next descendant, compared to "child". |
|
1271 | * | |
1272 | */ |
|
1272 | * @param widget Reference to container's child widget | |
1273 | _getNext(child: _WidgetBase, dir: 1 | -1): _WidgetBase | null; |
|
1273 | * @param last If true and if widget has multiple focusable nodes, focus the last one instead of the first one | |
1274 | } |
|
1274 | */ | |
1275 |
|
1275 | focusChild(widget: _WidgetBase, last?: boolean): void; | ||
1276 | interface _KeyNavMixinConstructor extends dojo._base.DeclareConstructor<_KeyNavMixin> { } |
|
1276 | ||
1277 |
|
1277 | /** | ||
1278 | /* dijit/_KeyNavContainer */ |
|
1278 | * Handler for when the container itself gets focus. | |
1279 |
|
1279 | * | ||
1280 | /** |
|
1280 | * Initially the container itself has a tabIndex, but when it gets focus, switch focus to first child. | |
1281 | * A _Container with keyboard navigation of its children. |
|
1281 | */ | |
1282 | * |
|
1282 | _onContainerFocus(evt: Event): void; | |
1283 | * Provides normalized keyboard and focusing code for Container widgets. |
|
1283 | ||
1284 | * To use this mixin, call connectKeyNavHandlers() in postCreate(). |
|
1284 | /** | |
1285 | * Also, child widgets must implement a focus() method. |
|
1285 | * Called when a child widget gets focus, either by user clicking it, or programatically by arrow key handling code. | |
1286 | */ |
|
1286 | * | |
1287 | interface _KeyNavContainer extends _FocusMixin, _KeyNavMixin, _Container { |
|
1287 | * It marks that the current node is the selected one, and the previously selected node no longer is. | |
1288 | /** |
|
1288 | */ | |
1289 | * Deprecated. You can call this in postCreate() to attach the keyboard handlers to the container, but the preferred method is to override _onLeftArrow() and _onRightArrow(), or _onUpArrow() and _onDownArrow(), to call focusPrev() and focusNext(). |
|
1289 | _onChildFocus(child?: _WidgetBase): void; | |
1290 | * |
|
1290 | ||
1291 | * @param prevKeyCodes Key codes for navigating to the previous child. |
|
1291 | _searchString: string; | |
1292 | * @param nextKeyCodes Key codes for navigating to the next child. |
|
1292 | ||
1293 | */ |
|
1293 | multiCharSearchDuration: number; | |
1294 | connectKeyNavHandlers(prevKeyCodes: number[], nextKeyCodes: number[]): void; |
|
1294 | ||
1295 |
|
1295 | /** | ||
1296 | /** |
|
1296 | * When a key is pressed that matches a child item, this method is called so that a widget can take appropriate action is necessary. | |
1297 | * @deprecated |
|
1297 | */ | |
1298 | */ |
|
1298 | onKeyboardSearch(tem: _WidgetBase, evt: Event, searchString: string, numMatches: number): void; | |
1299 | startupKeyNavChildren(): void; |
|
1299 | ||
1300 |
|
1300 | /** | ||
1301 | /** |
|
1301 | * Compares the searchString to the widget's text label, returning: | |
1302 | * Setup for each child widget. |
|
1302 | * | |
1303 | * |
|
1303 | * * -1: a high priority match and stop searching | |
1304 | * Sets tabIndex=-1 on each child, so that the tab key will leave the container rather than visiting each child. |
|
1304 | * * 0: not a match | |
1305 | * |
|
1305 | * * 1: a match but keep looking for a higher priority match | |
1306 | * Note: if you add children by a different method than addChild(), then need to call this manually or at least make sure the child's tabIndex is -1. |
|
1306 | */ | |
1307 | * |
|
1307 | _keyboardSearchCompare(item: _WidgetBase, searchString: string): -1 | 0 | 1; | |
1308 | * Note: see also _LayoutWidget.setupChild(), which is also called for each child widget. |
|
1308 | ||
1309 | */ |
|
1309 | /** | |
1310 | _startupChild(widget: _WidgetBase): void; |
|
1310 | * When a key is pressed, if it's an arrow key etc. then it's handled here. | |
1311 |
|
1311 | */ | ||
1312 | /** |
|
1312 | _onContainerKeydown(evt: Event): void; | |
1313 | * Returns the first child. |
|
1313 | ||
1314 | */ |
|
1314 | /** | |
1315 | _getFirst(): _Widget | null; |
|
1315 | * When a printable key is pressed, it's handled here, searching by letter. | |
1316 |
|
1316 | */ | ||
1317 | /** |
|
1317 | _onContainerKeypress(evt: Event): void; | |
1318 | * Returns the last descendant. |
|
1318 | ||
1319 | */ |
|
1319 | /** | |
1320 | _getLast(): _Widget | null; |
|
1320 | * Perform a search of the widget's options based on the user's keyboard activity | |
1321 |
|
1321 | * | ||
1322 | /** |
|
1322 | * Called on keypress (and sometimes keydown), searches through this widget's children looking for items that match the user's typed search string. Multiple characters typed within 1 sec of each other are combined for multicharacter searching. | |
1323 | * Focus the next widget |
|
1323 | */ | |
1324 | */ |
|
1324 | _keyboardSearch(evt: Event, keyChar: string): void; | |
1325 | focusNext(): void; |
|
1325 | ||
1326 |
|
1326 | /** | ||
1327 | /** |
|
1327 | * Called when focus leaves a child widget to go to a sibling widget. | |
1328 | * Focus the last focusable node in the previous widget |
|
1328 | */ | |
1329 | * |
|
1329 | _onChildBlur(widget: _WidgetBase): void; | |
1330 | * (ex: go to the ComboButton icon section rather than button section) |
|
1330 | ||
1331 | */ |
|
1331 | /** | |
1332 | focusPrev(): void; |
|
1332 | * Returns the next or previous focusable descendant, compared to "child". | |
1333 |
|
1333 | * Implements and extends _KeyNavMixin._getNextFocusableChild() for a _Container. | ||
1334 | /** |
|
1334 | */ | |
1335 | * Implement _KeyNavMixin.childSelector, to identify focusable child nodes. |
|
1335 | _getNextFocusableChild(child: _WidgetBase, dir: 1 | -1): _WidgetBase | null; | |
1336 | * |
|
1336 | ||
1337 | * If we allowed a dojo/query dependency from this module this could more simply be a string "> *" instead of this function. |
|
1337 | /** | |
1338 | */ |
|
1338 | * Returns the first child. | |
1339 | childSelector(node: Element | Node): boolean | void | any; |
|
1339 | */ | |
1340 | } |
|
1340 | _getFirst(): _WidgetBase | null; | |
1341 |
|
1341 | |||
1342 | interface _KeyNavContainerConstructor extends dojo._base.DeclareConstructor<_KeyNavContainer> { } |
|
1342 | /** | |
1343 |
|
1343 | * Returns the last descendant. | ||
1344 | /* dijit/_MenuBase */ |
|
1344 | */ | |
1345 |
|
1345 | _getLast(): _WidgetBase | null; | ||
1346 | /** |
|
1346 | ||
1347 | * Abstract base class for Menu and MenuBar. |
|
1347 | /** | |
1348 | * Subclass should implement _onUpArrow(), _onDownArrow(), _onLeftArrow(), and _onRightArrow(). |
|
1348 | * Returns the next descendant, compared to "child". | |
1349 | */ |
|
1349 | */ | |
1350 | interface _MenuBase extends _Widget, _TemplatedMixin, _KeyNavContainer, _CssStateMixin { |
|
1350 | _getNext(child: _WidgetBase, dir: 1 | -1): _WidgetBase | null; | |
1351 | selected: MenuItem | null; |
|
1351 | } | |
1352 |
|
1352 | |||
1353 | _setSelectedAttr(item?: MenuItem | null): void; |
|
1353 | interface _KeyNavMixinConstructor extends dojo._base.DeclareConstructor<_KeyNavMixin> { } | |
1354 |
|
1354 | |||
1355 | /** |
|
1355 | /* dijit/_KeyNavContainer */ | |
1356 | * This Menu has been clicked (mouse or via space/arrow key) or opened as a submenu, so mere mouseover will open submenus. Focusing a menu via TAB does NOT automatically make it active since TAB is a navigation operation and not a selection one. |
|
1356 | ||
1357 | * |
|
1357 | /** | |
1358 | * For Windows apps, pressing the ALT key focuses the menubar menus (similar to TAB navigation) but the menu is not active (ie no dropdown) until an item is clicked. |
|
1358 | * A _Container with keyboard navigation of its children. | |
1359 | */ |
|
1359 | * | |
1360 | activated: boolean; |
|
1360 | * Provides normalized keyboard and focusing code for Container widgets. | |
1361 |
|
1361 | * To use this mixin, call connectKeyNavHandlers() in postCreate(). | ||
1362 | _setActivatedAttr(val: boolean): void; |
|
1362 | * Also, child widgets must implement a focus() method. | |
1363 |
|
1363 | */ | ||
1364 | /** |
|
1364 | interface _KeyNavContainer extends _FocusMixin, _KeyNavMixin, _Container { | |
1365 | * pointer to menu that displayed me |
|
1365 | /** | |
1366 | */ |
|
1366 | * Deprecated. You can call this in postCreate() to attach the keyboard handlers to the container, but the preferred method is to override _onLeftArrow() and _onRightArrow(), or _onUpArrow() and _onDownArrow(), to call focusPrev() and focusNext(). | |
1367 | parentMenu: _Widget | null; |
|
1367 | * | |
1368 |
|
1368 | * @param prevKeyCodes Key codes for navigating to the previous child. | ||
1369 | /** |
|
1369 | * @param nextKeyCodes Key codes for navigating to the next child. | |
1370 | * After a menu has been activated (by clicking on it etc.), number of milliseconds before hovering (without clicking) another MenuItem causes that MenuItem's popup to automatically open. |
|
1370 | */ | |
1371 | */ |
|
1371 | connectKeyNavHandlers(prevKeyCodes: number[], nextKeyCodes: number[]): void; | |
1372 | popupDelay: number; |
|
1372 | ||
1373 |
|
1373 | /** | ||
1374 | /** |
|
1374 | * @deprecated | |
1375 | * For a passive (unclicked) Menu, number of milliseconds before hovering (without clicking) will cause the popup to open. Default is Infinity, meaning you need to click the menu to open it. |
|
1375 | */ | |
1376 | */ |
|
1376 | startupKeyNavChildren(): void; | |
1377 | passivePopupDelay: number; |
|
1377 | ||
1378 |
|
1378 | /** | ||
1379 | /** |
|
1379 | * Setup for each child widget. | |
1380 | * A toggle to control whether or not a Menu gets focused when opened as a drop down from a MenuBar or DropDownButton/ComboButton. Note though that it always get focused when opened via the keyboard. |
|
1380 | * | |
1381 | */ |
|
1381 | * Sets tabIndex=-1 on each child, so that the tab key will leave the container rather than visiting each child. | |
1382 | autoFocus: boolean; |
|
1382 | * | |
1383 |
|
1383 | * Note: if you add children by a different method than addChild(), then need to call this manually or at least make sure the child's tabIndex is -1. | ||
1384 | /** |
|
1384 | * | |
1385 | * Selector (passed to on.selector()) used to identify MenuItem child widgets, but exclude inert children like MenuSeparator. If subclass overrides to a string (ex: "> *"), the subclass must require dojo/query. |
|
1385 | * Note: see also _LayoutWidget.setupChild(), which is also called for each child widget. | |
1386 | */ |
|
1386 | */ | |
1387 | childSelector(node: Element | Node): boolean | void | Function; |
|
1387 | _startupChild(widget: _WidgetBase): void; | |
1388 |
|
1388 | |||
1389 | /** |
|
1389 | /** | |
1390 | * Attach point for notification about when a menu item has been executed. This is an internal mechanism used for Menus to signal to their parent to close them, because they are about to execute the onClick handler. In general developers should not attach to or override this method. |
|
1390 | * Returns the first child. | |
1391 | */ |
|
1391 | */ | |
1392 | onExecute(): void; |
|
1392 | _getFirst(): _Widget | null; | |
1393 |
|
1393 | |||
1394 | /** |
|
1394 | /** | |
1395 | * Attach point for notification about when the user cancels the current menu |
|
1395 | * Returns the last descendant. | |
1396 | * This is an internal mechanism used for Menus to signal to their parent to close them. In general developers should not attach to or override this method. |
|
1396 | */ | |
1397 | */ |
|
1397 | _getLast(): _Widget | null; | |
1398 | onCancel(): void; |
|
1398 | ||
1399 |
|
1399 | /** | ||
1400 | /** |
|
1400 | * Focus the next widget | |
1401 | * This handles the right arrow key (left arrow key on RTL systems), which will either open a submenu, or move to the next item in the ancestor MenuBar |
|
1401 | */ | |
1402 | */ |
|
1402 | focusNext(): void; | |
1403 | _moveToPopup(evt: Event): void; |
|
1403 | ||
1404 |
|
1404 | /** | ||
1405 | /** |
|
1405 | * Focus the last focusable node in the previous widget | |
1406 | * This handler is called when the mouse moves over the popup. |
|
1406 | * | |
1407 | */ |
|
1407 | * (ex: go to the ComboButton icon section rather than button section) | |
1408 | _onPopupHover(evt?: MouseEvent): void; |
|
1408 | */ | |
1409 |
|
1409 | focusPrev(): void; | ||
1410 | /** |
|
1410 | ||
1411 | * Called when cursor is over a MenuItem. |
|
1411 | /** | |
1412 | */ |
|
1412 | * Implement _KeyNavMixin.childSelector, to identify focusable child nodes. | |
1413 | onItemHover(item: MenuItem): void; |
|
1413 | * | |
1414 |
|
1414 | * If we allowed a dojo/query dependency from this module this could more simply be a string "> *" instead of this function. | ||
1415 | /** |
|
1415 | */ | |
1416 | * Called when a child MenuItem becomes deselected. Setup timer to close its popup. |
|
1416 | childSelector(node: Element | Node): boolean | void | any; | |
1417 | */ |
|
1417 | } | |
1418 | _onChildDeselect(item: MenuItem): void; |
|
1418 | ||
1419 |
|
1419 | interface _KeyNavContainerConstructor extends dojo._base.DeclareConstructor<_KeyNavContainer> { } | ||
1420 | /** |
|
1420 | ||
1421 | * Callback fires when mouse exits a MenuItem |
|
1421 | /* dijit/_MenuBase */ | |
1422 | */ |
|
1422 | ||
1423 | onItemUnhover(item: MenuItem): void; |
|
1423 | /** | |
1424 |
|
1424 | * Abstract base class for Menu and MenuBar. | ||
1425 | /** |
|
1425 | * Subclass should implement _onUpArrow(), _onDownArrow(), _onLeftArrow(), and _onRightArrow(). | |
1426 | * Cancels the popup timer because the user has stop hovering on the MenuItem, etc. |
|
1426 | */ | |
1427 | */ |
|
1427 | interface _MenuBase extends _Widget, _TemplatedMixin, _KeyNavContainer, _CssStateMixin { | |
1428 | _stopPopupTimer(): void; |
|
1428 | selected: MenuItem | null; | |
1429 |
|
1429 | |||
1430 | /** |
|
1430 | _setSelectedAttr(item?: MenuItem | null): void; | |
1431 | * Cancels the pending-close timer because the close has been preempted |
|
1431 | ||
1432 | */ |
|
1432 | /** | |
1433 | _stopPendingCloseTimer(): void; |
|
1433 | * This Menu has been clicked (mouse or via space/arrow key) or opened as a submenu, so mere mouseover will open submenus. Focusing a menu via TAB does NOT automatically make it active since TAB is a navigation operation and not a selection one. | |
1434 |
|
1434 | * | ||
1435 | /** |
|
1435 | * For Windows apps, pressing the ALT key focuses the menubar menus (similar to TAB navigation) but the menu is not active (ie no dropdown) until an item is clicked. | |
1436 | * Returns the top menu in this chain of Menus |
|
1436 | */ | |
1437 | */ |
|
1437 | activated: boolean; | |
1438 | _getTopMenu(): void; |
|
1438 | ||
1439 |
|
1439 | _setActivatedAttr(val: boolean): void; | ||
1440 | /** |
|
1440 | ||
1441 | * Handle clicks on an item. |
|
1441 | /** | |
1442 | */ |
|
1442 | * pointer to menu that displayed me | |
1443 | onItemClick(item: _WidgetBase, evt: Event): void; |
|
1443 | */ | |
1444 |
|
1444 | parentMenu: _Widget | null; | ||
1445 | /** |
|
1445 | ||
1446 | * Open the popup to the side of/underneath the current menu item, and optionally focus first item |
|
1446 | /** | |
1447 | */ |
|
1447 | * After a menu has been activated (by clicking on it etc.), number of milliseconds before hovering (without clicking) another MenuItem causes that MenuItem's popup to automatically open. | |
1448 | _openItemPopup(fromItem: MenuItem, focus: boolean): void; |
|
1448 | */ | |
1449 |
|
1449 | popupDelay: number; | ||
1450 | /** |
|
1450 | ||
1451 | * Callback when this menu is opened. |
|
1451 | /** | |
1452 | * This is called by the popup manager as notification that the menu was opened. |
|
1452 | * For a passive (unclicked) Menu, number of milliseconds before hovering (without clicking) will cause the popup to open. Default is Infinity, meaning you need to click the menu to open it. | |
1453 | */ |
|
1453 | */ | |
1454 | onOpen(evt?: Event): void; |
|
1454 | passivePopupDelay: number; | |
1455 |
|
1455 | |||
1456 | /** |
|
1456 | /** | |
1457 | * Callback when this menu is closed. |
|
1457 | * A toggle to control whether or not a Menu gets focused when opened as a drop down from a MenuBar or DropDownButton/ComboButton. Note though that it always get focused when opened via the keyboard. | |
1458 | * This is called by the popup manager as notification that the menu was closed. |
|
1458 | */ | |
1459 | */ |
|
1459 | autoFocus: boolean; | |
1460 | onClose(): boolean; |
|
1460 | ||
1461 |
|
1461 | /** | ||
1462 | /** |
|
1462 | * Selector (passed to on.selector()) used to identify MenuItem child widgets, but exclude inert children like MenuSeparator. If subclass overrides to a string (ex: "> *"), the subclass must require dojo/query. | |
1463 | * Called when submenu is clicked or focus is lost. Close hierarchy of menus. |
|
1463 | */ | |
1464 | */ |
|
1464 | childSelector(node: Element | Node): boolean | void | Function; | |
1465 | _closeChild(): void; |
|
1465 | ||
1466 | /** |
|
1466 | /** | |
1467 | * Called when child of this Menu gets focus from: |
|
1467 | * Attach point for notification about when a menu item has been executed. This is an internal mechanism used for Menus to signal to their parent to close them, because they are about to execute the onClick handler. In general developers should not attach to or override this method. | |
1468 | * |
|
1468 | */ | |
1469 | * 1. clicking it |
|
1469 | onExecute(): void; | |
1470 | * 2. tabbing into it |
|
1470 | ||
1471 | * 3. being opened by a parent menu. |
|
1471 | /** | |
1472 | * |
|
1472 | * Attach point for notification about when the user cancels the current menu | |
1473 | * This is not called just from mouse hover. |
|
1473 | * This is an internal mechanism used for Menus to signal to their parent to close them. In general developers should not attach to or override this method. | |
1474 | */ |
|
1474 | */ | |
1475 | _onItemFocus(item: MenuItem): void; |
|
1475 | onCancel(): void; | |
1476 |
|
1476 | |||
1477 | /** |
|
1477 | /** | |
1478 | * Called when focus is moved away from this Menu and it's submenus. |
|
1478 | * This handles the right arrow key (left arrow key on RTL systems), which will either open a submenu, or move to the next item in the ancestor MenuBar | |
1479 | */ |
|
1479 | */ | |
1480 | _onBlur(): void; |
|
1480 | _moveToPopup(evt: Event): void; | |
1481 |
|
1481 | |||
1482 | /** |
|
1482 | /** | |
1483 | * Called when the user is done with this menu. Closes hierarchy of menus. |
|
1483 | * This handler is called when the mouse moves over the popup. | |
1484 | */ |
|
1484 | */ | |
1485 | _cleanUp(clearSelectedItem?: boolean): void; |
|
1485 | _onPopupHover(evt?: MouseEvent): void; | |
1486 | } |
|
1486 | ||
1487 |
|
1487 | /** | ||
1488 | interface _MenuBaseConstructor extends _WidgetBaseConstructor<_MenuBase> { } |
|
1488 | * Called when cursor is over a MenuItem. | |
1489 |
|
1489 | */ | ||
1490 | /* dijit/Dialog */ |
|
1490 | onItemHover(item: MenuItem): void; | |
1491 |
|
1491 | |||
1492 | interface _DialogBase extends _TemplatedMixin, form._FormMixin, _DialogMixin, _CssStateMixin { |
|
1492 | /** | |
1493 | templateString: string; |
|
1493 | * Called when a child MenuItem becomes deselected. Setup timer to close its popup. | |
1494 | baseClass: string; |
|
1494 | */ | |
1495 | cssStateNodes: CSSStateNodes; |
|
1495 | _onChildDeselect(item: MenuItem): void; | |
1496 |
|
1496 | |||
1497 | /** |
|
1497 | /** | |
1498 | * True if Dialog is currently displayed on screen. |
|
1498 | * Callback fires when mouse exits a MenuItem | |
1499 | */ |
|
1499 | */ | |
1500 | open: boolean; |
|
1500 | onItemUnhover(item: MenuItem): void; | |
1501 |
|
1501 | |||
1502 | /** |
|
1502 | /** | |
1503 | * The time in milliseconds it takes the dialog to fade in and out |
|
1503 | * Cancels the popup timer because the user has stop hovering on the MenuItem, etc. | |
1504 | */ |
|
1504 | */ | |
1505 | duration: number; |
|
1505 | _stopPopupTimer(): void; | |
1506 |
|
1506 | |||
1507 | /** |
|
1507 | /** | |
1508 | * A Toggle to modify the default focus behavior of a Dialog, which |
|
1508 | * Cancels the pending-close timer because the close has been preempted | |
1509 | * is to re-focus the element which had focus before being opened. |
|
1509 | */ | |
1510 | * False will disable refocusing. Default: true |
|
1510 | _stopPendingCloseTimer(): void; | |
1511 | */ |
|
1511 | ||
1512 | refocus: boolean; |
|
1512 | /** | |
1513 |
|
1513 | * Returns the top menu in this chain of Menus | ||
1514 | /** |
|
1514 | */ | |
1515 | * A Toggle to modify the default focus behavior of a Dialog, which |
|
1515 | _getTopMenu(): void; | |
1516 | * is to focus on the first dialog element after opening the dialog. |
|
1516 | ||
1517 | * False will disable autofocusing. Default: true |
|
1517 | /** | |
1518 | */ |
|
1518 | * Handle clicks on an item. | |
1519 | autofocus: boolean; |
|
1519 | */ | |
1520 |
|
1520 | onItemClick(item: _WidgetBase, evt: Event): void; | ||
1521 | /** |
|
1521 | ||
1522 | * Toggles the movable aspect of the Dialog. If true, Dialog |
|
1522 | /** | |
1523 | * can be dragged by it's title. If false it will remain centered |
|
1523 | * Open the popup to the side of/underneath the current menu item, and optionally focus first item | |
1524 | * in the viewport. |
|
1524 | */ | |
1525 | */ |
|
1525 | _openItemPopup(fromItem: MenuItem, focus: boolean): void; | |
1526 | draggable: boolean; |
|
1526 | ||
1527 |
|
1527 | /** | ||
1528 | /** |
|
1528 | * Callback when this menu is opened. | |
1529 | * Maximum size to allow the dialog to expand to, relative to viewport size |
|
1529 | * This is called by the popup manager as notification that the menu was opened. | |
1530 | */ |
|
1530 | */ | |
1531 | maxRatio: number; |
|
1531 | onOpen(evt?: Event): void; | |
1532 |
|
1532 | |||
1533 | /** |
|
1533 | /** | |
1534 | * Dialog show [x] icon to close itself, and ESC key will close the dialog. |
|
1534 | * Callback when this menu is closed. | |
1535 | */ |
|
1535 | * This is called by the popup manager as notification that the menu was closed. | |
1536 | closable: boolean; |
|
1536 | */ | |
1537 | postMixInProperties(): void; |
|
1537 | onClose(): boolean; | |
1538 | postCreate(): void; |
|
1538 | ||
1539 |
|
1539 | /** | ||
1540 | /** |
|
1540 | * Called when submenu is clicked or focus is lost. Close hierarchy of menus. | |
1541 | * Called when data has been loaded from an href. |
|
1541 | */ | |
1542 | * Unlike most other callbacks, this function can be connected to (via `dojo.connect`) |
|
1542 | _closeChild(): void; | |
1543 | * but should *not* be overridden. |
|
1543 | /** | |
1544 | */ |
|
1544 | * Called when child of this Menu gets focus from: | |
1545 | onLoad(data?: any): void; |
|
1545 | * | |
1546 |
|
1546 | * 1. clicking it | ||
1547 | focus(): void; |
|
1547 | * 2. tabbing into it | |
1548 |
|
1548 | * 3. being opened by a parent menu. | ||
1549 | /* Not entirely sure of the resolution type of these promises */ |
|
1549 | * | |
1550 |
|
1550 | * This is not called just from mouse hover. | ||
1551 | /** |
|
1551 | */ | |
1552 | * Display the dialog |
|
1552 | _onItemFocus(item: MenuItem): void; | |
1553 | */ |
|
1553 | ||
1554 | show(): dojo.promise.Promise<any>; |
|
1554 | /** | |
1555 |
|
1555 | * Called when focus is moved away from this Menu and it's submenus. | ||
1556 | /** |
|
1556 | */ | |
1557 | * Hide the dialog |
|
1557 | _onBlur(): void; | |
1558 | */ |
|
1558 | ||
1559 | hide(): dojo.promise.Promise<any>; |
|
1559 | /** | |
1560 |
|
1560 | * Called when the user is done with this menu. Closes hierarchy of menus. | ||
1561 | /** |
|
1561 | */ | |
1562 | * Called with no argument when viewport scrolled or viewport size changed. Adjusts Dialog as |
|
1562 | _cleanUp(clearSelectedItem?: boolean): void; | |
1563 | * necessary to keep it visible. |
|
1563 | } | |
1564 | * |
|
1564 | ||
1565 | * Can also be called with an argument (by dojox/layout/ResizeHandle etc.) to explicitly set the |
|
1565 | interface _MenuBaseConstructor extends _WidgetBaseConstructor<_MenuBase> { } | |
1566 | * size of the dialog. |
|
1566 | ||
1567 | */ |
|
1567 | /* dijit/Dialog */ | |
1568 | resize(dim?: dojo.DomGeometryWidthHeight): void; |
|
1568 | ||
1569 |
|
1569 | interface _DialogBase extends _TemplatedMixin, form._FormMixin, _DialogMixin, _CssStateMixin { | ||
1570 | destroy(preserveDom?: boolean): void; |
|
1570 | templateString: string; | |
1571 | } |
|
1571 | baseClass: string; | |
1572 |
|
1572 | cssStateNodes: CSSStateNodes; | ||
1573 | interface _DialogBaseConstructor extends _WidgetBaseConstructor<_DialogBase> { } |
|
1573 | ||
1574 |
|
1574 | /** | ||
1575 | interface Dialog extends layout.ContentPane, _DialogBase { |
|
1575 | * True if Dialog is currently displayed on screen. | |
1576 | /* overrides conflicting methods */ |
|
1576 | */ | |
1577 | resize(dim?: dojo.DomGeometryWidthHeight): void; |
|
1577 | open: boolean; | |
1578 | } |
|
1578 | ||
1579 |
|
1579 | /** | ||
1580 | interface DialogLevelManager { |
|
1580 | * The time in milliseconds it takes the dialog to fade in and out | |
1581 | _beginZIndex: number; |
|
1581 | */ | |
1582 |
|
1582 | duration: number; | ||
1583 | /** |
|
1583 | ||
1584 | * Call right before fade-in animation for new dialog. |
|
1584 | /** | |
1585 | * |
|
1585 | * A Toggle to modify the default focus behavior of a Dialog, which | |
1586 | * Saves current focus, displays/adjusts underlay for new dialog, |
|
1586 | * is to re-focus the element which had focus before being opened. | |
1587 | * and sets the z-index of the dialog itself. |
|
1587 | * False will disable refocusing. Default: true | |
1588 | * |
|
1588 | */ | |
1589 | * New dialog will be displayed on top of all currently displayed dialogs. |
|
1589 | refocus: boolean; | |
1590 | * Caller is responsible for setting focus in new dialog after the fade-in |
|
1590 | ||
1591 | * animation completes. |
|
1591 | /** | |
1592 | */ |
|
1592 | * A Toggle to modify the default focus behavior of a Dialog, which | |
1593 | show(dialog: _WidgetBase, underlayAttrs: Object): void; |
|
1593 | * is to focus on the first dialog element after opening the dialog. | |
1594 |
|
1594 | * False will disable autofocusing. Default: true | ||
1595 | /** |
|
1595 | */ | |
1596 | * Called when the specified dialog is hidden/destroyed, after the fade-out |
|
1596 | autofocus: boolean; | |
1597 | * animation ends, in order to reset page focus, fix the underlay, etc. |
|
1597 | ||
1598 | * If the specified dialog isn't open then does nothing. |
|
1598 | /** | |
1599 | * |
|
1599 | * Toggles the movable aspect of the Dialog. If true, Dialog | |
1600 | * Caller is responsible for either setting display:none on the dialog domNode, |
|
1600 | * can be dragged by it's title. If false it will remain centered | |
1601 | * or calling dijit/popup.hide(), or removing it from the page DOM. |
|
1601 | * in the viewport. | |
1602 | */ |
|
1602 | */ | |
1603 | hide(dialog: _WidgetBase): void; |
|
1603 | draggable: boolean; | |
1604 |
|
1604 | |||
1605 | /** |
|
1605 | /** | |
1606 | * Returns true if specified Dialog is the top in the task |
|
1606 | * Maximum size to allow the dialog to expand to, relative to viewport size | |
1607 | */ |
|
1607 | */ | |
1608 | isTop(dialog: _WidgetBase): boolean; |
|
1608 | maxRatio: number; | |
1609 | } |
|
1609 | ||
1610 |
|
1610 | /** | ||
1611 | interface DialogConstructor extends _WidgetBaseConstructor<Dialog> { |
|
1611 | * Dialog show [x] icon to close itself, and ESC key will close the dialog. | |
1612 | /** |
|
1612 | */ | |
1613 | * for monkey patching and dojox/widget/DialogSimple |
|
1613 | closable: boolean; | |
1614 | */ |
|
1614 | postMixInProperties(): void; | |
1615 | _DialogBase: _DialogBaseConstructor; |
|
1615 | postCreate(): void; | |
1616 | _DialogLevelManager: DialogLevelManager; |
|
1616 | ||
1617 | _dialogStack: { |
|
1617 | /** | |
1618 | dialog: _WidgetBase, |
|
1618 | * Called when data has been loaded from an href. | |
1619 | focus: any, |
|
1619 | * Unlike most other callbacks, this function can be connected to (via `dojo.connect`) | |
1620 | underlayAttrs: any |
|
1620 | * but should *not* be overridden. | |
1621 | }[]; |
|
1621 | */ | |
1622 | } |
|
1622 | onLoad(data?: any): void; | |
1623 |
|
1623 | |||
1624 | /* dijit/ConfirmDialog */ |
|
1624 | focus(): void; | |
1625 |
|
1625 | |||
1626 | interface ConfirmDialog extends _ConfirmDialogMixin { } |
|
1626 | /* Not entirely sure of the resolution type of these promises */ | |
1627 |
|
1627 | |||
1628 | interface ConfirmDialogConstructor extends DialogConstructor { } |
|
1628 | /** | |
1629 |
|
1629 | * Display the dialog | ||
1630 | /* dijit/DropDownMenu */ |
|
1630 | */ | |
1631 |
|
1631 | show(): dojo.promise.Promise<any>; | ||
1632 | /** |
|
1632 | ||
1633 | * A menu, without features for context menu (Meaning, drop down menu) |
|
1633 | /** | |
1634 | */ |
|
1634 | * Hide the dialog | |
1635 | interface DropDownMenu extends _MenuBase { } |
|
1635 | */ | |
1636 |
|
1636 | hide(): dojo.promise.Promise<any>; | ||
1637 | interface DropDownMenuConstructor extends _WidgetBaseConstructor<DropDownMenu> { } |
|
1637 | ||
1638 |
|
1638 | /** | ||
1639 | /* dijit/Fieldset */ |
|
1639 | * Called with no argument when viewport scrolled or viewport size changed. Adjusts Dialog as | |
1640 |
|
1640 | * necessary to keep it visible. | ||
1641 | /** |
|
1641 | * | |
1642 | * An accessible fieldset that can be expanded or collapsed via |
|
1642 | * Can also be called with an argument (by dojox/layout/ResizeHandle etc.) to explicitly set the | |
1643 | * its legend. Fieldset extends `dijit.TitlePane`. |
|
1643 | * size of the dialog. | |
1644 | */ |
|
1644 | */ | |
1645 | interface Fieldset extends TitlePane { |
|
1645 | resize(dim?: dojo.DomGeometryWidthHeight): void; | |
1646 | open: boolean; |
|
1646 | ||
1647 | } |
|
1647 | destroy(preserveDom?: boolean): void; | |
1648 |
|
1648 | } | ||
1649 | interface FieldsetConstructor extends _WidgetBaseConstructor<Fieldset> { } |
|
1649 | ||
1650 |
|
1650 | interface _DialogBaseConstructor extends _WidgetBaseConstructor<_DialogBase> { } | ||
1651 | /* dijit/Menu */ |
|
1651 | ||
1652 |
|
1652 | interface Dialog extends layout.ContentPane, _DialogBase { | ||
1653 | /** |
|
1653 | /* overrides conflicting methods */ | |
1654 | * A context menu you can assign to multiple elements |
|
1654 | resize(dim?: dojo.DomGeometryWidthHeight): void; | |
1655 | */ |
|
1655 | } | |
1656 | interface Menu extends dijit.DropDownMenu { |
|
1656 | ||
1657 | /** |
|
1657 | interface DialogLevelManager { | |
1658 | * Array of dom node ids of nodes to attach to. |
|
1658 | _beginZIndex: number; | |
1659 | * Fill this with nodeIds upon widget creation and it becomes context menu for those nodes. |
|
1659 | ||
1660 | */ |
|
1660 | /** | |
1661 | targetNodeIds: string[]; |
|
1661 | * Call right before fade-in animation for new dialog. | |
1662 |
|
1662 | * | ||
1663 | /** |
|
1663 | * Saves current focus, displays/adjusts underlay for new dialog, | |
1664 | * CSS expression to apply this Menu to descendants of targetNodeIds, rather than to |
|
1664 | * and sets the z-index of the dialog itself. | |
1665 | * the nodes specified by targetNodeIds themselves. Useful for applying a Menu to |
|
1665 | * | |
1666 | * a range of rows in a table, tree, etc. |
|
1666 | * New dialog will be displayed on top of all currently displayed dialogs. | |
1667 | * |
|
1667 | * Caller is responsible for setting focus in new dialog after the fade-in | |
1668 | * The application must require() an appropriate level of dojo/query to handle the selector. |
|
1668 | * animation completes. | |
1669 | */ |
|
1669 | */ | |
1670 | selector: string; |
|
1670 | show(dialog: _WidgetBase, underlayAttrs: Object): void; | |
1671 |
|
1671 | |||
1672 | /** |
|
1672 | /** | |
1673 | * If true, right clicking anywhere on the window will cause this context menu to open. |
|
1673 | * Called when the specified dialog is hidden/destroyed, after the fade-out | |
1674 | * If false, must specify targetNodeIds. |
|
1674 | * animation ends, in order to reset page focus, fix the underlay, etc. | |
1675 | */ |
|
1675 | * If the specified dialog isn't open then does nothing. | |
1676 | contextMenuForWindow: boolean; |
|
1676 | * | |
1677 |
|
1677 | * Caller is responsible for either setting display:none on the dialog domNode, | ||
1678 | /** |
|
1678 | * or calling dijit/popup.hide(), or removing it from the page DOM. | |
1679 | * If true, menu will open on left click instead of right click, similar to a file menu. |
|
1679 | */ | |
1680 | */ |
|
1680 | hide(dialog: _WidgetBase): void; | |
1681 | leftClickToOpen: boolean; |
|
1681 | ||
1682 |
|
1682 | /** | ||
1683 | /** |
|
1683 | * Returns true if specified Dialog is the top in the task | |
1684 | * When this menu closes, re-focus the element which had focus before it was opened. |
|
1684 | */ | |
1685 | */ |
|
1685 | isTop(dialog: _WidgetBase): boolean; | |
1686 | refocus: boolean; |
|
1686 | } | |
1687 |
|
1687 | |||
1688 | /** |
|
1688 | interface DialogConstructor extends _WidgetBaseConstructor<Dialog> { | |
1689 | * Attach menu to given node |
|
1689 | /** | |
1690 | */ |
|
1690 | * for monkey patching and dojox/widget/DialogSimple | |
1691 | bindDomNode(node: string | Node): void; |
|
1691 | */ | |
1692 |
|
1692 | _DialogBase: _DialogBaseConstructor; | ||
1693 | /** |
|
1693 | _DialogLevelManager: DialogLevelManager; | |
1694 | * Detach menu from given node |
|
1694 | _dialogStack: { | |
1695 | */ |
|
1695 | dialog: _WidgetBase, | |
1696 | unBindDomNode(nodeName: string | Node): void; |
|
1696 | focus: any, | |
1697 | } |
|
1697 | underlayAttrs: any | |
1698 |
|
1698 | }[]; | ||
1699 | interface MenuConstructor extends _WidgetBaseConstructor<Menu> { } |
|
1699 | } | |
1700 |
|
1700 | |||
1701 | /* dijit/MenuBar */ |
|
1701 | /* dijit/ConfirmDialog */ | |
1702 | interface MenuBar extends _MenuBase { |
|
1702 | ||
1703 | baseClass: 'dijitMenuBar'; |
|
1703 | interface ConfirmDialog extends _ConfirmDialogMixin { } | |
1704 | popupDelay: number; |
|
1704 | ||
1705 | _isMenuBar: true; |
|
1705 | interface ConfirmDialogConstructor extends DialogConstructor { } | |
1706 | _orient: string[]; |
|
1706 | ||
1707 | _moveToPopup(evt: Event): void; |
|
1707 | /* dijit/DropDownMenu */ | |
1708 | focusChild(item: _WidgetBase): void; |
|
1708 | ||
1709 | _onChildDeselect(item: _WidgetBase): void; |
|
1709 | /** | |
1710 | _onLeftArrow(): void; |
|
1710 | * A menu, without features for context menu (Meaning, drop down menu) | |
1711 | _onRightArrow(): void; |
|
1711 | */ | |
1712 | _onDownArrow(): void; |
|
1712 | interface DropDownMenu extends _MenuBase { } | |
1713 | _onUpArrow(): void; |
|
1713 | ||
1714 | onItemClick(item: _WidgetBase, evt: Event): void; |
|
1714 | interface DropDownMenuConstructor extends _WidgetBaseConstructor<DropDownMenu> { } | |
1715 | } |
|
1715 | ||
1716 |
|
1716 | /* dijit/Fieldset */ | ||
1717 | interface MenuBarConstructor extends _WidgetBaseConstructor<MenuBar> { } |
|
1717 | ||
1718 |
|
1718 | /** | ||
1719 | /* dijit/MenuBarItem */ |
|
1719 | * An accessible fieldset that can be expanded or collapsed via | |
1720 | interface MenuBarItem extends MenuItem { } |
|
1720 | * its legend. Fieldset extends `dijit.TitlePane`. | |
1721 |
|
1721 | */ | ||
1722 | interface MenuBarItemConstructor extends _WidgetBaseConstructor<MenuBarItem> { } |
|
1722 | interface Fieldset extends TitlePane { | |
1723 |
|
1723 | open: boolean; | ||
1724 | /* dijit/MenuItem */ |
|
1724 | } | |
1725 | interface MenuItem extends _Widget, _TemplatedMixin, _Contained, _CssStateMixin { |
|
1725 | ||
1726 | /** |
|
1726 | interface FieldsetConstructor extends _WidgetBaseConstructor<Fieldset> { } | |
1727 | * Text for the accelerator (shortcut) key combination, a control, alt, etc. modified keystroke meant to execute the menu item regardless of where the focus is on the page. |
|
1727 | ||
1728 | * |
|
1728 | /* dijit/Menu */ | |
1729 | * Note that although Menu can display accelerator keys, there is no infrastructure to actually catch and execute those accelerators. |
|
1729 | ||
1730 | */ |
|
1730 | /** | |
1731 | accelKey: string; |
|
1731 | * A context menu you can assign to multiple elements | |
1732 |
|
1732 | */ | ||
1733 | /** |
|
1733 | interface Menu extends dijit.DropDownMenu { | |
1734 | * If true, the menu item is disabled. |
|
1734 | /** | |
1735 | * If false, the menu item is enabled. |
|
1735 | * Array of dom node ids of nodes to attach to. | |
1736 | */ |
|
1736 | * Fill this with nodeIds upon widget creation and it becomes context menu for those nodes. | |
1737 | disabled: boolean; |
|
1737 | */ | |
1738 |
|
1738 | targetNodeIds: string[]; | ||
1739 | /** Menu text as HTML */ |
|
1739 | ||
1740 | label: string; |
|
1740 | /** | |
1741 |
|
1741 | * CSS expression to apply this Menu to descendants of targetNodeIds, rather than to | ||
1742 | /** |
|
1742 | * the nodes specified by targetNodeIds themselves. Useful for applying a Menu to | |
1743 | * Class to apply to DOMNode to make it display an icon. |
|
1743 | * a range of rows in a table, tree, etc. | |
1744 | */ |
|
1744 | * | |
1745 | iconClass: string; |
|
1745 | * The application must require() an appropriate level of dojo/query to handle the selector. | |
1746 |
|
1746 | */ | ||
1747 | /** |
|
1747 | selector: string; | |
1748 | * Hook for attr('accelKey', ...) to work. |
|
1748 | ||
1749 | * Set accelKey on this menu item. |
|
1749 | /** | |
1750 | */ |
|
1750 | * If true, right clicking anywhere on the window will cause this context menu to open. | |
1751 | _setAccelKeyAttr(value: string): void; |
|
1751 | * If false, must specify targetNodeIds. | |
1752 |
|
1752 | */ | ||
1753 | /** |
|
1753 | contextMenuForWindow: boolean; | |
1754 | * Hook for attr('disabled', ...) to work. |
|
1754 | ||
1755 | * Enable or disable this menu item. |
|
1755 | /** | |
1756 | */ |
|
1756 | * If true, menu will open on left click instead of right click, similar to a file menu. | |
1757 | _setDisabledAttr(value: boolean): void; |
|
1757 | */ | |
1758 |
|
1758 | leftClickToOpen: boolean; | ||
1759 | _setLabelAttr(val: string): void; |
|
1759 | ||
1760 | _setIconClassAttr(val: string): void; |
|
1760 | /** | |
1761 |
|
1761 | * When this menu closes, re-focus the element which had focus before it was opened. | ||
1762 | _fillContent(source: Element): void; |
|
1762 | */ | |
1763 |
|
1763 | refocus: boolean; | ||
1764 | /** |
|
1764 | ||
1765 | * Indicate that this node is the currently selected one |
|
1765 | /** | |
1766 | */ |
|
1766 | * Attach menu to given node | |
1767 | _setSelected(selected: boolean): void; |
|
1767 | */ | |
1768 |
|
1768 | bindDomNode(node: string | Node): void; | ||
1769 | focus(): void; |
|
1769 | ||
1770 |
|
1770 | /** | ||
1771 | /** |
|
1771 | * Detach menu from given node | |
1772 | * Deprecated. |
|
1772 | */ | |
1773 | * Use set('disabled', bool) instead. |
|
1773 | unBindDomNode(nodeName: string | Node): void; | |
1774 | */ |
|
1774 | } | |
1775 | setDisabled(disabled: boolean): void; |
|
1775 | ||
1776 |
|
1776 | interface MenuConstructor extends _WidgetBaseConstructor<Menu> { } | ||
1777 | /** |
|
1777 | ||
1778 | * Deprecated. |
|
1778 | /* dijit/MenuBar */ | |
1779 | * Use set('label', ...) instead. |
|
1779 | interface MenuBar extends _MenuBase { | |
1780 | */ |
|
1780 | baseClass: 'dijitMenuBar'; | |
1781 | setLabel(content: string): void; |
|
1781 | popupDelay: number; | |
1782 | } |
|
1782 | _isMenuBar: true; | |
1783 |
|
1783 | _orient: string[]; | ||
1784 | interface MenuItemConstructor extends _WidgetBaseConstructor<MenuItem> { } |
|
1784 | _moveToPopup(evt: Event): void; | |
1785 |
|
1785 | focusChild(item: _WidgetBase): void; | ||
1786 | /* dijit/MenuSeparator */ |
|
1786 | _onChildDeselect(item: _WidgetBase): void; | |
1787 | interface MenuSeparator extends _WidgetBase, _TemplatedMixin, _Contained { } |
|
1787 | _onLeftArrow(): void; | |
1788 |
|
1788 | _onRightArrow(): void; | ||
1789 | interface MenuSeparatorConstructor extends _WidgetBaseConstructor<MenuSeparator> { } |
|
1789 | _onDownArrow(): void; | |
1790 |
|
1790 | _onUpArrow(): void; | ||
1791 | /* dijit/place */ |
|
1791 | onItemClick(item: _WidgetBase, evt: Event): void; | |
1792 |
|
1792 | } | ||
1793 | interface PlacePosition { |
|
1793 | ||
1794 | x: number; |
|
1794 | interface MenuBarConstructor extends _WidgetBaseConstructor<MenuBar> { } | |
1795 | y: number; |
|
1795 | ||
1796 | } |
|
1796 | /* dijit/MenuBarItem */ | |
1797 |
|
1797 | interface MenuBarItem extends MenuItem { } | ||
1798 | interface PlaceWidthHeight { |
|
1798 | ||
1799 | w: number; |
|
1799 | interface MenuBarItemConstructor extends _WidgetBaseConstructor<MenuBarItem> { } | |
1800 | h: number; |
|
1800 | ||
1801 | } |
|
1801 | /* dijit/MenuItem */ | |
1802 |
|
1802 | interface MenuItem extends _Widget, _TemplatedMixin, _Contained, _CssStateMixin { | ||
1803 | interface PlaceRectangle extends PlacePosition, PlaceWidthHeight { } |
|
1803 | /** | |
1804 |
|
1804 | * Text for the accelerator (shortcut) key combination, a control, alt, etc. modified keystroke meant to execute the menu item regardless of where the focus is on the page. | ||
1805 | type PlaceCorner = 'BL' | 'TR' | 'BR' | 'TL'; |
|
1805 | * | |
1806 |
|
1806 | * Note that although Menu can display accelerator keys, there is no infrastructure to actually catch and execute those accelerators. | ||
1807 | type PlacePositions = 'before' | 'after' | 'before-centered' | 'after-centered' | 'above-centered' | 'above' | 'above-alt' | 'below-centered' | 'below' | 'below-alt'; |
|
1807 | */ | |
1808 |
|
1808 | accelKey: string; | ||
1809 | interface PlaceChoice { |
|
1809 | ||
1810 | corner: PlaceCorner; |
|
1810 | /** | |
1811 | pos: PlacePosition; |
|
1811 | * If true, the menu item is disabled. | |
1812 | aroundCorner?: PlaceCorner; |
|
1812 | * If false, the menu item is enabled. | |
1813 | } |
|
1813 | */ | |
1814 |
|
1814 | disabled: boolean; | ||
1815 | interface PlaceLocation extends PlaceRectangle { |
|
1815 | ||
1816 | corner: PlaceCorner; |
|
1816 | /** Menu text as HTML */ | |
1817 | aroundCorner: PlaceCorner; |
|
1817 | label: string; | |
1818 | overflow: number; |
|
1818 | ||
1819 | spaceAvailable: PlaceWidthHeight; |
|
1819 | /** | |
1820 | } |
|
1820 | * Class to apply to DOMNode to make it display an icon. | |
1821 |
|
1821 | */ | ||
1822 | interface LayoutNodeFunction { |
|
1822 | iconClass: string; | |
1823 | (node: HTMLElement, aroundCorner: string, corner: string, spaceAvailable: PlaceWidthHeight, aroundNodeCoords: PlaceWidthHeight): number; |
|
1823 | ||
1824 | } |
|
1824 | /** | |
1825 |
|
1825 | * Hook for attr('accelKey', ...) to work. | ||
1826 | interface Place { |
|
1826 | * Set accelKey on this menu item. | |
1827 | /** |
|
1827 | */ | |
1828 | * Positions node kitty-corner to the rectangle centered at (pos.x, pos.y) with width and height of |
|
1828 | _setAccelKeyAttr(value: string): void; | |
1829 | * padding.x * 2 and padding.y * 2, or zero if padding not specified. Picks first corner in corners[] |
|
1829 | ||
1830 | * where node is fully visible, or the corner where it's most visible. |
|
1830 | /** | |
1831 | * |
|
1831 | * Hook for attr('disabled', ...) to work. | |
1832 | * Node is assumed to be absolutely or relatively positioned. |
|
1832 | * Enable or disable this menu item. | |
1833 | */ |
|
1833 | */ | |
1834 | at(node: Element, pos?: PlacePosition, corners?: PlaceCorner[], padding?: PlacePosition, layoutNode?: LayoutNodeFunction): PlaceLocation; |
|
1834 | _setDisabledAttr(value: boolean): void; | |
1835 |
|
1835 | |||
1836 | /** |
|
1836 | _setLabelAttr(val: string): void; | |
1837 | * Position node adjacent or kitty-corner to anchor |
|
1837 | _setIconClassAttr(val: string): void; | |
1838 | * such that it's fully visible in viewport. |
|
1838 | ||
1839 | */ |
|
1839 | _fillContent(source: Element): void; | |
1840 | around(node: Element, anchor: Element | PlaceRectangle, positions: PlacePositions[], leftToRight?: boolean, layoutNode?: LayoutNodeFunction): PlaceLocation; |
|
1840 | ||
1841 | } |
|
1841 | /** | |
1842 |
|
1842 | * Indicate that this node is the currently selected one | ||
1843 | /* dijit/popup */ |
|
1843 | */ | |
1844 |
|
1844 | _setSelected(selected: boolean): void; | ||
1845 | interface PopupOpenArgs { |
|
1845 | ||
1846 | /** |
|
1846 | focus(): void; | |
1847 | * widget to display |
|
1847 | ||
1848 | */ |
|
1848 | /** | |
1849 | popup?: _WidgetBase; |
|
1849 | * Deprecated. | |
1850 |
|
1850 | * Use set('disabled', bool) instead. | ||
1851 | /** |
|
1851 | */ | |
1852 | * the button etc. that is displaying this popup |
|
1852 | setDisabled(disabled: boolean): void; | |
1853 | */ |
|
1853 | ||
1854 | parent?: _WidgetBase; |
|
1854 | /** | |
1855 |
|
1855 | * Deprecated. | ||
1856 | /** |
|
1856 | * Use set('label', ...) instead. | |
1857 | * DOM node (typically a button); place popup relative to this node. (Specify this *or* "x" and "y" parameters.) |
|
1857 | */ | |
1858 | */ |
|
1858 | setLabel(content: string): void; | |
1859 | around?: HTMLElement; |
|
1859 | } | |
1860 |
|
1860 | |||
1861 | /** |
|
1861 | interface MenuItemConstructor extends _WidgetBaseConstructor<MenuItem> { } | |
1862 | * Absolute horizontal position (in pixels) to place node at. (Specify this *or* "around" parameter.) |
|
1862 | ||
1863 | */ |
|
1863 | /* dijit/MenuSeparator */ | |
1864 | x?: number; |
|
1864 | interface MenuSeparator extends _WidgetBase, _TemplatedMixin, _Contained { } | |
1865 |
|
1865 | |||
1866 | /** |
|
1866 | interface MenuSeparatorConstructor extends _WidgetBaseConstructor<MenuSeparator> { } | |
1867 | * Absolute vertical position (in pixels) to place node at. (Specify this *or* "around" parameter.) |
|
1867 | ||
1868 | */ |
|
1868 | /* dijit/place */ | |
1869 | y?: number; |
|
1869 | ||
1870 |
|
1870 | interface PlacePosition { | ||
1871 | /** |
|
1871 | x: number; | |
1872 | * When the around parameter is specified, orient should be a list of positions to try |
|
1872 | y: number; | |
1873 | */ |
|
1873 | } | |
1874 | orient?: string | string[] | { BL?: string; TR?: string; TL?: string; BR?: string; }; |
|
1874 | ||
1875 |
|
1875 | interface PlaceWidthHeight { | ||
1876 | /** |
|
1876 | w: number; | |
1877 | * callback when user has canceled the popup by: |
|
1877 | h: number; | |
1878 | * |
|
1878 | } | |
1879 | * 1. hitting ESC or |
|
1879 | ||
1880 | * 2. by using the popup widget's proprietary cancel mechanism (like a cancel button in a dialog); |
|
1880 | interface PlaceRectangle extends PlacePosition, PlaceWidthHeight { } | |
1881 | * i.e. whenever popupWidget.onCancel() is called, args.onCancel is called |
|
1881 | ||
1882 | */ |
|
1882 | type PlaceCorner = 'BL' | 'TR' | 'BR' | 'TL'; | |
1883 | onCancel?: () => void; |
|
1883 | ||
1884 |
|
1884 | type PlacePositions = 'before' | 'after' | 'before-centered' | 'after-centered' | 'above-centered' | 'above' | 'above-alt' | 'below-centered' | 'below' | 'below-alt'; | ||
1885 | /** |
|
1885 | ||
1886 | * callback whenever this popup is closed |
|
1886 | interface PlaceChoice { | |
1887 | */ |
|
1887 | corner: PlaceCorner; | |
1888 | onClose?: () => void; |
|
1888 | pos: PlacePosition; | |
1889 |
|
1889 | aroundCorner?: PlaceCorner; | ||
1890 | /** |
|
1890 | } | |
1891 | * callback when user "executed" on the popup/sub-popup by selecting a menu choice, etc. (top menu only) |
|
1891 | ||
1892 | */ |
|
1892 | interface PlaceLocation extends PlaceRectangle { | |
1893 | onExecute?: () => void; |
|
1893 | corner: PlaceCorner; | |
1894 |
|
1894 | aroundCorner: PlaceCorner; | ||
1895 | /** |
|
1895 | overflow: number; | |
1896 | * adding a buffer around the opening position. This is only useful when around is not set. |
|
1896 | spaceAvailable: PlaceWidthHeight; | |
1897 | */ |
|
1897 | } | |
1898 | padding?: PlacePosition; |
|
1898 | ||
1899 |
|
1899 | interface LayoutNodeFunction { | ||
1900 | /** |
|
1900 | (node: HTMLElement, aroundCorner: string, corner: string, spaceAvailable: PlaceWidthHeight, aroundNodeCoords: PlaceWidthHeight): number; | |
1901 | * The max height for the popup. Any popup taller than this will have scrollbars. |
|
1901 | } | |
1902 | * Set to Infinity for no max height. Default is to limit height to available space in viewport, |
|
1902 | ||
1903 | * above or below the aroundNode or specified x/y position. |
|
1903 | interface Place { | |
1904 | */ |
|
1904 | /** | |
1905 | maxHeight?: number; |
|
1905 | * Positions node kitty-corner to the rectangle centered at (pos.x, pos.y) with width and height of | |
1906 | } |
|
1906 | * padding.x * 2 and padding.y * 2, or zero if padding not specified. Picks first corner in corners[] | |
1907 |
|
1907 | * where node is fully visible, or the corner where it's most visible. | ||
1908 | interface PopupManager { |
|
1908 | * | |
1909 | /** |
|
1909 | * Node is assumed to be absolutely or relatively positioned. | |
1910 | * Stack of currently popped up widgets. |
|
1910 | */ | |
1911 | * (someone opened _stack[0], and then it opened _stack[1], etc.) |
|
1911 | at(node: Element, pos?: PlacePosition, corners?: PlaceCorner[], padding?: PlacePosition, layoutNode?: LayoutNodeFunction): PlaceLocation; | |
1912 | */ |
|
1912 | ||
1913 | _stack: _WidgetBase[]; |
|
1913 | /** | |
1914 |
|
1914 | * Position node adjacent or kitty-corner to anchor | ||
1915 | /** |
|
1915 | * such that it's fully visible in viewport. | |
1916 | * Z-index of the first popup. (If first popup opens other |
|
1916 | */ | |
1917 | * popups they get a higher z-index.) |
|
1917 | around(node: Element, anchor: Element | PlaceRectangle, positions: PlacePositions[], leftToRight?: boolean, layoutNode?: LayoutNodeFunction): PlaceLocation; | |
1918 | */ |
|
1918 | } | |
1919 | _beginZIndex: number; |
|
1919 | ||
1920 |
|
1920 | /* dijit/popup */ | ||
1921 | _idGen: number; |
|
1921 | ||
1922 |
|
1922 | interface PopupOpenArgs { | ||
1923 | /** |
|
1923 | /** | |
1924 | * If screen has been scrolled, reposition all the popups in the stack. |
|
1924 | * widget to display | |
1925 | * Then set timer to check again later. |
|
1925 | */ | |
1926 | */ |
|
1926 | popup?: _WidgetBase; | |
1927 | _repositionAll(): void; |
|
1927 | ||
1928 |
|
1928 | /** | ||
1929 | /** |
|
1929 | * the button etc. that is displaying this popup | |
1930 | * Initialization for widgets that will be used as popups. |
|
1930 | */ | |
1931 | * Puts widget inside a wrapper DIV (if not already in one), |
|
1931 | parent?: _WidgetBase; | |
1932 | * and returns pointer to that wrapper DIV. |
|
1932 | ||
1933 | */ |
|
1933 | /** | |
1934 | _createWrapper(widget: _WidgetBase): HTMLDivElement; |
|
1934 | * DOM node (typically a button); place popup relative to this node. (Specify this *or* "x" and "y" parameters.) | |
1935 |
|
1935 | */ | ||
1936 | /** |
|
1936 | around?: HTMLElement; | |
1937 | * Moves the popup widget off-screen. |
|
1937 | ||
1938 | * Do not use this method to hide popups when not in use, because |
|
1938 | /** | |
1939 | * that will create an accessibility issue: the offscreen popup is |
|
1939 | * Absolute horizontal position (in pixels) to place node at. (Specify this *or* "around" parameter.) | |
1940 | * still in the tabbing order. |
|
1940 | */ | |
1941 | */ |
|
1941 | x?: number; | |
1942 | moveOffScreen(widget: _WidgetBase): HTMLDivElement; |
|
1942 | ||
1943 |
|
1943 | /** | ||
1944 | /** |
|
1944 | * Absolute vertical position (in pixels) to place node at. (Specify this *or* "around" parameter.) | |
1945 | * Hide this popup widget (until it is ready to be shown). |
|
1945 | */ | |
1946 | * Initialization for widgets that will be used as popups |
|
1946 | y?: number; | |
1947 | * |
|
1947 | ||
1948 | * Also puts widget inside a wrapper DIV (if not already in one) |
|
1948 | /** | |
1949 | * |
|
1949 | * When the around parameter is specified, orient should be a list of positions to try | |
1950 | * If popup widget needs to layout it should |
|
1950 | */ | |
1951 | * do so when it is made visible, and popup._onShow() is called. |
|
1951 | orient?: string | string[] | { BL?: string; TR?: string; TL?: string; BR?: string; }; | |
1952 | */ |
|
1952 | ||
1953 | hide(widget: _WidgetBase): void; |
|
1953 | /** | |
1954 |
|
1954 | * callback when user has canceled the popup by: | ||
1955 | /** |
|
1955 | * | |
1956 | * Compute the closest ancestor popup that's *not* a child of another popup. |
|
1956 | * 1. hitting ESC or | |
1957 | * Ex: For a TooltipDialog with a button that spawns a tree of menus, find the popup of the button. |
|
1957 | * 2. by using the popup widget's proprietary cancel mechanism (like a cancel button in a dialog); | |
1958 | */ |
|
1958 | * i.e. whenever popupWidget.onCancel() is called, args.onCancel is called | |
1959 | getTopPopup(): _WidgetBase; |
|
1959 | */ | |
1960 |
|
1960 | onCancel?: () => void; | ||
1961 | /** |
|
1961 | ||
1962 | * Popup the widget at the specified position |
|
1962 | /** | |
1963 | */ |
|
1963 | * callback whenever this popup is closed | |
1964 | open(args: PopupOpenArgs): PlaceLocation; |
|
1964 | */ | |
1965 |
|
1965 | onClose?: () => void; | ||
1966 | /** |
|
1966 | ||
1967 | * Close specified popup and any popups that it parented. |
|
1967 | /** | |
1968 | * If no popup is specified, closes all popups. |
|
1968 | * callback when user "executed" on the popup/sub-popup by selecting a menu choice, etc. (top menu only) | |
1969 | */ |
|
1969 | */ | |
1970 | close(popup?: _WidgetBase): void; |
|
1970 | onExecute?: () => void; | |
1971 | } |
|
1971 | ||
1972 |
|
1972 | /** | ||
1973 | /* dijit/PopupMenuBarItem */ |
|
1973 | * adding a buffer around the opening position. This is only useful when around is not set. | |
1974 |
|
1974 | */ | ||
1975 | interface PopupMenuBarItem extends PopupMenuItem { } |
|
1975 | padding?: PlacePosition; | |
1976 |
|
1976 | |||
1977 | interface PopupMenuBarItemConstructor extends _WidgetBaseConstructor<PopupMenuBarItem> { } |
|
1977 | /** | |
1978 |
|
1978 | * The max height for the popup. Any popup taller than this will have scrollbars. | ||
1979 | /** dijit/PopupMenuItem */ |
|
1979 | * Set to Infinity for no max height. Default is to limit height to available space in viewport, | |
1980 |
|
1980 | * above or below the aroundNode or specified x/y position. | ||
1981 | /** |
|
1981 | */ | |
1982 | * An item in a Menu that spawn a drop down (usually a drop down menu) |
|
1982 | maxHeight?: number; | |
1983 | */ |
|
1983 | } | |
1984 | interface PopupMenuItem extends MenuItem { |
|
1984 | ||
1985 | /** |
|
1985 | interface PopupManager { | |
1986 | * When Menu is declared in markup, this code gets the menu label and the popup widget from the srcNodeRef. |
|
1986 | /** | |
1987 | * |
|
1987 | * Stack of currently popped up widgets. | |
1988 | * srcNodeRef.innerHTML contains both the menu item text and a popup widget |
|
1988 | * (someone opened _stack[0], and then it opened _stack[1], etc.) | |
1989 | * The first part holds the menu item text and the second part is the popup |
|
1989 | */ | |
1990 | */ |
|
1990 | _stack: _WidgetBase[]; | |
1991 | _fillContent(source: Element): void; |
|
1991 | ||
1992 |
|
1992 | /** | ||
1993 | /** |
|
1993 | * Z-index of the first popup. (If first popup opens other | |
1994 | * Open the popup to the side of/underneath this MenuItem, and optionally focus first item |
|
1994 | * popups they get a higher z-index.) | |
1995 | */ |
|
1995 | */ | |
1996 | _openPopup(params: { around?: Element; popup?: Function }, focus?: boolean): void; |
|
1996 | _beginZIndex: number; | |
1997 |
|
1997 | |||
1998 | _closePopup(): void; |
|
1998 | _idGen: number; | |
1999 | } |
|
1999 | ||
2000 |
|
2000 | /** | ||
2001 | interface PopupMenuItemConstructor extends _WidgetBaseConstructor<PopupMenuItem> { } |
|
2001 | * If screen has been scrolled, reposition all the popups in the stack. | |
2002 |
|
2002 | * Then set timer to check again later. | ||
2003 | /* dijit/registry */ |
|
2003 | */ | |
2004 |
|
2004 | _repositionAll(): void; | ||
2005 | interface Registry { |
|
2005 | ||
2006 | /** |
|
2006 | /** | |
2007 | * Number of registered widgets |
|
2007 | * Initialization for widgets that will be used as popups. | |
2008 | */ |
|
2008 | * Puts widget inside a wrapper DIV (if not already in one), | |
2009 | length: number; |
|
2009 | * and returns pointer to that wrapper DIV. | |
2010 |
|
2010 | */ | ||
2011 | /** |
|
2011 | _createWrapper(widget: _WidgetBase): HTMLDivElement; | |
2012 | * Add a widget to the registry. If a duplicate ID is detected, a error is thrown. |
|
2012 | ||
2013 | */ |
|
2013 | /** | |
2014 | add(widget: _WidgetBase): void; |
|
2014 | * Moves the popup widget off-screen. | |
2015 |
|
2015 | * Do not use this method to hide popups when not in use, because | ||
2016 | /** |
|
2016 | * that will create an accessibility issue: the offscreen popup is | |
2017 | * Remove a widget from the registry. Does not destroy the widget; simply |
|
2017 | * still in the tabbing order. | |
2018 | * removes the reference. |
|
2018 | */ | |
2019 | */ |
|
2019 | moveOffScreen(widget: _WidgetBase): HTMLDivElement; | |
2020 | remove(id: string): void; |
|
2020 | ||
2021 |
|
2021 | /** | ||
2022 | /** |
|
2022 | * Hide this popup widget (until it is ready to be shown). | |
2023 | * Find a widget by it's id. |
|
2023 | * Initialization for widgets that will be used as popups | |
2024 | * If passed a widget then just returns the widget. |
|
2024 | * | |
2025 | */ |
|
2025 | * Also puts widget inside a wrapper DIV (if not already in one) | |
2026 | byId(id: string | _WidgetBase): _WidgetBase; |
|
2026 | * | |
2027 |
|
2027 | * If popup widget needs to layout it should | ||
2028 | /** |
|
2028 | * do so when it is made visible, and popup._onShow() is called. | |
2029 | * Returns the widget corresponding to the given DOMNode |
|
2029 | */ | |
2030 | */ |
|
2030 | hide(widget: _WidgetBase): void; | |
2031 | byNode(node: Element | Node): _WidgetBase; |
|
2031 | ||
2032 |
|
2032 | /** | ||
2033 | /** |
|
2033 | * Compute the closest ancestor popup that's *not* a child of another popup. | |
2034 | * Convert registry into a true Array |
|
2034 | * Ex: For a TooltipDialog with a button that spawns a tree of menus, find the popup of the button. | |
2035 | */ |
|
2035 | */ | |
2036 | toArray(): _WidgetBase[]; |
|
2036 | getTopPopup(): _WidgetBase; | |
2037 |
|
2037 | |||
2038 | /** |
|
2038 | /** | |
2039 | * Generates a unique id for a given widgetType |
|
2039 | * Popup the widget at the specified position | |
2040 | */ |
|
2040 | */ | |
2041 | getUniqueId(widgetType: string): string; |
|
2041 | open(args: PopupOpenArgs): PlaceLocation; | |
2042 |
|
2042 | |||
2043 | /** |
|
2043 | /** | |
2044 | * Search subtree under root returning widgets found. |
|
2044 | * Close specified popup and any popups that it parented. | |
2045 | * Doesn't search for nested widgets (ie, widgets inside other widgets). |
|
2045 | * If no popup is specified, closes all popups. | |
2046 | */ |
|
2046 | */ | |
2047 | findWidgets(root: Node, skipNode?: Node): _WidgetBase[]; |
|
2047 | close(popup?: _WidgetBase): void; | |
2048 |
|
2048 | } | ||
2049 | /** |
|
2049 | ||
2050 | * Returns the widget whose DOM tree contains the specified DOMNode, or null if |
|
2050 | /* dijit/PopupMenuBarItem */ | |
2051 | * the node is not contained within the DOM tree of any widget |
|
2051 | ||
2052 | */ |
|
2052 | interface PopupMenuBarItem extends PopupMenuItem { } | |
2053 | getEnclosingWidget(node: Element | Node): _WidgetBase; |
|
2053 | ||
2054 | } |
|
2054 | interface PopupMenuBarItemConstructor extends _WidgetBaseConstructor<PopupMenuBarItem> { } | |
2055 |
|
2055 | |||
2056 | /* dijit/TitlePane */ |
|
2056 | /** dijit/PopupMenuItem */ | |
2057 |
|
2057 | |||
2058 | interface TitlePane extends dijit.layout.ContentPane, _TemplatedMixin, _CssStateMixin { |
|
2058 | /** | |
2059 | /** |
|
2059 | * An item in a Menu that spawn a drop down (usually a drop down menu) | |
2060 | * Whether pane can be opened or closed by clicking the title bar. |
|
2060 | */ | |
2061 | */ |
|
2061 | interface PopupMenuItem extends MenuItem { | |
2062 | toggleable: boolean; |
|
2062 | /** | |
2063 |
|
2063 | * When Menu is declared in markup, this code gets the menu label and the popup widget from the srcNodeRef. | ||
2064 | /** |
|
2064 | * | |
2065 | * Tabindex setting for the title (so users can tab to the title then use space/enter to open/close the title pane) |
|
2065 | * srcNodeRef.innerHTML contains both the menu item text and a popup widget | |
2066 | */ |
|
2066 | * The first part holds the menu item text and the second part is the popup | |
2067 | tabIndex: string; |
|
2067 | */ | |
2068 |
|
2068 | _fillContent(source: Element): void; | ||
2069 | /** |
|
2069 | ||
2070 | * Time in milliseconds to fade in/fade out |
|
2070 | /** | |
2071 | */ |
|
2071 | * Open the popup to the side of/underneath this MenuItem, and optionally focus first item | |
2072 | duration: number; |
|
2072 | */ | |
2073 |
|
2073 | _openPopup(params: { around?: Element; popup?: Function }, focus?: boolean): void; | ||
2074 | /** |
|
2074 | ||
2075 | * Don't change this parameter from the default value. |
|
2075 | _closePopup(): void; | |
2076 | * |
|
2076 | } | |
2077 | * This ContentPane parameter doesn't make sense for TitlePane, since TitlePane is never a child of a layout container, nor should TitlePane try to control the size of an inner widget. |
|
2077 | ||
2078 | */ |
|
2078 | interface PopupMenuItemConstructor extends _WidgetBaseConstructor<PopupMenuItem> { } | |
2079 | doLayout: boolean; |
|
2079 | ||
2080 |
|
2080 | /* dijit/registry */ | ||
2081 | /** |
|
2081 | ||
2082 | * Switches between opened and closed state |
|
2082 | interface Registry { | |
2083 | */ |
|
2083 | /** | |
2084 | toggle(): void; |
|
2084 | * Number of registered widgets | |
2085 |
|
2085 | */ | ||
2086 | /** |
|
2086 | length: number; | |
2087 | * Set the open/close css state for the TitlePane |
|
2087 | ||
2088 | */ |
|
2088 | /** | |
2089 | _setCss(): void; |
|
2089 | * Add a widget to the registry. If a duplicate ID is detected, a error is thrown. | |
2090 |
|
2090 | */ | ||
2091 | /** |
|
2091 | add(widget: _WidgetBase): void; | |
2092 | * Handler for when user hits a key |
|
2092 | ||
2093 | */ |
|
2093 | /** | |
2094 | _onTitleKey(e: Event): void; |
|
2094 | * Remove a widget from the registry. Does not destroy the widget; simply | |
2095 |
|
2095 | * removes the reference. | ||
2096 | /** |
|
2096 | */ | |
2097 | * Handler when user clicks the title bar |
|
2097 | remove(id: string): void; | |
2098 | */ |
|
2098 | ||
2099 | _onTitleClick(): void; |
|
2099 | /** | |
2100 |
|
2100 | * Find a widget by it's id. | ||
2101 | /** |
|
2101 | * If passed a widget then just returns the widget. | |
2102 | * Deprecated. Use set('title', ...) instead. |
|
2102 | */ | |
2103 | */ |
|
2103 | byId(id: string | _WidgetBase): _WidgetBase; | |
2104 | setTitle(): void; |
|
2104 | ||
2105 | } |
|
2105 | /** | |
2106 |
|
2106 | * Returns the widget corresponding to the given DOMNode | ||
2107 | interface TitlePaneConstructor extends _WidgetBaseConstructor<TitlePane> { } |
|
2107 | */ | |
2108 |
|
2108 | byNode(node: Element | Node): _WidgetBase; | ||
2109 | /* dijit/Toolbar */ |
|
2109 | ||
2110 |
|
2110 | /** | ||
2111 | interface Toolbar extends dijit._Widget, dijit._TemplatedMixin, dijit._KeyNavContainer { } |
|
2111 | * Convert registry into a true Array | |
2112 |
|
2112 | */ | ||
2113 | interface ToolbarConstructor extends _WidgetBaseConstructor<Toolbar> { } |
|
2113 | toArray(): _WidgetBase[]; | |
2114 |
|
2114 | |||
2115 | /* dijit/ToolbarSeparator */ |
|
2115 | /** | |
2116 |
|
2116 | * Generates a unique id for a given widgetType | ||
2117 | interface ToolbarSeparator extends dijit._Widget, dijit._TemplatedMixin { } |
|
2117 | */ | |
2118 |
|
2118 | getUniqueId(widgetType: string): string; | ||
2119 | interface ToolbarSeparatorConstructor extends _WidgetBaseConstructor<ToolbarSeparator> { } |
|
2119 | ||
2120 |
|
2120 | /** | ||
2121 | /* dijit/Tooltip */ |
|
2121 | * Search subtree under root returning widgets found. | |
2122 |
|
2122 | * Doesn't search for nested widgets (ie, widgets inside other widgets). | ||
2123 | interface Tooltip extends _Widget { |
|
2123 | */ | |
2124 | /** |
|
2124 | findWidgets(root: Node, skipNode?: Node): _WidgetBase[]; | |
2125 | * HTML to display in the tooltip. |
|
2125 | ||
2126 | * Specified as innerHTML when creating the widget from markup. |
|
2126 | /** | |
2127 | */ |
|
2127 | * Returns the widget whose DOM tree contains the specified DOMNode, or null if | |
2128 | label: string; |
|
2128 | * the node is not contained within the DOM tree of any widget | |
2129 |
|
2129 | */ | ||
2130 | /** |
|
2130 | getEnclosingWidget(node: Element | Node): _WidgetBase; | |
2131 | * Number of milliseconds to wait after hovering over/focusing on the object, before |
|
2131 | } | |
2132 | * the tooltip is displayed. |
|
2132 | ||
2133 | */ |
|
2133 | /* dijit/TitlePane */ | |
2134 | showDelay: number; |
|
2134 | ||
2135 |
|
2135 | interface TitlePane extends dijit.layout.ContentPane, _TemplatedMixin, _CssStateMixin { | ||
2136 | /** |
|
2136 | /** | |
2137 | * Number of milliseconds to wait after unhovering the object, before |
|
2137 | * Whether pane can be opened or closed by clicking the title bar. | |
2138 | * the tooltip is hidden. Note that blurring an object hides the tooltip immediately. |
|
2138 | */ | |
2139 | */ |
|
2139 | toggleable: boolean; | |
2140 | hideDelay: number; |
|
2140 | ||
2141 |
|
2141 | /** | ||
2142 | /** |
|
2142 | * Tabindex setting for the title (so users can tab to the title then use space/enter to open/close the title pane) | |
2143 | * Id of domNode(s) to attach the tooltip to. |
|
2143 | */ | |
2144 | * When user hovers over specified dom node(s), the tooltip will appear. |
|
2144 | tabIndex: string; | |
2145 | */ |
|
2145 | ||
2146 | connectId: dojo.NodeOrString | dojo.NodeOrString[]; |
|
2146 | /** | |
2147 |
|
2147 | * Time in milliseconds to fade in/fade out | ||
2148 | /** |
|
2148 | */ | |
2149 | * See description of `dijit/Tooltip.defaultPosition` for details on position parameter. |
|
2149 | duration: number; | |
2150 | */ |
|
2150 | ||
2151 | position: string; |
|
2151 | /** | |
2152 |
|
2152 | * Don't change this parameter from the default value. | ||
2153 | /** |
|
2153 | * | |
2154 | * CSS expression to apply this Tooltip to descendants of connectIds, rather than to |
|
2154 | * This ContentPane parameter doesn't make sense for TitlePane, since TitlePane is never a child of a layout container, nor should TitlePane try to control the size of an inner widget. | |
2155 | * the nodes specified by connectIds themselves. Useful for applying a Tooltip to |
|
2155 | */ | |
2156 | * a range of rows in a table, tree, etc. Use in conjunction with getContent() parameter. |
|
2156 | doLayout: boolean; | |
2157 | * Ex: connectId: myTable, selector: "tr", getContent: function(node){ return ...; } |
|
2157 | ||
2158 | * |
|
2158 | /** | |
2159 | * The application must require() an appropriate level of dojo/query to handle the selector. |
|
2159 | * Switches between opened and closed state | |
2160 | */ |
|
2160 | */ | |
2161 | selector: string; |
|
2161 | toggle(): void; | |
2162 |
|
2162 | |||
2163 | /** |
|
2163 | /** | |
2164 | * Attach tooltip to specified node if it's not already connected |
|
2164 | * Set the open/close css state for the TitlePane | |
2165 | */ |
|
2165 | */ | |
2166 | addTarget(node: dojo.NodeOrString): void; |
|
2166 | _setCss(): void; | |
2167 |
|
2167 | |||
2168 | /** |
|
2168 | /** | |
2169 | * Detach tooltip from specified node |
|
2169 | * Handler for when user hits a key | |
2170 | */ |
|
2170 | */ | |
2171 | removeTarget(node: dojo.NodeOrString): void; |
|
2171 | _onTitleKey(e: Event): void; | |
2172 |
|
2172 | |||
2173 | /** |
|
2173 | /** | |
2174 | * User overridable function that return the text to display in the tooltip. |
|
2174 | * Handler when user clicks the title bar | |
2175 | */ |
|
2175 | */ | |
2176 | getContent(node: Node): Node; |
|
2176 | _onTitleClick(): void; | |
2177 |
|
2177 | |||
2178 | /** |
|
2178 | /** | |
2179 | * Display the tooltip; usually not called directly. |
|
2179 | * Deprecated. Use set('title', ...) instead. | |
2180 | */ |
|
2180 | */ | |
2181 | open(target: Node): void; |
|
2181 | setTitle(): void; | |
2182 |
|
2182 | } | ||
2183 | /** |
|
2183 | ||
2184 | * Hide the tooltip or cancel timer for show of tooltip |
|
2184 | interface TitlePaneConstructor extends _WidgetBaseConstructor<TitlePane> { } | |
2185 | */ |
|
2185 | ||
2186 | close(): void; |
|
2186 | /* dijit/Toolbar */ | |
2187 |
|
2187 | |||
2188 | /** |
|
2188 | interface Toolbar extends dijit._Widget, dijit._TemplatedMixin, dijit._KeyNavContainer { } | |
2189 | * Called when the tooltip is shown |
|
2189 | ||
2190 | */ |
|
2190 | interface ToolbarConstructor extends _WidgetBaseConstructor<Toolbar> { } | |
2191 | onShow(): void; |
|
2191 | ||
2192 |
|
2192 | /* dijit/ToolbarSeparator */ | ||
2193 | /** |
|
2193 | ||
2194 | * Called when the tooltip is hidden |
|
2194 | interface ToolbarSeparator extends dijit._Widget, dijit._TemplatedMixin { } | |
2195 | */ |
|
2195 | ||
2196 | onHide(): void; |
|
2196 | interface ToolbarSeparatorConstructor extends _WidgetBaseConstructor<ToolbarSeparator> { } | |
2197 | } |
|
2197 | ||
2198 |
|
2198 | /* dijit/Tooltip */ | ||
2199 | interface TooltipConstructor extends _WidgetBaseConstructor<Tooltip> { |
|
2199 | ||
2200 | /** |
|
2200 | interface Tooltip extends _Widget { | |
2201 | * This variable controls the position of tooltips, if the position is not specified to |
|
2201 | /** | |
2202 | * the Tooltip widget or *TextBox widget itself. It's an array of strings with the values |
|
2202 | * HTML to display in the tooltip. | |
2203 | * possible for `dijit/place.around()`. The recommended values are: |
|
2203 | * Specified as innerHTML when creating the widget from markup. | |
2204 | * |
|
2204 | */ | |
2205 | * - before-centered: centers tooltip to the left of the anchor node/widget, or to the right |
|
2205 | label: string; | |
2206 | * in the case of RTL scripts like Hebrew and Arabic |
|
2206 | ||
2207 | * - after-centered: centers tooltip to the right of the anchor node/widget, or to the left |
|
2207 | /** | |
2208 | * in the case of RTL scripts like Hebrew and Arabic |
|
2208 | * Number of milliseconds to wait after hovering over/focusing on the object, before | |
2209 | * - above-centered: tooltip is centered above anchor node |
|
2209 | * the tooltip is displayed. | |
2210 | * - below-centered: tooltip is centered above anchor node |
|
2210 | */ | |
2211 | * |
|
2211 | showDelay: number; | |
2212 | * The list is positions is tried, in order, until a position is found where the tooltip fits |
|
2212 | ||
2213 | * within the viewport. |
|
2213 | /** | |
2214 | * |
|
2214 | * Number of milliseconds to wait after unhovering the object, before | |
2215 | * Be careful setting this parameter. A value of "above-centered" may work fine until the user scrolls |
|
2215 | * the tooltip is hidden. Note that blurring an object hides the tooltip immediately. | |
2216 | * the screen so that there's no room above the target node. Nodes with drop downs, like |
|
2216 | */ | |
2217 | * DropDownButton or FilteringSelect, are especially problematic, in that you need to be sure |
|
2217 | hideDelay: number; | |
2218 | * that the drop down and tooltip don't overlap, even when the viewport is scrolled so that there |
|
2218 | ||
2219 | * is only room below (or above) the target node, but not both. |
|
2219 | /** | |
2220 | */ |
|
2220 | * Id of domNode(s) to attach the tooltip to. | |
2221 | defaultPosition: [string]; |
|
2221 | * When user hovers over specified dom node(s), the tooltip will appear. | |
2222 |
|
2222 | */ | ||
2223 | /** |
|
2223 | connectId: dojo.NodeOrString | dojo.NodeOrString[]; | |
2224 | * Static method to display tooltip w/specified contents in specified position. |
|
2224 | ||
2225 | * See description of dijit/Tooltip.defaultPosition for details on position parameter. |
|
2225 | /** | |
2226 | * If position is not specified then dijit/Tooltip.defaultPosition is used. |
|
2226 | * See description of `dijit/Tooltip.defaultPosition` for details on position parameter. | |
2227 | */ |
|
2227 | */ | |
2228 | show(innerHTML: string, aroundNode: PlaceRectangle, position?: [string], rtl?: boolean, textDir?: string, onMouseEnter?: Function, onMouseLeave?: Function): void; |
|
2228 | position: string; | |
2229 |
|
2229 | |||
2230 | /** |
|
2230 | /** | |
2231 | * Hide the tooltip |
|
2231 | * CSS expression to apply this Tooltip to descendants of connectIds, rather than to | |
2232 | */ |
|
2232 | * the nodes specified by connectIds themselves. Useful for applying a Tooltip to | |
2233 | hide(aroundNode: PlaceRectangle): void; |
|
2233 | * a range of rows in a table, tree, etc. Use in conjunction with getContent() parameter. | |
2234 | } |
|
2234 | * Ex: connectId: myTable, selector: "tr", getContent: function(node){ return ...; } | |
2235 |
|
2235 | * | ||
2236 | /* dijit/TooltipDialog */ |
|
2236 | * The application must require() an appropriate level of dojo/query to handle the selector. | |
2237 |
|
2237 | */ | ||
2238 | interface TooltipDialog extends layout.ContentPane, _TemplatedMixin, form._FormMixin, _DialogMixin { |
|
2238 | selector: string; | |
2239 | /** |
|
2239 | ||
2240 | * Description of tooltip dialog (required for a11y) |
|
2240 | /** | |
2241 | */ |
|
2241 | * Attach tooltip to specified node if it's not already connected | |
2242 | title: string; |
|
2242 | */ | |
2243 |
|
2243 | addTarget(node: dojo.NodeOrString): void; | ||
2244 | /** |
|
2244 | ||
2245 | * Don't change this parameter from the default value. |
|
2245 | /** | |
2246 | * This ContentPane parameter doesn't make sense for TooltipDialog, since TooltipDialog |
|
2246 | * Detach tooltip from specified node | |
2247 | * is never a child of a layout container, nor can you specify the size of |
|
2247 | */ | |
2248 | * TooltipDialog in order to control the size of an inner widget. |
|
2248 | removeTarget(node: dojo.NodeOrString): void; | |
2249 | */ |
|
2249 | ||
2250 | doLayout: boolean; |
|
2250 | /** | |
2251 |
|
2251 | * User overridable function that return the text to display in the tooltip. | ||
2252 | /** |
|
2252 | */ | |
2253 | * A Toggle to modify the default focus behavior of a Dialog, which |
|
2253 | getContent(node: Node): Node; | |
2254 | * is to focus on the first dialog element after opening the dialog. |
|
2254 | ||
2255 | * False will disable autofocusing. Default: true. |
|
2255 | /** | |
2256 | */ |
|
2256 | * Display the tooltip; usually not called directly. | |
2257 | autofocus: boolean; |
|
2257 | */ | |
2258 |
|
2258 | open(target: Node): void; | ||
2259 | /** |
|
2259 | ||
2260 | * The pointer to the first focusable node in the dialog. |
|
2260 | /** | |
2261 | */ |
|
2261 | * Hide the tooltip or cancel timer for show of tooltip | |
2262 | _firstFocusItem: any; |
|
2262 | */ | |
2263 |
|
2263 | close(): void; | ||
2264 | /** |
|
2264 | ||
2265 | * The pointer to which node has focus prior to our dialog. |
|
2265 | /** | |
2266 | */ |
|
2266 | * Called when the tooltip is shown | |
2267 | _lastFocusItem: any; |
|
2267 | */ | |
2268 |
|
2268 | onShow(): void; | ||
2269 | /** |
|
2269 | ||
2270 | * Configure widget to be displayed in given position relative to the button. |
|
2270 | /** | |
2271 | * |
|
2271 | * Called when the tooltip is hidden | |
2272 | * This is called from the dijit.popup code, and should not be called directly. |
|
2272 | */ | |
2273 | */ |
|
2273 | onHide(): void; | |
2274 | orient(node: Node | HTMLElement, aroundCorner: PlaceCorner, tooltipCorner: PlaceCorner): void; |
|
2274 | } | |
2275 |
|
2275 | |||
2276 | /** |
|
2276 | interface TooltipConstructor extends _WidgetBaseConstructor<Tooltip> { | |
2277 | * Focus on first field |
|
2277 | /** | |
2278 | */ |
|
2278 | * This variable controls the position of tooltips, if the position is not specified to | |
2279 | focus(): void; |
|
2279 | * the Tooltip widget or *TextBox widget itself. It's an array of strings with the values | |
2280 |
|
2280 | * possible for `dijit/place.around()`. The recommended values are: | ||
2281 | /** |
|
2281 | * | |
2282 | * Called when dialog is displayed. |
|
2282 | * - before-centered: centers tooltip to the left of the anchor node/widget, or to the right | |
2283 | * |
|
2283 | * in the case of RTL scripts like Hebrew and Arabic | |
2284 | * This is called from the dijit.popup code, and should not be called directly. |
|
2284 | * - after-centered: centers tooltip to the right of the anchor node/widget, or to the left | |
2285 | */ |
|
2285 | * in the case of RTL scripts like Hebrew and Arabic | |
2286 | onOpen(pos: { |
|
2286 | * - above-centered: tooltip is centered above anchor node | |
2287 | aroundCorner: PlaceCorner |
|
2287 | * - below-centered: tooltip is centered above anchor node | |
2288 | aroundNodePos: PlacePosition |
|
2288 | * | |
2289 | corner: PlaceCorner |
|
2289 | * The list is positions is tried, in order, until a position is found where the tooltip fits | |
2290 | x: number |
|
2290 | * within the viewport. | |
2291 | y: number |
|
2291 | * | |
2292 | }): void; |
|
2292 | * Be careful setting this parameter. A value of "above-centered" may work fine until the user scrolls | |
2293 |
|
2293 | * the screen so that there's no room above the target node. Nodes with drop downs, like | ||
2294 | /** |
|
2294 | * DropDownButton or FilteringSelect, are especially problematic, in that you need to be sure | |
2295 | * Handler for keydown events |
|
2295 | * that the drop down and tooltip don't overlap, even when the viewport is scrolled so that there | |
2296 | * |
|
2296 | * is only room below (or above) the target node, but not both. | |
2297 | * Keep keyboard focus in dialog; close dialog on escape key |
|
2297 | */ | |
2298 | */ |
|
2298 | defaultPosition: [string]; | |
2299 | _onKey(evt: KeyboardEvent): void; |
|
2299 | ||
2300 | } |
|
2300 | /** | |
2301 |
|
2301 | * Static method to display tooltip w/specified contents in specified position. | ||
2302 | interface TooltipDialogConstructor extends _WidgetBaseConstructor<TooltipDialog> { } |
|
2302 | * See description of dijit/Tooltip.defaultPosition for details on position parameter. | |
|
2303 | * If position is not specified then dijit/Tooltip.defaultPosition is used. | |||
|
2304 | */ | |||
|
2305 | show(innerHTML: string, aroundNode: PlaceRectangle, position?: [string], rtl?: boolean, textDir?: string, onMouseEnter?: Function, onMouseLeave?: Function): void; | |||
|
2306 | ||||
|
2307 | /** | |||
|
2308 | * Hide the tooltip | |||
|
2309 | */ | |||
|
2310 | hide(aroundNode: PlaceRectangle): void; | |||
|
2311 | } | |||
|
2312 | ||||
|
2313 | /* dijit/TooltipDialog */ | |||
|
2314 | ||||
|
2315 | interface TooltipDialog extends layout.ContentPane, _TemplatedMixin, form._FormMixin, _DialogMixin { | |||
|
2316 | /** | |||
|
2317 | * Description of tooltip dialog (required for a11y) | |||
|
2318 | */ | |||
|
2319 | title: string; | |||
|
2320 | ||||
|
2321 | /** | |||
|
2322 | * Don't change this parameter from the default value. | |||
|
2323 | * This ContentPane parameter doesn't make sense for TooltipDialog, since TooltipDialog | |||
|
2324 | * is never a child of a layout container, nor can you specify the size of | |||
|
2325 | * TooltipDialog in order to control the size of an inner widget. | |||
|
2326 | */ | |||
|
2327 | doLayout: boolean; | |||
|
2328 | ||||
|
2329 | /** | |||
|
2330 | * A Toggle to modify the default focus behavior of a Dialog, which | |||
|
2331 | * is to focus on the first dialog element after opening the dialog. | |||
|
2332 | * False will disable autofocusing. Default: true. | |||
|
2333 | */ | |||
|
2334 | autofocus: boolean; | |||
|
2335 | ||||
|
2336 | /** | |||
|
2337 | * The pointer to the first focusable node in the dialog. | |||
|
2338 | */ | |||
|
2339 | _firstFocusItem: any; | |||
|
2340 | ||||
|
2341 | /** | |||
|
2342 | * The pointer to which node has focus prior to our dialog. | |||
|
2343 | */ | |||
|
2344 | _lastFocusItem: any; | |||
|
2345 | ||||
|
2346 | /** | |||
|
2347 | * Configure widget to be displayed in given position relative to the button. | |||
|
2348 | * | |||
|
2349 | * This is called from the dijit.popup code, and should not be called directly. | |||
|
2350 | */ | |||
|
2351 | orient(node: Node | HTMLElement, aroundCorner: PlaceCorner, tooltipCorner: PlaceCorner): void; | |||
|
2352 | ||||
|
2353 | /** | |||
|
2354 | * Focus on first field | |||
|
2355 | */ | |||
|
2356 | focus(): void; | |||
|
2357 | ||||
|
2358 | /** | |||
|
2359 | * Called when dialog is displayed. | |||
|
2360 | * | |||
|
2361 | * This is called from the dijit.popup code, and should not be called directly. | |||
|
2362 | */ | |||
|
2363 | onOpen(pos: { | |||
|
2364 | aroundCorner: PlaceCorner | |||
|
2365 | aroundNodePos: PlacePosition | |||
|
2366 | corner: PlaceCorner | |||
|
2367 | x: number | |||
|
2368 | y: number | |||
|
2369 | }): void; | |||
|
2370 | ||||
|
2371 | /** | |||
|
2372 | * Handler for keydown events | |||
|
2373 | * | |||
|
2374 | * Keep keyboard focus in dialog; close dialog on escape key | |||
|
2375 | */ | |||
|
2376 | _onKey(evt: KeyboardEvent): void; | |||
|
2377 | } | |||
|
2378 | ||||
|
2379 | interface TooltipDialogConstructor extends _WidgetBaseConstructor<TooltipDialog> { } | |||
2303 | } |
|
2380 | } |
@@ -1,487 +1,487 | |||||
1 | /// <reference path="index.d.ts" /> |
|
1 | /// <reference path="index.d.ts" /> | |
2 |
|
2 | |||
3 | declare module 'dijit/_Widget' { |
|
3 | declare module 'dijit/_Widget' { | |
4 | type _Widget = dijit._Widget; |
|
4 | type _Widget = dijit._Widget; | |
5 | const _Widget: dijit._WidgetBaseConstructor<_Widget>; |
|
5 | const _Widget: dijit._WidgetBaseConstructor<_Widget>; | |
6 | export = _Widget; |
|
6 | export = _Widget; | |
7 | } |
|
7 | } | |
8 |
|
8 | |||
9 | declare module 'dijit/_WidgetBase' { |
|
9 | declare module 'dijit/_WidgetBase' { | |
10 | type _WidgetBase<A = any> = dijit._WidgetBase<A>; |
|
10 | type _WidgetBase<E extends { [k in keyof E]: Event } = {}> = dijit._WidgetBase<E & GlobalEventHandlersEventMap>; | |
11 |
|
11 | |||
12 | // individual _WidgetBase constructor to keep type parameters |
|
12 | // individual _WidgetBase constructor to keep type parameters | |
13 | interface _WidgetBaseConstructor { |
|
13 | interface _WidgetBaseConstructor { | |
14 |
new <A = |
|
14 | new <A = {}, E extends { [k in keyof E]: Event } = {}>(params?: Partial<_WidgetBase<E> & A>, srcNodeRef?: dojo.NodeOrString): _WidgetBase<E> & dojo._base.DeclareCreatedObject; | |
15 | prototype: _WidgetBase; |
|
15 | prototype: _WidgetBase<any>; | |
16 | } |
|
16 | } | |
17 | const _WidgetBase: _WidgetBaseConstructor; |
|
17 | const _WidgetBase: _WidgetBaseConstructor; | |
18 | export = _WidgetBase; |
|
18 | export = _WidgetBase; | |
19 | } |
|
19 | } | |
20 |
|
20 | |||
21 | declare module 'dijit/_AttachMixin' { |
|
21 | declare module 'dijit/_AttachMixin' { | |
22 | type _AttachMixin = dijit._AttachMixin; |
|
22 | type _AttachMixin = dijit._AttachMixin; | |
23 | const _AttachMixin: dijit._AttachMixinConstructor; |
|
23 | const _AttachMixin: dijit._AttachMixinConstructor; | |
24 | export = _AttachMixin; |
|
24 | export = _AttachMixin; | |
25 | } |
|
25 | } | |
26 |
|
26 | |||
27 | declare module 'dijit/_CssStateMixin' { |
|
27 | declare module 'dijit/_CssStateMixin' { | |
28 | type _CssStateMixin = dijit._CssStateMixin; |
|
28 | type _CssStateMixin = dijit._CssStateMixin; | |
29 | const _CssStateMixin: dijit._CssStateMixinConstructor; |
|
29 | const _CssStateMixin: dijit._CssStateMixinConstructor; | |
30 | export = _CssStateMixin; |
|
30 | export = _CssStateMixin; | |
31 | } |
|
31 | } | |
32 |
|
32 | |||
33 | declare module 'dijit/_Contained' { |
|
33 | declare module 'dijit/_Contained' { | |
34 | type _Contained = dijit._Contained; |
|
34 | type _Contained = dijit._Contained; | |
35 | const _Contained: dijit._ContainedConstructor; |
|
35 | const _Contained: dijit._ContainedConstructor; | |
36 | export = _Contained; |
|
36 | export = _Contained; | |
37 | } |
|
37 | } | |
38 |
|
38 | |||
39 | declare module 'dijit/_Container' { |
|
39 | declare module 'dijit/_Container' { | |
40 | type _Container = dijit._Container; |
|
40 | type _Container = dijit._Container; | |
41 | const _Container: dijit._ContainerConstructor; |
|
41 | const _Container: dijit._ContainerConstructor; | |
42 | export = _Container; |
|
42 | export = _Container; | |
43 | } |
|
43 | } | |
44 |
|
44 | |||
45 | declare module 'dijit/_KeyNavContainer' { |
|
45 | declare module 'dijit/_KeyNavContainer' { | |
46 | type _KeyNavContainer = dijit._KeyNavContainer; |
|
46 | type _KeyNavContainer = dijit._KeyNavContainer; | |
47 | const _KeyNavContainer: dijit._KeyNavContainerConstructor; |
|
47 | const _KeyNavContainer: dijit._KeyNavContainerConstructor; | |
48 | export = _KeyNavContainer; |
|
48 | export = _KeyNavContainer; | |
49 | } |
|
49 | } | |
50 |
|
50 | |||
51 | declare module 'dijit/_KeyNavMixin' { |
|
51 | declare module 'dijit/_KeyNavMixin' { | |
52 | type _KeyNavMixin = dijit._KeyNavMixin; |
|
52 | type _KeyNavMixin = dijit._KeyNavMixin; | |
53 | const _KeyNavMixin: dijit._KeyNavMixinConstructor; |
|
53 | const _KeyNavMixin: dijit._KeyNavMixinConstructor; | |
54 | export = _KeyNavMixin; |
|
54 | export = _KeyNavMixin; | |
55 | } |
|
55 | } | |
56 |
|
56 | |||
57 | declare module 'dijit/_MenuBase' { |
|
57 | declare module 'dijit/_MenuBase' { | |
58 | type _MenuBase = dijit._MenuBase; |
|
58 | type _MenuBase = dijit._MenuBase; | |
59 | const _MenuBase: dijit._MenuBaseConstructor; |
|
59 | const _MenuBase: dijit._MenuBaseConstructor; | |
60 | export = _MenuBase; |
|
60 | export = _MenuBase; | |
61 | } |
|
61 | } | |
62 |
|
62 | |||
63 | declare module 'dijit/_TemplatedMixin' { |
|
63 | declare module 'dijit/_TemplatedMixin' { | |
64 | type _TemplatedMixin = dijit._TemplatedMixin; |
|
64 | type _TemplatedMixin = dijit._TemplatedMixin; | |
65 | const _TemplatedMixin: dijit._TemplatedMixinConstructor; |
|
65 | const _TemplatedMixin: dijit._TemplatedMixinConstructor; | |
66 | export = _TemplatedMixin; |
|
66 | export = _TemplatedMixin; | |
67 | } |
|
67 | } | |
68 |
|
68 | |||
69 | declare module 'dijit/_WidgetsInTemplateMixin' { |
|
69 | declare module 'dijit/_WidgetsInTemplateMixin' { | |
70 | type _WidgetsInTemplateMixin = dijit._WidgetsInTemplateMixin; |
|
70 | type _WidgetsInTemplateMixin = dijit._WidgetsInTemplateMixin; | |
71 | const _WidgetsInTemplateMixin: dijit._WidgetsInTemplateMixinConstructor; |
|
71 | const _WidgetsInTemplateMixin: dijit._WidgetsInTemplateMixinConstructor; | |
72 | export = _WidgetsInTemplateMixin; |
|
72 | export = _WidgetsInTemplateMixin; | |
73 | } |
|
73 | } | |
74 |
|
74 | |||
75 | declare module 'dijit/ConfirmDialog' { |
|
75 | declare module 'dijit/ConfirmDialog' { | |
76 | type ConfirmDialog = dijit.ConfirmDialog; |
|
76 | type ConfirmDialog = dijit.ConfirmDialog; | |
77 | const ConfirmDialog: dijit.ConfirmDialogConstructor; |
|
77 | const ConfirmDialog: dijit.ConfirmDialogConstructor; | |
78 | export = ConfirmDialog; |
|
78 | export = ConfirmDialog; | |
79 | } |
|
79 | } | |
80 |
|
80 | |||
81 | declare module 'dijit/Calendar' { |
|
81 | declare module 'dijit/Calendar' { | |
82 | type Calendar = dijit.Calendar; |
|
82 | type Calendar = dijit.Calendar; | |
83 | const Calendar: dijit.CalendarConstructor; |
|
83 | const Calendar: dijit.CalendarConstructor; | |
84 | export = Calendar; |
|
84 | export = Calendar; | |
85 | } |
|
85 | } | |
86 |
|
86 | |||
87 | declare module 'dijit/CalendarLite' { |
|
87 | declare module 'dijit/CalendarLite' { | |
88 | type CalendarLite = dijit.CalendarLite; |
|
88 | type CalendarLite = dijit.CalendarLite; | |
89 | const CalendarLite: dijit.CalendarLiteConstructor; |
|
89 | const CalendarLite: dijit.CalendarLiteConstructor; | |
90 | export = CalendarLite; |
|
90 | export = CalendarLite; | |
91 | } |
|
91 | } | |
92 |
|
92 | |||
93 | declare module 'dijit/Destroyable' { |
|
93 | declare module 'dijit/Destroyable' { | |
94 | type Destroyable = dijit.Destroyable; |
|
94 | type Destroyable = dijit.Destroyable; | |
95 | const Destroyable: dijit.DestroyableConstructor; |
|
95 | const Destroyable: dijit.DestroyableConstructor; | |
96 | export = Destroyable; |
|
96 | export = Destroyable; | |
97 | } |
|
97 | } | |
98 |
|
98 | |||
99 | declare module 'dijit/Dialog' { |
|
99 | declare module 'dijit/Dialog' { | |
100 | type Dialog = dijit.Dialog; |
|
100 | type Dialog = dijit.Dialog; | |
101 | const Dialog: dijit.DialogConstructor; |
|
101 | const Dialog: dijit.DialogConstructor; | |
102 | export = Dialog; |
|
102 | export = Dialog; | |
103 | } |
|
103 | } | |
104 |
|
104 | |||
105 | declare module 'dijit/DropDownMenu' { |
|
105 | declare module 'dijit/DropDownMenu' { | |
106 | type DropDownMenu = dijit.DropDownMenu; |
|
106 | type DropDownMenu = dijit.DropDownMenu; | |
107 | const DropDownMenu: dijit.DropDownMenuConstructor; |
|
107 | const DropDownMenu: dijit.DropDownMenuConstructor; | |
108 | export = DropDownMenu; |
|
108 | export = DropDownMenu; | |
109 | } |
|
109 | } | |
110 |
|
110 | |||
111 | declare module 'dijit/Fieldset' { |
|
111 | declare module 'dijit/Fieldset' { | |
112 | type Fieldset = dijit.Fieldset; |
|
112 | type Fieldset = dijit.Fieldset; | |
113 | const Fieldset: dijit.FieldsetConstructor; |
|
113 | const Fieldset: dijit.FieldsetConstructor; | |
114 | export = Fieldset; |
|
114 | export = Fieldset; | |
115 | } |
|
115 | } | |
116 |
|
116 | |||
117 | declare module 'dijit/Menu' { |
|
117 | declare module 'dijit/Menu' { | |
118 | type Menu = dijit.Menu; |
|
118 | type Menu = dijit.Menu; | |
119 | const Menu: dijit.MenuConstructor; |
|
119 | const Menu: dijit.MenuConstructor; | |
120 | export = Menu; |
|
120 | export = Menu; | |
121 | } |
|
121 | } | |
122 |
|
122 | |||
123 | declare module 'dijit/MenuBar' { |
|
123 | declare module 'dijit/MenuBar' { | |
124 | type MenuBar = dijit.MenuBar; |
|
124 | type MenuBar = dijit.MenuBar; | |
125 | const MenuBar: dijit.MenuBarConstructor; |
|
125 | const MenuBar: dijit.MenuBarConstructor; | |
126 | export = MenuBar; |
|
126 | export = MenuBar; | |
127 | } |
|
127 | } | |
128 |
|
128 | |||
129 | declare module 'dijit/MenuBarItem' { |
|
129 | declare module 'dijit/MenuBarItem' { | |
130 | type MenuBarItem = dijit.MenuBarItem; |
|
130 | type MenuBarItem = dijit.MenuBarItem; | |
131 | const MenuBarItem: dijit.MenuBarItemConstructor; |
|
131 | const MenuBarItem: dijit.MenuBarItemConstructor; | |
132 | export = MenuBarItem; |
|
132 | export = MenuBarItem; | |
133 | } |
|
133 | } | |
134 |
|
134 | |||
135 | declare module 'dijit/MenuItem' { |
|
135 | declare module 'dijit/MenuItem' { | |
136 | type MenuItem = dijit.MenuItem; |
|
136 | type MenuItem = dijit.MenuItem; | |
137 | const MenuItem: dijit.MenuItemConstructor; |
|
137 | const MenuItem: dijit.MenuItemConstructor; | |
138 | export = MenuItem; |
|
138 | export = MenuItem; | |
139 | } |
|
139 | } | |
140 |
|
140 | |||
141 | declare module 'dijit/MenuSeparator' { |
|
141 | declare module 'dijit/MenuSeparator' { | |
142 | type MenuSeparator = dijit.MenuSeparator; |
|
142 | type MenuSeparator = dijit.MenuSeparator; | |
143 | const MenuSeparator: dijit.MenuSeparatorConstructor; |
|
143 | const MenuSeparator: dijit.MenuSeparatorConstructor; | |
144 | export = MenuSeparator; |
|
144 | export = MenuSeparator; | |
145 | } |
|
145 | } | |
146 |
|
146 | |||
147 | declare module 'dijit/place' { |
|
147 | declare module 'dijit/place' { | |
148 | const place: dijit.Place; |
|
148 | const place: dijit.Place; | |
149 | export = place; |
|
149 | export = place; | |
150 | } |
|
150 | } | |
151 |
|
151 | |||
152 | declare module 'dijit/popup' { |
|
152 | declare module 'dijit/popup' { | |
153 | const popup: dijit.PopupManager; |
|
153 | const popup: dijit.PopupManager; | |
154 | export = popup; |
|
154 | export = popup; | |
155 | } |
|
155 | } | |
156 |
|
156 | |||
157 | declare module 'dijit/PopupMenuBarItem' { |
|
157 | declare module 'dijit/PopupMenuBarItem' { | |
158 | type PopupMenuBarItem = dijit.PopupMenuBarItem; |
|
158 | type PopupMenuBarItem = dijit.PopupMenuBarItem; | |
159 | const PopupMenuBarItem: dijit.PopupMenuBarItemConstructor; |
|
159 | const PopupMenuBarItem: dijit.PopupMenuBarItemConstructor; | |
160 | export = PopupMenuBarItem; |
|
160 | export = PopupMenuBarItem; | |
161 | } |
|
161 | } | |
162 |
|
162 | |||
163 | declare module 'dijit/PopupMenuItem' { |
|
163 | declare module 'dijit/PopupMenuItem' { | |
164 | type PopupMenuItem = dijit.PopupMenuItem; |
|
164 | type PopupMenuItem = dijit.PopupMenuItem; | |
165 | const PopupMenuItem: dijit.PopupMenuItemConstructor; |
|
165 | const PopupMenuItem: dijit.PopupMenuItemConstructor; | |
166 | export = PopupMenuItem; |
|
166 | export = PopupMenuItem; | |
167 | } |
|
167 | } | |
168 |
|
168 | |||
169 | declare module 'dijit/registry' { |
|
169 | declare module 'dijit/registry' { | |
170 | const registry: dijit.Registry; |
|
170 | const registry: dijit.Registry; | |
171 | export = registry; |
|
171 | export = registry; | |
172 | } |
|
172 | } | |
173 |
|
173 | |||
174 | declare module 'dijit/TitlePane' { |
|
174 | declare module 'dijit/TitlePane' { | |
175 | type TitlePane = dijit.TitlePane; |
|
175 | type TitlePane = dijit.TitlePane; | |
176 | const TitlePane: dijit.TitlePaneConstructor; |
|
176 | const TitlePane: dijit.TitlePaneConstructor; | |
177 | export = TitlePane; |
|
177 | export = TitlePane; | |
178 | } |
|
178 | } | |
179 |
|
179 | |||
180 | declare module 'dijit/Toolbar' { |
|
180 | declare module 'dijit/Toolbar' { | |
181 | type Toolbar = dijit.Toolbar; |
|
181 | type Toolbar = dijit.Toolbar; | |
182 | const Toolbar: dijit.ToolbarConstructor; |
|
182 | const Toolbar: dijit.ToolbarConstructor; | |
183 | export = Toolbar; |
|
183 | export = Toolbar; | |
184 | } |
|
184 | } | |
185 |
|
185 | |||
186 | declare module 'dijit/ToolbarSeparator' { |
|
186 | declare module 'dijit/ToolbarSeparator' { | |
187 | type ToolbarSeparator = dijit.ToolbarSeparator; |
|
187 | type ToolbarSeparator = dijit.ToolbarSeparator; | |
188 | const ToolbarSeparator: dijit.ToolbarSeparatorConstructor; |
|
188 | const ToolbarSeparator: dijit.ToolbarSeparatorConstructor; | |
189 | export = ToolbarSeparator; |
|
189 | export = ToolbarSeparator; | |
190 | } |
|
190 | } | |
191 |
|
191 | |||
192 | declare module 'dijit/Tooltip' { |
|
192 | declare module 'dijit/Tooltip' { | |
193 | type Tooltip = dijit.Tooltip; |
|
193 | type Tooltip = dijit.Tooltip; | |
194 | const Tooltip: dijit.TooltipConstructor; |
|
194 | const Tooltip: dijit.TooltipConstructor; | |
195 | export = Tooltip; |
|
195 | export = Tooltip; | |
196 | } |
|
196 | } | |
197 |
|
197 | |||
198 | declare module 'dijit/TooltipDialog' { |
|
198 | declare module 'dijit/TooltipDialog' { | |
199 | type TooltipDialog = dijit.TooltipDialog; |
|
199 | type TooltipDialog = dijit.TooltipDialog; | |
200 | const TooltipDialog: dijit.TooltipDialogConstructor; |
|
200 | const TooltipDialog: dijit.TooltipDialogConstructor; | |
201 | export = TooltipDialog; |
|
201 | export = TooltipDialog; | |
202 | } |
|
202 | } | |
203 |
|
203 | |||
204 | declare module 'dijit/_base/focus' { |
|
204 | declare module 'dijit/_base/focus' { | |
205 | const focus: dijit._base.Focus; |
|
205 | const focus: dijit._base.Focus; | |
206 | export = focus; |
|
206 | export = focus; | |
207 | } |
|
207 | } | |
208 |
|
208 | |||
209 | declare module 'dijit/_base/manager' { |
|
209 | declare module 'dijit/_base/manager' { | |
210 | const manager: dijit._base.Manager; |
|
210 | const manager: dijit._base.Manager; | |
211 | export = manager; |
|
211 | export = manager; | |
212 | } |
|
212 | } | |
213 |
|
213 | |||
214 | declare module 'dijit/_base/place' { |
|
214 | declare module 'dijit/_base/place' { | |
215 | const place: dijit._base.Place; |
|
215 | const place: dijit._base.Place; | |
216 | export = place; |
|
216 | export = place; | |
217 | } |
|
217 | } | |
218 |
|
218 | |||
219 | declare module 'dijit/_base/popup' { |
|
219 | declare module 'dijit/_base/popup' { | |
220 | const popup: dijit._base.Popup; |
|
220 | const popup: dijit._base.Popup; | |
221 | export = popup; |
|
221 | export = popup; | |
222 | } |
|
222 | } | |
223 |
|
223 | |||
224 | declare module 'dijit/_base/scroll' { |
|
224 | declare module 'dijit/_base/scroll' { | |
225 | const scroll: dijit._base.Scroll; |
|
225 | const scroll: dijit._base.Scroll; | |
226 | export = scroll; |
|
226 | export = scroll; | |
227 | } |
|
227 | } | |
228 |
|
228 | |||
229 | declare module 'dijit/_base/sniff' { |
|
229 | declare module 'dijit/_base/sniff' { | |
230 | const sniff: dijit._base.Sniff; |
|
230 | const sniff: dijit._base.Sniff; | |
231 | export = sniff; |
|
231 | export = sniff; | |
232 | } |
|
232 | } | |
233 |
|
233 | |||
234 | declare module 'dijit/_base/typematic' { |
|
234 | declare module 'dijit/_base/typematic' { | |
235 | const typematic: dijit._base.Typematic; |
|
235 | const typematic: dijit._base.Typematic; | |
236 | export = typematic; |
|
236 | export = typematic; | |
237 | } |
|
237 | } | |
238 |
|
238 | |||
239 | declare module 'dijit/_base/wai' { |
|
239 | declare module 'dijit/_base/wai' { | |
240 | const wai: dijit._base.Wai; |
|
240 | const wai: dijit._base.Wai; | |
241 | export = wai; |
|
241 | export = wai; | |
242 | } |
|
242 | } | |
243 |
|
243 | |||
244 | declare module 'dijit/_base/window' { |
|
244 | declare module 'dijit/_base/window' { | |
245 | const window: dijit._base.Window; |
|
245 | const window: dijit._base.Window; | |
246 | export = window; |
|
246 | export = window; | |
247 | } |
|
247 | } | |
248 |
|
248 | |||
249 | declare module 'dijit/form/_FormMixin' { |
|
249 | declare module 'dijit/form/_FormMixin' { | |
250 | type _FormMixin = dijit.form._FormMixin; |
|
250 | type _FormMixin = dijit.form._FormMixin; | |
251 | const _FormMixin: dijit.form._FormMixinConstructor; |
|
251 | const _FormMixin: dijit.form._FormMixinConstructor; | |
252 | export = _FormMixin; |
|
252 | export = _FormMixin; | |
253 | } |
|
253 | } | |
254 |
|
254 | |||
255 | declare module 'dijit/form/_FormValueWidget' { |
|
255 | declare module 'dijit/form/_FormValueWidget' { | |
256 | type _FormValueWidget = dijit.form._FormValueWidget; |
|
256 | type _FormValueWidget = dijit.form._FormValueWidget; | |
257 | const _FormValueWidget: dijit.form._FormValueWidgetConstructor; |
|
257 | const _FormValueWidget: dijit.form._FormValueWidgetConstructor; | |
258 | export = _FormValueWidget; |
|
258 | export = _FormValueWidget; | |
259 | } |
|
259 | } | |
260 |
|
260 | |||
261 | declare module 'dijit/form/_FormWidget' { |
|
261 | declare module 'dijit/form/_FormWidget' { | |
262 | type _FormWidget = dijit.form._FormWidget; |
|
262 | type _FormWidget = dijit.form._FormWidget; | |
263 | const _FormWidget: dijit.form._FormWidgetConstructor; |
|
263 | const _FormWidget: dijit.form._FormWidgetConstructor; | |
264 | export = _FormWidget; |
|
264 | export = _FormWidget; | |
265 | } |
|
265 | } | |
266 |
|
266 | |||
267 | declare module 'dijit/form/Button' { |
|
267 | declare module 'dijit/form/Button' { | |
268 | type Button = dijit.form.Button; |
|
268 | type Button = dijit.form.Button; | |
269 | const Button: dijit.form.ButtonConstructor; |
|
269 | const Button: dijit.form.ButtonConstructor; | |
270 | export = Button; |
|
270 | export = Button; | |
271 | } |
|
271 | } | |
272 |
|
272 | |||
273 | declare module 'dijit/form/CheckBox' { |
|
273 | declare module 'dijit/form/CheckBox' { | |
274 | type CheckBox = dijit.form.CheckBox; |
|
274 | type CheckBox = dijit.form.CheckBox; | |
275 | const CheckBox: dijit.form.CheckBoxConstructor; |
|
275 | const CheckBox: dijit.form.CheckBoxConstructor; | |
276 | export = CheckBox; |
|
276 | export = CheckBox; | |
277 | } |
|
277 | } | |
278 |
|
278 | |||
279 | declare module 'dijit/form/ComboBox' { |
|
279 | declare module 'dijit/form/ComboBox' { | |
280 | type ComboBox = dijit.form.TextBox; |
|
280 | type ComboBox = dijit.form.TextBox; | |
281 | const ComboBox: dijit.form.ComboBoxConstructor; |
|
281 | const ComboBox: dijit.form.ComboBoxConstructor; | |
282 | export = ComboBox; |
|
282 | export = ComboBox; | |
283 | } |
|
283 | } | |
284 |
|
284 | |||
285 | declare module 'dijit/form/ComboBoxMixin' { |
|
285 | declare module 'dijit/form/ComboBoxMixin' { | |
286 | type ComboBoxMixin<T, U extends dojo.store.api.BaseQueryType, V> = dijit.form.ComboBoxMixin<T, U, V>; |
|
286 | type ComboBoxMixin<T, U extends dojo.store.api.BaseQueryType, V> = dijit.form.ComboBoxMixin<T, U, V>; | |
287 | const ComboBoxMixin: dijit.form.ComboBoxConstructor; |
|
287 | const ComboBoxMixin: dijit.form.ComboBoxConstructor; | |
288 | export = ComboBoxMixin; |
|
288 | export = ComboBoxMixin; | |
289 | } |
|
289 | } | |
290 |
|
290 | |||
291 | declare module 'dijit/form/CurrencyTextBox' { |
|
291 | declare module 'dijit/form/CurrencyTextBox' { | |
292 | type CurrencyTextBox = dijit.form.CurrencyTextBox; |
|
292 | type CurrencyTextBox = dijit.form.CurrencyTextBox; | |
293 | const CurrencyTextBox: dijit.form.CurrencyTextBoxConstructor; |
|
293 | const CurrencyTextBox: dijit.form.CurrencyTextBoxConstructor; | |
294 | export = CurrencyTextBox; |
|
294 | export = CurrencyTextBox; | |
295 | } |
|
295 | } | |
296 |
|
296 | |||
297 | declare module 'dijit/form/DataList' { |
|
297 | declare module 'dijit/form/DataList' { | |
298 | type DataList<T> = dijit.form.DataList<T>; |
|
298 | type DataList<T> = dijit.form.DataList<T>; | |
299 | const DataList: dijit.form.DataListConstructor; |
|
299 | const DataList: dijit.form.DataListConstructor; | |
300 | export = DataList; |
|
300 | export = DataList; | |
301 | } |
|
301 | } | |
302 |
|
302 | |||
303 | declare module 'dijit/form/DateTextBox' { |
|
303 | declare module 'dijit/form/DateTextBox' { | |
304 | type DateTextBox = dijit.form.DateTextBox; |
|
304 | type DateTextBox = dijit.form.DateTextBox; | |
305 | const DateTextBox: dijit.form.DateTextBoxConstructor; |
|
305 | const DateTextBox: dijit.form.DateTextBoxConstructor; | |
306 | export = DateTextBox; |
|
306 | export = DateTextBox; | |
307 | } |
|
307 | } | |
308 |
|
308 | |||
309 | declare module 'dijit/form/DropDownButton' { |
|
309 | declare module 'dijit/form/DropDownButton' { | |
310 | type DropDownButton<T extends dijit._WidgetBase> = dijit.form.DropDownButton<T>; |
|
310 | type DropDownButton<T extends dijit._WidgetBase> = dijit.form.DropDownButton<T>; | |
311 | const DropDownButton: dijit.form.DropDownButtonConstructor; |
|
311 | const DropDownButton: dijit.form.DropDownButtonConstructor; | |
312 | export = DropDownButton; |
|
312 | export = DropDownButton; | |
313 | } |
|
313 | } | |
314 |
|
314 | |||
315 | declare module 'dijit/form/FilteringSelect' { |
|
315 | declare module 'dijit/form/FilteringSelect' { | |
316 | type FilteringSelect<C extends dijit.form.Constraints, T extends Object, Q extends string | Object | Function, O extends dojo.store.api.QueryOptions> = dijit.form.FilteringSelect<C, T, Q, O>; |
|
316 | type FilteringSelect<C extends dijit.form.Constraints, T extends Object, Q extends string | Object | Function, O extends dojo.store.api.QueryOptions> = dijit.form.FilteringSelect<C, T, Q, O>; | |
317 | const FilteringSelect: dijit.form.FilteringSelectConstructor; |
|
317 | const FilteringSelect: dijit.form.FilteringSelectConstructor; | |
318 | export = FilteringSelect; |
|
318 | export = FilteringSelect; | |
319 | } |
|
319 | } | |
320 |
|
320 | |||
321 | declare module 'dijit/form/Form' { |
|
321 | declare module 'dijit/form/Form' { | |
322 | type Form = dijit.form.Form; |
|
322 | type Form = dijit.form.Form; | |
323 | const Form: dijit.form.FormConstructor; |
|
323 | const Form: dijit.form.FormConstructor; | |
324 | export = Form; |
|
324 | export = Form; | |
325 | } |
|
325 | } | |
326 |
|
326 | |||
327 | declare module 'dijit/form/HorizontalRule' { |
|
327 | declare module 'dijit/form/HorizontalRule' { | |
328 | type HorizontalRule = dijit.form.HorizontalRule; |
|
328 | type HorizontalRule = dijit.form.HorizontalRule; | |
329 | const HorizontalRule: dijit.form.HorizontalRuleConstructor; |
|
329 | const HorizontalRule: dijit.form.HorizontalRuleConstructor; | |
330 | export = HorizontalRule; |
|
330 | export = HorizontalRule; | |
331 | } |
|
331 | } | |
332 |
|
332 | |||
333 | declare module 'dijit/form/HorizontalRuleLabels' { |
|
333 | declare module 'dijit/form/HorizontalRuleLabels' { | |
334 | type HorizontalRuleLabels = dijit.form.HorizontalRuleLabels; |
|
334 | type HorizontalRuleLabels = dijit.form.HorizontalRuleLabels; | |
335 | const HorizontalRuleLabels: dijit.form.HorizontalRuleLabelsConstructor; |
|
335 | const HorizontalRuleLabels: dijit.form.HorizontalRuleLabelsConstructor; | |
336 | export = HorizontalRuleLabels; |
|
336 | export = HorizontalRuleLabels; | |
337 | } |
|
337 | } | |
338 |
|
338 | |||
339 | declare module 'dijit/form/HorizontalSlider' { |
|
339 | declare module 'dijit/form/HorizontalSlider' { | |
340 | type HorizontalSlider = dijit.form.HorizontalSlider; |
|
340 | type HorizontalSlider = dijit.form.HorizontalSlider; | |
341 | const HorizontalSlider: dijit.form.HorizontalSliderConstructor; |
|
341 | const HorizontalSlider: dijit.form.HorizontalSliderConstructor; | |
342 | export = HorizontalSlider; |
|
342 | export = HorizontalSlider; | |
343 | } |
|
343 | } | |
344 |
|
344 | |||
345 | declare module 'dijit/form/MappedTextBox' { |
|
345 | declare module 'dijit/form/MappedTextBox' { | |
346 | type MappedTextBox<C extends dijit.form.Constraints> = dijit.form.MappedTextBox<C>; |
|
346 | type MappedTextBox<C extends dijit.form.Constraints> = dijit.form.MappedTextBox<C>; | |
347 | const MappedTextBox: dijit.form.MappedTextBoxConstructor; |
|
347 | const MappedTextBox: dijit.form.MappedTextBoxConstructor; | |
348 | export = MappedTextBox; |
|
348 | export = MappedTextBox; | |
349 | } |
|
349 | } | |
350 |
|
350 | |||
351 | declare module 'dijit/form/NumberSpinner' { |
|
351 | declare module 'dijit/form/NumberSpinner' { | |
352 | type NumberSpinner = dijit.form.NumberSpinner; |
|
352 | type NumberSpinner = dijit.form.NumberSpinner; | |
353 | const NumberSpinner: dijit.form.NumberSpinnerConstructor; |
|
353 | const NumberSpinner: dijit.form.NumberSpinnerConstructor; | |
354 | export = NumberSpinner; |
|
354 | export = NumberSpinner; | |
355 | } |
|
355 | } | |
356 |
|
356 | |||
357 | declare module 'dijit/form/NumberTextBox' { |
|
357 | declare module 'dijit/form/NumberTextBox' { | |
358 | type NumberTextBox = dijit.form.NumberTextBox; |
|
358 | type NumberTextBox = dijit.form.NumberTextBox; | |
359 | const NumberTextBox: dijit.form.NumberTextBoxConstructor; |
|
359 | const NumberTextBox: dijit.form.NumberTextBoxConstructor; | |
360 | export = NumberTextBox; |
|
360 | export = NumberTextBox; | |
361 | } |
|
361 | } | |
362 |
|
362 | |||
363 | declare module 'dijit/form/RadioButton' { |
|
363 | declare module 'dijit/form/RadioButton' { | |
364 | type RadioButton = dijit.form.RadioButton; |
|
364 | type RadioButton = dijit.form.RadioButton; | |
365 | const RadioButton: dijit.form.RadioButtonConstructor; |
|
365 | const RadioButton: dijit.form.RadioButtonConstructor; | |
366 | export = RadioButton; |
|
366 | export = RadioButton; | |
367 | } |
|
367 | } | |
368 |
|
368 | |||
369 | declare module 'dijit/form/RangeBoundTextBox' { |
|
369 | declare module 'dijit/form/RangeBoundTextBox' { | |
370 | type RangeBoundTextBox = dijit.form.RangeBoundTextBox; |
|
370 | type RangeBoundTextBox = dijit.form.RangeBoundTextBox; | |
371 | const RangeBoundTextBox: dijit.form.RangeBoundTextBoxConstructor; |
|
371 | const RangeBoundTextBox: dijit.form.RangeBoundTextBoxConstructor; | |
372 | export = RangeBoundTextBox; |
|
372 | export = RangeBoundTextBox; | |
373 | } |
|
373 | } | |
374 |
|
374 | |||
375 | declare module 'dijit/form/Select' { |
|
375 | declare module 'dijit/form/Select' { | |
376 | type Select<T, Q extends dojo.store.api.BaseQueryType, O, U extends dijit._WidgetBase> = dijit.form.Select<T, Q, O, U>; |
|
376 | type Select<T, Q extends dojo.store.api.BaseQueryType, O, U extends dijit._WidgetBase> = dijit.form.Select<T, Q, O, U>; | |
377 | const Select: dijit.form.SelectConstructor; |
|
377 | const Select: dijit.form.SelectConstructor; | |
378 | export = Select; |
|
378 | export = Select; | |
379 | } |
|
379 | } | |
380 |
|
380 | |||
381 | declare module 'dijit/form/SimpleTextarea' { |
|
381 | declare module 'dijit/form/SimpleTextarea' { | |
382 | type SimpleTextarea = dijit.form.SimpleTextarea; |
|
382 | type SimpleTextarea = dijit.form.SimpleTextarea; | |
383 | const SimpleTextarea: dijit.form.SimpleTextareaConstructor; |
|
383 | const SimpleTextarea: dijit.form.SimpleTextareaConstructor; | |
384 | export = SimpleTextarea; |
|
384 | export = SimpleTextarea; | |
385 | } |
|
385 | } | |
386 |
|
386 | |||
387 | declare module 'dijit/form/Textarea' { |
|
387 | declare module 'dijit/form/Textarea' { | |
388 | type Textarea = dijit.form.Textarea; |
|
388 | type Textarea = dijit.form.Textarea; | |
389 | const Textarea: dijit.form.TextareaConstructor; |
|
389 | const Textarea: dijit.form.TextareaConstructor; | |
390 | export = Textarea; |
|
390 | export = Textarea; | |
391 | } |
|
391 | } | |
392 |
|
392 | |||
393 | declare module 'dijit/form/TextBox' { |
|
393 | declare module 'dijit/form/TextBox' { | |
394 | type TextBox = dijit.form.TextBox; |
|
394 | type TextBox = dijit.form.TextBox; | |
395 | const TextBox: dijit.form.TextBoxConstructor; |
|
395 | const TextBox: dijit.form.TextBoxConstructor; | |
396 | export = TextBox; |
|
396 | export = TextBox; | |
397 | } |
|
397 | } | |
398 |
|
398 | |||
399 | declare module 'dijit/form/ToggleButton' { |
|
399 | declare module 'dijit/form/ToggleButton' { | |
400 | type ToggleButton = dijit.form.ToggleButton; |
|
400 | type ToggleButton = dijit.form.ToggleButton; | |
401 | const ToggleButton: dijit.form.ToggleButtonConstructor; |
|
401 | const ToggleButton: dijit.form.ToggleButtonConstructor; | |
402 | export = ToggleButton; |
|
402 | export = ToggleButton; | |
403 | } |
|
403 | } | |
404 |
|
404 | |||
405 | declare module 'dijit/form/ValidationTextBox' { |
|
405 | declare module 'dijit/form/ValidationTextBox' { | |
406 | type ValidationTextBox<C extends dijit.form.Constraints> = dijit.form.ValidationTextBox<C>; |
|
406 | type ValidationTextBox<C extends dijit.form.Constraints> = dijit.form.ValidationTextBox<C>; | |
407 | const ValidationTextBox: dijit.form.ValidationTextBoxConstructor; |
|
407 | const ValidationTextBox: dijit.form.ValidationTextBoxConstructor; | |
408 | export = ValidationTextBox; |
|
408 | export = ValidationTextBox; | |
409 | } |
|
409 | } | |
410 |
|
410 | |||
411 | declare module 'dijit/layout/_LayoutWidget' { |
|
411 | declare module 'dijit/layout/_LayoutWidget' { | |
412 | type _LayoutWidget = dijit.layout._LayoutWidget; |
|
412 | type _LayoutWidget = dijit.layout._LayoutWidget; | |
413 | const _LayoutWidget: dijit.layout._LayoutWidgetConstructor; |
|
413 | const _LayoutWidget: dijit.layout._LayoutWidgetConstructor; | |
414 | export = _LayoutWidget; |
|
414 | export = _LayoutWidget; | |
415 | } |
|
415 | } | |
416 |
|
416 | |||
417 | declare module 'dijit/layout/AccordionContainer' { |
|
417 | declare module 'dijit/layout/AccordionContainer' { | |
418 | type AccordionContainer = dijit.layout.AccordionContainer; |
|
418 | type AccordionContainer = dijit.layout.AccordionContainer; | |
419 | const AccordionContainer: dijit.layout.AccordionContainerConstructor; |
|
419 | const AccordionContainer: dijit.layout.AccordionContainerConstructor; | |
420 | export = AccordionContainer; |
|
420 | export = AccordionContainer; | |
421 | } |
|
421 | } | |
422 |
|
422 | |||
423 | declare module 'dijit/layout/AccordionPane' { |
|
423 | declare module 'dijit/layout/AccordionPane' { | |
424 | type AccordionPane = dijit.layout.AccordionPane; |
|
424 | type AccordionPane = dijit.layout.AccordionPane; | |
425 | const AccordionPane: dijit.layout.AccordionPaneConstructor; |
|
425 | const AccordionPane: dijit.layout.AccordionPaneConstructor; | |
426 | export = AccordionPane; |
|
426 | export = AccordionPane; | |
427 | } |
|
427 | } | |
428 |
|
428 | |||
429 | declare module 'dijit/layout/ContentPane' { |
|
429 | declare module 'dijit/layout/ContentPane' { | |
430 | type ContentPane = dijit.layout.ContentPane; |
|
430 | type ContentPane = dijit.layout.ContentPane; | |
431 | const ContentPane: dijit.layout.ContentPaneConstructor; |
|
431 | const ContentPane: dijit.layout.ContentPaneConstructor; | |
432 | export = ContentPane; |
|
432 | export = ContentPane; | |
433 | } |
|
433 | } | |
434 |
|
434 | |||
435 | declare module 'dijit/layout/_ContentPaneResizeMixin' { |
|
435 | declare module 'dijit/layout/_ContentPaneResizeMixin' { | |
436 | type _ContentPaneResizeMixin = dijit.layout._ContentPaneResizeMixin; |
|
436 | type _ContentPaneResizeMixin = dijit.layout._ContentPaneResizeMixin; | |
437 | const _ContentPaneResizeMixin: dijit.layout._ContentPaneResizeMixinConstructor; |
|
437 | const _ContentPaneResizeMixin: dijit.layout._ContentPaneResizeMixinConstructor; | |
438 | export = _ContentPaneResizeMixin; |
|
438 | export = _ContentPaneResizeMixin; | |
439 | } |
|
439 | } | |
440 |
|
440 | |||
441 | declare module 'dijit/layout/BorderContainer' { |
|
441 | declare module 'dijit/layout/BorderContainer' { | |
442 | type BorderContainer = dijit.layout.BorderContainer; |
|
442 | type BorderContainer = dijit.layout.BorderContainer; | |
443 | const BorderContainer: dijit.layout.BorderContainerConstructor; |
|
443 | const BorderContainer: dijit.layout.BorderContainerConstructor; | |
444 | export = BorderContainer; |
|
444 | export = BorderContainer; | |
445 | } |
|
445 | } | |
446 |
|
446 | |||
447 | declare module 'dijit/layout/LayoutContainer' { |
|
447 | declare module 'dijit/layout/LayoutContainer' { | |
448 | type LayoutContainer = dijit.layout.LayoutContainer; |
|
448 | type LayoutContainer = dijit.layout.LayoutContainer; | |
449 | const LayoutContainer: dijit.layout.LayoutContainerConstructor; |
|
449 | const LayoutContainer: dijit.layout.LayoutContainerConstructor; | |
450 | export = LayoutContainer; |
|
450 | export = LayoutContainer; | |
451 | } |
|
451 | } | |
452 |
|
452 | |||
453 | declare module 'dijit/layout/LinkPane' { |
|
453 | declare module 'dijit/layout/LinkPane' { | |
454 | type LinkPane = dijit.layout.LinkPane; |
|
454 | type LinkPane = dijit.layout.LinkPane; | |
455 | const LinkPane: dijit.layout.LinkPaneConstructor; |
|
455 | const LinkPane: dijit.layout.LinkPaneConstructor; | |
456 | export = LinkPane; |
|
456 | export = LinkPane; | |
457 | } |
|
457 | } | |
458 |
|
458 | |||
459 | declare module 'dijit/layout/ScrollingTabController' { |
|
459 | declare module 'dijit/layout/ScrollingTabController' { | |
460 | type ScrollingTabController = dijit.layout.ScrollingTabController; |
|
460 | type ScrollingTabController = dijit.layout.ScrollingTabController; | |
461 | const ScrollingTabController: dijit.layout.ScrollingTabControllerConstructor; |
|
461 | const ScrollingTabController: dijit.layout.ScrollingTabControllerConstructor; | |
462 | export = ScrollingTabController; |
|
462 | export = ScrollingTabController; | |
463 | } |
|
463 | } | |
464 |
|
464 | |||
465 | declare module 'dijit/layout/StackContainer' { |
|
465 | declare module 'dijit/layout/StackContainer' { | |
466 | type StackContainer = dijit.layout.StackContainer; |
|
466 | type StackContainer = dijit.layout.StackContainer; | |
467 | const StackContainer: dijit.layout.StackContainerConstructor; |
|
467 | const StackContainer: dijit.layout.StackContainerConstructor; | |
468 | export = StackContainer; |
|
468 | export = StackContainer; | |
469 | } |
|
469 | } | |
470 |
|
470 | |||
471 | declare module 'dijit/layout/StackController' { |
|
471 | declare module 'dijit/layout/StackController' { | |
472 | type StackController = dijit.layout.StackController; |
|
472 | type StackController = dijit.layout.StackController; | |
473 | const StackController: dijit.layout.StackControllerConstructor; |
|
473 | const StackController: dijit.layout.StackControllerConstructor; | |
474 | export = StackController; |
|
474 | export = StackController; | |
475 | } |
|
475 | } | |
476 |
|
476 | |||
477 | declare module 'dijit/layout/TabContainer' { |
|
477 | declare module 'dijit/layout/TabContainer' { | |
478 | type TabContainer = dijit.layout.TabContainer; |
|
478 | type TabContainer = dijit.layout.TabContainer; | |
479 | const TabContainer: dijit.layout.TabContainerConstructor; |
|
479 | const TabContainer: dijit.layout.TabContainerConstructor; | |
480 | export = TabContainer; |
|
480 | export = TabContainer; | |
481 | } |
|
481 | } | |
482 |
|
482 | |||
483 | declare module 'dijit/layout/TabController' { |
|
483 | declare module 'dijit/layout/TabController' { | |
484 | type TabController = dijit.layout.TabController; |
|
484 | type TabController = dijit.layout.TabController; | |
485 | const TabController: dijit.layout.TabControllerConstructor; |
|
485 | const TabController: dijit.layout.TabControllerConstructor; | |
486 | export = TabController; |
|
486 | export = TabController; | |
487 | } |
|
487 | } |
@@ -1,2101 +1,2101 | |||||
1 | /// <reference path="index.d.ts" /> |
|
1 | /// <reference path="index.d.ts" /> | |
2 | /// <reference path="../doh/doh.d.ts" /> |
|
2 | /// <reference path="../doh/doh.d.ts" /> | |
3 |
|
3 | |||
4 | declare namespace dojo { |
|
4 | declare namespace dojo { | |
5 | /* general implied types */ |
|
5 | /* general implied types */ | |
6 |
|
6 | |||
7 | type NodeOrString = Node | string; |
|
7 | type NodeOrString = Node | string; | |
8 | type ElementOrString = Element | string; |
|
8 | type ElementOrString = Element | string; | |
9 | type NodeFragmentOrString = NodeOrString | DocumentFragment; |
|
9 | type NodeFragmentOrString = NodeOrString | DocumentFragment; | |
10 |
|
10 | |||
11 | interface GenericConstructor<T> { |
|
11 | interface GenericConstructor<T> { | |
12 | new (...args: any[]): T; |
|
12 | new (...args: any[]): T; | |
13 | prototype: T; |
|
13 | prototype: T; | |
14 | } |
|
14 | } | |
15 |
|
15 | |||
16 | interface GenericObject { |
|
16 | interface GenericObject { | |
17 | [id: string]: any; |
|
17 | [id: string]: any; | |
18 | } |
|
18 | } | |
19 |
|
19 | |||
20 | interface GenericFunction<T> { |
|
20 | interface GenericFunction<T> { | |
21 | (...args: any[]): T; |
|
21 | (...args: any[]): T; | |
22 | } |
|
22 | } | |
23 |
|
23 | |||
24 | interface Handle { |
|
24 | interface Handle { | |
25 | remove(): void; |
|
25 | remove(): void; | |
26 | } |
|
26 | } | |
27 |
|
27 | |||
28 | interface EventListener { |
|
28 | interface EventListener { | |
29 | (evt: any): void; |
|
29 | (evt: any): void; | |
30 | } |
|
30 | } | |
31 |
|
31 | |||
32 | interface BuildProfile { |
|
32 | interface BuildProfile { | |
33 | resourceTags: { [tag: string]: (filename: string, mid?: string) => boolean; }; |
|
33 | resourceTags: { [tag: string]: (filename: string, mid?: string) => boolean; }; | |
34 | } |
|
34 | } | |
35 |
|
35 | |||
36 | interface Package { |
|
36 | interface Package { | |
37 | location?: string; |
|
37 | location?: string; | |
38 | main?: string; |
|
38 | main?: string; | |
39 | name?: string; |
|
39 | name?: string; | |
40 | } |
|
40 | } | |
41 |
|
41 | |||
42 | export interface ModuleMap extends ModuleMapItem { |
|
42 | export interface ModuleMap extends ModuleMapItem { | |
43 | [ sourceMid: string ]: ModuleMapReplacement; |
|
43 | [ sourceMid: string ]: ModuleMapReplacement; | |
44 | } |
|
44 | } | |
45 |
|
45 | |||
46 | export interface ModuleMapItem { |
|
46 | export interface ModuleMapItem { | |
47 | [ mid: string ]: /* ModuleMapReplacement | ModuleMap */ any; |
|
47 | [ mid: string ]: /* ModuleMapReplacement | ModuleMap */ any; | |
48 | } |
|
48 | } | |
49 |
|
49 | |||
50 | export interface ModuleMapReplacement extends ModuleMapItem { |
|
50 | export interface ModuleMapReplacement extends ModuleMapItem { | |
51 | [ findMid: string ]: /* replaceMid */ string; |
|
51 | [ findMid: string ]: /* replaceMid */ string; | |
52 | } |
|
52 | } | |
53 |
|
53 | |||
54 | /* dojo/AdapterRegistry */ |
|
54 | /* dojo/AdapterRegistry */ | |
55 |
|
55 | |||
56 | interface AdapterRegistry { |
|
56 | interface AdapterRegistry { | |
57 | /** |
|
57 | /** | |
58 | * register a check function to determine if the wrap function or |
|
58 | * register a check function to determine if the wrap function or | |
59 | * object gets selected |
|
59 | * object gets selected | |
60 | */ |
|
60 | */ | |
61 | register(name: string, check: (...args: any[]) => boolean, wrap: Function, directReturn?: boolean, override?: boolean): void; |
|
61 | register(name: string, check: (...args: any[]) => boolean, wrap: Function, directReturn?: boolean, override?: boolean): void; | |
62 |
|
62 | |||
63 | /** |
|
63 | /** | |
64 | * Find an adapter for the given arguments. If no suitable adapter |
|
64 | * Find an adapter for the given arguments. If no suitable adapter | |
65 | * is found, throws an exception. match() accepts any number of |
|
65 | * is found, throws an exception. match() accepts any number of | |
66 | * arguments, all of which are passed to all matching functions |
|
66 | * arguments, all of which are passed to all matching functions | |
67 | * from the registered pairs. |
|
67 | * from the registered pairs. | |
68 | */ |
|
68 | */ | |
69 | match(...args: any[]): any; |
|
69 | match(...args: any[]): any; | |
70 |
|
70 | |||
71 | /** |
|
71 | /** | |
72 | * Remove a named adapter from the registry |
|
72 | * Remove a named adapter from the registry | |
73 | */ |
|
73 | */ | |
74 | unregister(name: string): boolean; |
|
74 | unregister(name: string): boolean; | |
75 | } |
|
75 | } | |
76 |
|
76 | |||
77 | interface AdapterRegistryConstructor { |
|
77 | interface AdapterRegistryConstructor { | |
78 | new (returnWrappers?: boolean): AdapterRegistry; |
|
78 | new (returnWrappers?: boolean): AdapterRegistry; | |
79 | prototype: AdapterRegistry; |
|
79 | prototype: AdapterRegistry; | |
80 | } |
|
80 | } | |
81 |
|
81 | |||
82 | /* dojo/aspect */ |
|
82 | /* dojo/aspect */ | |
83 |
|
83 | |||
84 | interface AfterAdvice<T> { |
|
84 | interface AfterAdvice<T> { | |
85 | (result: T, ...args: any[]): T; |
|
85 | (result: T, ...args: any[]): T; | |
86 | } |
|
86 | } | |
87 |
|
87 | |||
88 | interface AroundAdvice<T> { |
|
88 | interface AroundAdvice<T> { | |
89 | (origFn: GenericFunction<T>): (...args: any[]) => T; |
|
89 | (origFn: GenericFunction<T>): (...args: any[]) => T; | |
90 | } |
|
90 | } | |
91 |
|
91 | |||
92 | interface BeforeAdvice { |
|
92 | interface BeforeAdvice { | |
93 | (...args: any[]): any[] | void; |
|
93 | (...args: any[]): any[] | void; | |
94 | } |
|
94 | } | |
95 |
|
95 | |||
96 | interface Aspect { |
|
96 | interface Aspect { | |
97 | /** |
|
97 | /** | |
98 | * The "before" export of the aspect module is a function that can be used to attach |
|
98 | * The "before" export of the aspect module is a function that can be used to attach | |
99 | * "before" advice to a method. This function will be executed before the original attach |
|
99 | * "before" advice to a method. This function will be executed before the original attach | |
100 | * is executed. This function will be called with the arguments used to call the mattach |
|
100 | * is executed. This function will be called with the arguments used to call the mattach | |
101 | * This function may optionally return an array as the new arguments to use tattach |
|
101 | * This function may optionally return an array as the new arguments to use tattach | |
102 | * the original method (or the previous, next-to-execute before advice, if one exattach |
|
102 | * the original method (or the previous, next-to-execute before advice, if one exattach | |
103 | * If the before method doesn't return anything (returns undefined) the original argattach |
|
103 | * If the before method doesn't return anything (returns undefined) the original argattach | |
104 | * will be presattach |
|
104 | * will be presattach | |
105 | * If there are multiple "before" advisors, they are executed in the reverse order they were registered. |
|
105 | * If there are multiple "before" advisors, they are executed in the reverse order they were registered. | |
106 | */ |
|
106 | */ | |
107 | before<T>(target: GenericObject, methodName: string, advice: BeforeAdvice | Function): Handle; |
|
107 | before<T>(target: GenericObject, methodName: string, advice: BeforeAdvice | Function): Handle; | |
108 |
|
108 | |||
109 | /** |
|
109 | /** | |
110 | * The "around" export of the aspect module is a function that can be used to attach |
|
110 | * The "around" export of the aspect module is a function that can be used to attach | |
111 | * "around" advice to a method. The advisor function is immediately executeattach |
|
111 | * "around" advice to a method. The advisor function is immediately executeattach | |
112 | * the around() is called, is passed a single argument that is a function that attach |
|
112 | * the around() is called, is passed a single argument that is a function that attach | |
113 | * called to continue execution of the original method (or the next around advattach |
|
113 | * called to continue execution of the original method (or the next around advattach | |
114 | * The advisor function should return a function, and this function will be called whattach |
|
114 | * The advisor function should return a function, and this function will be called whattach | |
115 | * the method is called. It will be called with the arguments used to call the mattach |
|
115 | * the method is called. It will be called with the arguments used to call the mattach | |
116 | * Whatever this function returns will be returned as the result of the method call (unless after advise changes it). |
|
116 | * Whatever this function returns will be returned as the result of the method call (unless after advise changes it). | |
117 | */ |
|
117 | */ | |
118 | around<T>(target: GenericObject, methodName: string, advice: AroundAdvice<T> | Function): Handle; |
|
118 | around<T>(target: GenericObject, methodName: string, advice: AroundAdvice<T> | Function): Handle; | |
119 |
|
119 | |||
120 | /** |
|
120 | /** | |
121 | * The "after" export of the aspect module is a function that can be used to attach |
|
121 | * The "after" export of the aspect module is a function that can be used to attach | |
122 | * "after" advice to a method. This function will be executed after the original method |
|
122 | * "after" advice to a method. This function will be executed after the original method | |
123 | * is executed. By default the function will be called with a single argument, the return |
|
123 | * is executed. By default the function will be called with a single argument, the return | |
124 | * value of the original method, or the the return value of the last executed advice (if a previous one exists). |
|
124 | * value of the original method, or the the return value of the last executed advice (if a previous one exists). | |
125 | * The fourth (optional) argument can be set to true to so the function receives the original |
|
125 | * The fourth (optional) argument can be set to true to so the function receives the original | |
126 | * arguments (from when the original method was called) rather than the return value. |
|
126 | * arguments (from when the original method was called) rather than the return value. | |
127 | * If there are multiple "after" advisors, they are executed in the order they were registered. |
|
127 | * If there are multiple "after" advisors, they are executed in the order they were registered. | |
128 | */ |
|
128 | */ | |
129 | after<T>(target: GenericObject, methodName: string, advice: AfterAdvice<T> | Function, receiveArguments?: boolean): Handle; |
|
129 | after<T>(target: GenericObject, methodName: string, advice: AfterAdvice<T> | Function, receiveArguments?: boolean): Handle; | |
130 | } |
|
130 | } | |
131 |
|
131 | |||
132 | /* dojo/back */ |
|
132 | /* dojo/back */ | |
133 |
|
133 | |||
134 | interface BackArgs { |
|
134 | interface BackArgs { | |
135 | back?: GenericFunction<void>; |
|
135 | back?: GenericFunction<void>; | |
136 | forward?: GenericFunction<void>; |
|
136 | forward?: GenericFunction<void>; | |
137 | changeUrl?: boolean | string; |
|
137 | changeUrl?: boolean | string; | |
138 | } |
|
138 | } | |
139 |
|
139 | |||
140 | interface Back { |
|
140 | interface Back { | |
141 | getHash(): string; |
|
141 | getHash(): string; | |
142 | setHash(h: string): void; |
|
142 | setHash(h: string): void; | |
143 |
|
143 | |||
144 | /** |
|
144 | /** | |
145 | * private method. Do not call this directly. |
|
145 | * private method. Do not call this directly. | |
146 | */ |
|
146 | */ | |
147 | goBack(): void; |
|
147 | goBack(): void; | |
148 |
|
148 | |||
149 | /** |
|
149 | /** | |
150 | * private method. Do not call this directly. |
|
150 | * private method. Do not call this directly. | |
151 | */ |
|
151 | */ | |
152 | goForward(): void; |
|
152 | goForward(): void; | |
153 |
|
153 | |||
154 | /** |
|
154 | /** | |
155 | * Initializes the undo stack. This must be called from a <script> |
|
155 | * Initializes the undo stack. This must be called from a <script> | |
156 | * block that lives inside the `<body>` tag to prevent bugs on IE. |
|
156 | * block that lives inside the `<body>` tag to prevent bugs on IE. | |
157 | * Only call this method before the page's DOM is finished loading. Otherwise |
|
157 | * Only call this method before the page's DOM is finished loading. Otherwise | |
158 | * it will not work. Be careful with xdomain loading or djConfig.debugAtAllCosts scenarios, |
|
158 | * it will not work. Be careful with xdomain loading or djConfig.debugAtAllCosts scenarios, | |
159 | * in order for this method to work, dojo/back will need to be part of a build layer. |
|
159 | * in order for this method to work, dojo/back will need to be part of a build layer. | |
160 | */ |
|
160 | */ | |
161 | init(): void; |
|
161 | init(): void; | |
162 |
|
162 | |||
163 | /** |
|
163 | /** | |
164 | * Sets the state object and back callback for the very first page |
|
164 | * Sets the state object and back callback for the very first page | |
165 | * that is loaded. |
|
165 | * that is loaded. | |
166 | * It is recommended that you call this method as part of an event |
|
166 | * It is recommended that you call this method as part of an event | |
167 | * listener that is registered via dojo/ready. |
|
167 | * listener that is registered via dojo/ready. | |
168 | */ |
|
168 | */ | |
169 | setInitialState(args: BackArgs): void; |
|
169 | setInitialState(args: BackArgs): void; | |
170 |
|
170 | |||
171 | /** |
|
171 | /** | |
172 | * adds a state object (args) to the history list. |
|
172 | * adds a state object (args) to the history list. | |
173 | */ |
|
173 | */ | |
174 | addToHistory(args: BackArgs): void; |
|
174 | addToHistory(args: BackArgs): void; | |
175 |
|
175 | |||
176 | /** |
|
176 | /** | |
177 | * private method. Do not call this directly. |
|
177 | * private method. Do not call this directly. | |
178 | */ |
|
178 | */ | |
179 | _iframeLoaded(evt: Event, ifrLoc: Location): void; |
|
179 | _iframeLoaded(evt: Event, ifrLoc: Location): void; | |
180 | } |
|
180 | } | |
181 |
|
181 | |||
182 | /* dojo/behavior */ |
|
182 | /* dojo/behavior */ | |
183 |
|
183 | |||
184 | interface Behavior { |
|
184 | interface Behavior { | |
185 | _behaviors: { [selector: string]: any }; |
|
185 | _behaviors: { [selector: string]: any }; | |
186 |
|
186 | |||
187 | /** |
|
187 | /** | |
188 | * Add the specified behavior to the list of behaviors, ignoring existing |
|
188 | * Add the specified behavior to the list of behaviors, ignoring existing | |
189 | * matches. |
|
189 | * matches. | |
190 | */ |
|
190 | */ | |
191 | add(behaviorObject: { [selector: string]: any }): void; |
|
191 | add(behaviorObject: { [selector: string]: any }): void; | |
192 |
|
192 | |||
193 | /** |
|
193 | /** | |
194 | * Applies all currently registered behaviors to the document. |
|
194 | * Applies all currently registered behaviors to the document. | |
195 | */ |
|
195 | */ | |
196 | apply(): void; |
|
196 | apply(): void; | |
197 | } |
|
197 | } | |
198 |
|
198 | |||
199 | /* dojo/cookie */ |
|
199 | /* dojo/cookie */ | |
200 |
|
200 | |||
201 | interface CookieProps { |
|
201 | interface CookieProps { | |
202 | expires?: Date | string | number; |
|
202 | expires?: Date | string | number; | |
203 | path?: string; |
|
203 | path?: string; | |
204 | domain?: string; |
|
204 | domain?: string; | |
205 | secure?: boolean; |
|
205 | secure?: boolean; | |
206 | } |
|
206 | } | |
207 |
|
207 | |||
208 | interface Cookie { |
|
208 | interface Cookie { | |
209 | /* Get or set a cookie. */ |
|
209 | /* Get or set a cookie. */ | |
210 | (name: string, value?: string, props?: CookieProps): string; |
|
210 | (name: string, value?: string, props?: CookieProps): string; | |
211 |
|
211 | |||
212 | /** |
|
212 | /** | |
213 | * Use to determine if the current browser supports cookies or not. |
|
213 | * Use to determine if the current browser supports cookies or not. | |
214 | */ |
|
214 | */ | |
215 | isSupported(): boolean; |
|
215 | isSupported(): boolean; | |
216 | } |
|
216 | } | |
217 |
|
217 | |||
218 | /* dojo/currency */ |
|
218 | /* dojo/currency */ | |
219 |
|
219 | |||
220 | interface CurrencyFormatOptions extends NumberFormatOptions { |
|
220 | interface CurrencyFormatOptions extends NumberFormatOptions { | |
221 |
|
221 | |||
222 | /** |
|
222 | /** | |
223 | * Should not be set. Value is assumed to be "currency". |
|
223 | * Should not be set. Value is assumed to be "currency". | |
224 | */ |
|
224 | */ | |
225 | type?: string; |
|
225 | type?: string; | |
226 |
|
226 | |||
227 | /** |
|
227 | /** | |
228 | * localized currency symbol. The default will be looked up in table of supported currencies in `dojo.cldr` |
|
228 | * localized currency symbol. The default will be looked up in table of supported currencies in `dojo.cldr` | |
229 | * A [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code will be used if not found. |
|
229 | * A [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code will be used if not found. | |
230 | */ |
|
230 | */ | |
231 | symbol?: string; |
|
231 | symbol?: string; | |
232 |
|
232 | |||
233 | /** |
|
233 | /** | |
234 | * an [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code, a three letter sequence like "USD". |
|
234 | * an [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code, a three letter sequence like "USD". | |
235 | * For use with dojo.currency only. |
|
235 | * For use with dojo.currency only. | |
236 | */ |
|
236 | */ | |
237 | currency?: string; |
|
237 | currency?: string; | |
238 |
|
238 | |||
239 | /** |
|
239 | /** | |
240 | * number of decimal places to show. Default is defined based on which currency is used. |
|
240 | * number of decimal places to show. Default is defined based on which currency is used. | |
241 | */ |
|
241 | */ | |
242 | places?: number; |
|
242 | places?: number; | |
243 | } |
|
243 | } | |
244 |
|
244 | |||
245 | interface CurrencyParseOptions extends NumberParseOptions { |
|
245 | interface CurrencyParseOptions extends NumberParseOptions { | |
246 |
|
246 | |||
247 | /** |
|
247 | /** | |
248 | * Should not be set. Value is assumed to be "currency". |
|
248 | * Should not be set. Value is assumed to be "currency". | |
249 | */ |
|
249 | */ | |
250 | type?: string; |
|
250 | type?: string; | |
251 |
|
251 | |||
252 | /** |
|
252 | /** | |
253 | * localized currency symbol. The default will be looked up in table of supported currencies in `dojo.cldr` |
|
253 | * localized currency symbol. The default will be looked up in table of supported currencies in `dojo.cldr` | |
254 | * A [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code will be used if not found. |
|
254 | * A [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code will be used if not found. | |
255 | */ |
|
255 | */ | |
256 | symbol?: string; |
|
256 | symbol?: string; | |
257 |
|
257 | |||
258 | /** |
|
258 | /** | |
259 | * an [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code, a three letter sequence like "USD". |
|
259 | * an [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code, a three letter sequence like "USD". | |
260 | * For use with dojo.currency only. |
|
260 | * For use with dojo.currency only. | |
261 | */ |
|
261 | */ | |
262 | currency?: string; |
|
262 | currency?: string; | |
263 |
|
263 | |||
264 | /** |
|
264 | /** | |
265 | * number of decimal places to show. Default is defined based on which currency is used. |
|
265 | * number of decimal places to show. Default is defined based on which currency is used. | |
266 | */ |
|
266 | */ | |
267 | places?: number; |
|
267 | places?: number; | |
268 |
|
268 | |||
269 | /** |
|
269 | /** | |
270 | * Whether to include the fractional portion, where the number of decimal places are implied by the currency |
|
270 | * Whether to include the fractional portion, where the number of decimal places are implied by the currency | |
271 | * or explicit 'places' parameter. The value [true,false] makes the fractional portion optional. |
|
271 | * or explicit 'places' parameter. The value [true,false] makes the fractional portion optional. | |
272 | * By default for currencies, it the fractional portion is optional. |
|
272 | * By default for currencies, it the fractional portion is optional. | |
273 | */ |
|
273 | */ | |
274 | fractional?: boolean | [boolean, boolean]; |
|
274 | fractional?: boolean | [boolean, boolean]; | |
275 | } |
|
275 | } | |
276 |
|
276 | |||
277 | interface Currency { |
|
277 | interface Currency { | |
278 | _mixInDefaults(options: NumberFormatOptions): CurrencyFormatOptions; |
|
278 | _mixInDefaults(options: NumberFormatOptions): CurrencyFormatOptions; | |
279 |
|
279 | |||
280 | /** |
|
280 | /** | |
281 | * Format a Number as a currency, using locale-specific settings |
|
281 | * Format a Number as a currency, using locale-specific settings | |
282 | */ |
|
282 | */ | |
283 | format(value: number, options?: CurrencyFormatOptions): string; |
|
283 | format(value: number, options?: CurrencyFormatOptions): string; | |
284 |
|
284 | |||
285 | /** |
|
285 | /** | |
286 | * Builds the regular needed to parse a currency value |
|
286 | * Builds the regular needed to parse a currency value | |
287 | */ |
|
287 | */ | |
288 | regexp(options?: NumberRegexpOptions): string; |
|
288 | regexp(options?: NumberRegexpOptions): string; | |
289 |
|
289 | |||
290 | /** |
|
290 | /** | |
291 | * Convert a properly formatted currency string to a primitive Number, |
|
291 | * Convert a properly formatted currency string to a primitive Number, | |
292 | * using locale-specific settings. |
|
292 | * using locale-specific settings. | |
293 | */ |
|
293 | */ | |
294 | parse(expression: string, options?: CurrencyParseOptions): number; |
|
294 | parse(expression: string, options?: CurrencyParseOptions): number; | |
295 | } |
|
295 | } | |
296 |
|
296 | |||
297 | /* dojo/debounce */ |
|
297 | /* dojo/debounce */ | |
298 |
|
298 | |||
299 | interface Debounce { |
|
299 | interface Debounce { | |
300 | /** |
|
300 | /** | |
301 | * Create a function that will only execute after `wait` milliseconds |
|
301 | * Create a function that will only execute after `wait` milliseconds | |
302 | */ |
|
302 | */ | |
303 | <T extends Function>(cb: T, wait: number): T; |
|
303 | <T extends Function>(cb: T, wait: number): T; | |
304 | <T extends Function>(cb: Function, wait: number, ...args: any[]): T; |
|
304 | <T extends Function>(cb: Function, wait: number, ...args: any[]): T; | |
305 | } |
|
305 | } | |
306 |
|
306 | |||
307 | /* dojo/Deferred */ |
|
307 | /* dojo/Deferred */ | |
308 |
|
308 | |||
309 | interface Deferred<T> { |
|
309 | interface Deferred<T> { | |
310 |
|
310 | |||
311 | /** |
|
311 | /** | |
312 | * The public promise object that clients can add callbacks to. |
|
312 | * The public promise object that clients can add callbacks to. | |
313 | */ |
|
313 | */ | |
314 | promise: promise.Promise<T>; |
|
314 | promise: promise.Promise<T>; | |
315 |
|
315 | |||
316 | /** |
|
316 | /** | |
317 | * Checks whether the deferred has been resolved. |
|
317 | * Checks whether the deferred has been resolved. | |
318 | */ |
|
318 | */ | |
319 | isResolved(): boolean; |
|
319 | isResolved(): boolean; | |
320 |
|
320 | |||
321 | /** |
|
321 | /** | |
322 | * Checks whether the deferred has been rejected. |
|
322 | * Checks whether the deferred has been rejected. | |
323 | */ |
|
323 | */ | |
324 | isRejected(): boolean; |
|
324 | isRejected(): boolean; | |
325 |
|
325 | |||
326 | /** |
|
326 | /** | |
327 | * Checks whether the deferred has been resolved or rejected. |
|
327 | * Checks whether the deferred has been resolved or rejected. | |
328 | */ |
|
328 | */ | |
329 | isFulfilled(): boolean; |
|
329 | isFulfilled(): boolean; | |
330 |
|
330 | |||
331 | /** |
|
331 | /** | |
332 | * Checks whether the deferred has been canceled. |
|
332 | * Checks whether the deferred has been canceled. | |
333 | */ |
|
333 | */ | |
334 | isCanceled(): boolean; |
|
334 | isCanceled(): boolean; | |
335 |
|
335 | |||
336 | /** |
|
336 | /** | |
337 | * Emit a progress update on the deferred. |
|
337 | * Emit a progress update on the deferred. | |
338 | */ |
|
338 | */ | |
339 | progress(update: any, strict?: boolean): promise.Promise<T>; |
|
339 | progress(update: any, strict?: boolean): promise.Promise<T>; | |
340 |
|
340 | |||
341 | /** |
|
341 | /** | |
342 | * Resolve the deferred. |
|
342 | * Resolve the deferred. | |
343 | */ |
|
343 | */ | |
344 | resolve(value?: T, strict?: boolean): promise.Promise<T>; |
|
344 | resolve(value?: T, strict?: boolean): promise.Promise<T>; | |
345 |
|
345 | |||
346 | /** |
|
346 | /** | |
347 | * Reject the deferred. |
|
347 | * Reject the deferred. | |
348 | */ |
|
348 | */ | |
349 | reject(error?: any, strict?: boolean): promise.Promise<T>; |
|
349 | reject(error?: any, strict?: boolean): promise.Promise<T>; | |
350 |
|
350 | |||
351 | /** |
|
351 | /** | |
352 | * Add new callbacks to the deferred. |
|
352 | * Add new callbacks to the deferred. | |
353 | */ |
|
353 | */ | |
354 | then<U>(callback?: promise.PromiseCallback<T, U>, errback?: promise.PromiseErrback<U>, progback?: promise.PromiseProgback): promise.Promise<U>; |
|
354 | then<U>(callback?: promise.PromiseCallback<T, U>, errback?: promise.PromiseErrback<U>, progback?: promise.PromiseProgback): promise.Promise<U>; | |
355 |
|
355 | |||
356 | /** |
|
356 | /** | |
357 | * Inform the deferred it may cancel its asynchronous operation. |
|
357 | * Inform the deferred it may cancel its asynchronous operation. | |
358 | */ |
|
358 | */ | |
359 | cancel(reason?: any, strict?: boolean): any; |
|
359 | cancel(reason?: any, strict?: boolean): any; | |
360 |
|
360 | |||
361 | /** |
|
361 | /** | |
362 | * Returns `[object Deferred]`. |
|
362 | * Returns `[object Deferred]`. | |
363 | */ |
|
363 | */ | |
364 | toString(): string; |
|
364 | toString(): string; | |
365 | } |
|
365 | } | |
366 |
|
366 | |||
367 | interface DeferredConstructor { |
|
367 | interface DeferredConstructor { | |
368 | /** |
|
368 | /** | |
369 | * Creates a new deferred. This API is preferred over |
|
369 | * Creates a new deferred. This API is preferred over | |
370 | * `dojo/_base/Deferred`. |
|
370 | * `dojo/_base/Deferred`. | |
371 | */ |
|
371 | */ | |
372 | new <T>(canceller?: (reason: any) => void): Deferred<T>; |
|
372 | new <T>(canceller?: (reason: any) => void): Deferred<T>; | |
373 | prototype: Deferred<any>; |
|
373 | prototype: Deferred<any>; | |
374 | } |
|
374 | } | |
375 |
|
375 | |||
376 | /* dojo/DeferredList */ |
|
376 | /* dojo/DeferredList */ | |
377 |
|
377 | |||
378 | interface DeferredList<T> extends Deferred<T[]> { |
|
378 | interface DeferredList<T> extends Deferred<T[]> { | |
379 | /** |
|
379 | /** | |
380 | * Gathers the results of the deferreds for packaging |
|
380 | * Gathers the results of the deferreds for packaging | |
381 | * as the parameters to the Deferred Lists' callback |
|
381 | * as the parameters to the Deferred Lists' callback | |
382 | */ |
|
382 | */ | |
383 | gatherResults<T>(deferredList: DeferredList<any>): DeferredList<T>; |
|
383 | gatherResults<T>(deferredList: DeferredList<any>): DeferredList<T>; | |
384 | } |
|
384 | } | |
385 |
|
385 | |||
386 | interface DeferredListConstructor { |
|
386 | interface DeferredListConstructor { | |
387 | /** |
|
387 | /** | |
388 | * Deprecated, use dojo/promise/all instead. |
|
388 | * Deprecated, use dojo/promise/all instead. | |
389 | * Provides event handling for a group of Deferred objects. |
|
389 | * Provides event handling for a group of Deferred objects. | |
390 | */ |
|
390 | */ | |
391 | new <T>(list: T[], fireOnOneCallback?: boolean, fireOnOneErrback?: boolean, consumeErrors?: boolean, canceller?: (reason: any) => void): DeferredList<T>; |
|
391 | new <T>(list: T[], fireOnOneCallback?: boolean, fireOnOneErrback?: boolean, consumeErrors?: boolean, canceller?: (reason: any) => void): DeferredList<T>; | |
392 | prototype: DeferredList<any>; |
|
392 | prototype: DeferredList<any>; | |
393 | } |
|
393 | } | |
394 |
|
394 | |||
395 | /* dojo/dojo */ |
|
395 | /* dojo/dojo */ | |
396 |
|
396 | |||
397 | interface RequireTrace { |
|
397 | interface RequireTrace { | |
398 | (group: string, args: any[]): void; |
|
398 | (group: string, args: any[]): void; | |
399 | on: boolean | number; |
|
399 | on: boolean | number; | |
400 | group: GenericObject; |
|
400 | group: GenericObject; | |
401 | set(group: string | GenericObject, value: any): void; |
|
401 | set(group: string | GenericObject, value: any): void; | |
402 | } |
|
402 | } | |
403 |
|
403 | |||
404 | interface Require { |
|
404 | interface Require { | |
405 | (config: GenericObject, dependencies: string[], callback?: GenericFunction<void>): Require; |
|
405 | (config: GenericObject, dependencies: string[], callback?: GenericFunction<void>): Require; | |
406 | (dependencies: string[], callback: GenericFunction<void>): Require; |
|
406 | (dependencies: string[], callback: GenericFunction<void>): Require; | |
407 | async: number| boolean; |
|
407 | async: number| boolean; | |
408 | has: dojo.Has; |
|
408 | has: dojo.Has; | |
409 | isXdurl(url: string): boolean; |
|
409 | isXdurl(url: string): boolean; | |
410 | initSyncLoader(dojoRequirePlugin: any, checkDojoRequirePlugin: any, transformToAmd: any): GenericObject; |
|
410 | initSyncLoader(dojoRequirePlugin: any, checkDojoRequirePlugin: any, transformToAmd: any): GenericObject; | |
411 | getXhr(): XMLHttpRequest | ActiveXObject; |
|
411 | getXhr(): XMLHttpRequest | ActiveXObject; | |
412 | getText(url: string, async?: boolean, onLoad?: (responseText: string, async?: boolean) => void): string; |
|
412 | getText(url: string, async?: boolean, onLoad?: (responseText: string, async?: boolean) => void): string; | |
413 | eval(text: string, hint?: string): any; |
|
413 | eval(text: string, hint?: string): any; | |
414 | signal(type: string, args: any[]): void; |
|
414 | signal(type: string, args: any[]): void; | |
415 | on(type: string, listener: (...args: any[]) => void): Handle; |
|
415 | on(type: string, listener: (...args: any[]) => void): Handle; | |
416 | map: { [id: string]: any }; |
|
416 | map: { [id: string]: any }; | |
417 | waitms?: number; |
|
417 | waitms?: number; | |
418 | legacyMode: boolean; |
|
418 | legacyMode: boolean; | |
419 | rawConfig: dojo._base.Config; |
|
419 | rawConfig: dojo._base.Config; | |
420 | baseUrl: string; |
|
420 | baseUrl: string; | |
421 | combo?: { |
|
421 | combo?: { | |
422 | add: () => void; |
|
422 | add: () => void; | |
423 | done(callback: (mids: string[], url?: string) => void, req: Require): void; |
|
423 | done(callback: (mids: string[], url?: string) => void, req: Require): void; | |
424 | plugins?: GenericObject; |
|
424 | plugins?: GenericObject; | |
425 | }; |
|
425 | }; | |
426 | idle(): boolean; |
|
426 | idle(): boolean; | |
427 | toAbsMid(mid: string, referenceModule?: string): string; |
|
427 | toAbsMid(mid: string, referenceModule?: string): string; | |
428 | toUrl(name: string, referenceModule?: string): string; |
|
428 | toUrl(name: string, referenceModule?: string): string; | |
429 | undef(moduleId: string, referenceModule?: string): void; |
|
429 | undef(moduleId: string, referenceModule?: string): void; | |
430 | pageLoaded: number | boolean; |
|
430 | pageLoaded: number | boolean; | |
431 | injectUrl(url: string, callback?: () => void, owner?: HTMLScriptElement): HTMLScriptElement; |
|
431 | injectUrl(url: string, callback?: () => void, owner?: HTMLScriptElement): HTMLScriptElement; | |
432 | log(...args: any[]): void; |
|
432 | log(...args: any[]): void; | |
433 | trace: RequireTrace; |
|
433 | trace: RequireTrace; | |
434 | boot?: [string[], Function] | number; |
|
434 | boot?: [string[], Function] | number; | |
435 | } |
|
435 | } | |
436 |
|
436 | |||
437 | interface Define { |
|
437 | interface Define { | |
438 | (mid: string, dependencies?: string[], factory?: any): void; |
|
438 | (mid: string, dependencies?: string[], factory?: any): void; | |
439 | (dependencies: string[], factory?: any): void; |
|
439 | (dependencies: string[], factory?: any): void; | |
440 | amd: string; |
|
440 | amd: string; | |
441 | } |
|
441 | } | |
442 |
|
442 | |||
443 | /* dojo/dom */ |
|
443 | /* dojo/dom */ | |
444 |
|
444 | |||
445 | interface Dom { |
|
445 | interface Dom { | |
446 | /** |
|
446 | /** | |
447 | * Returns DOM node with matching `id` attribute or falsy value (ex: null or undefined) |
|
447 | * Returns DOM node with matching `id` attribute or falsy value (ex: null or undefined) | |
448 | * if not found. Internally if `id` is not a string then `id` returned. |
|
448 | * if not found. Internally if `id` is not a string then `id` returned. | |
449 | */ |
|
449 | */ | |
450 | byId<E extends Element>(id: string | E, doc?: Document): E; |
|
450 | byId<E extends Element>(id: string | E, doc?: Document): E; | |
451 |
|
451 | |||
452 | /** |
|
452 | /** | |
453 | * Returns true if node is a descendant of ancestor |
|
453 | * Returns true if node is a descendant of ancestor | |
454 | */ |
|
454 | */ | |
455 | isDescendant(node: NodeOrString, ancestor: NodeOrString): boolean; |
|
455 | isDescendant(node: NodeOrString, ancestor: NodeOrString): boolean; | |
456 |
|
456 | |||
457 | /** |
|
457 | /** | |
458 | * Enable or disable selection on a node |
|
458 | * Enable or disable selection on a node | |
459 | */ |
|
459 | */ | |
460 | setSelectable(node: ElementOrString, selectable?: boolean): void; |
|
460 | setSelectable(node: ElementOrString, selectable?: boolean): void; | |
461 | } |
|
461 | } | |
462 |
|
462 | |||
463 | /* dojo/dom-attr */ |
|
463 | /* dojo/dom-attr */ | |
464 |
|
464 | |||
465 | interface DomAttr { |
|
465 | interface DomAttr { | |
466 | /** |
|
466 | /** | |
467 | * Returns true if the requested attribute is specified on the |
|
467 | * Returns true if the requested attribute is specified on the | |
468 | * given element, and false otherwise. |
|
468 | * given element, and false otherwise. | |
469 | */ |
|
469 | */ | |
470 | has(node: NodeOrString, name: string): boolean; |
|
470 | has(node: NodeOrString, name: string): boolean; | |
471 |
|
471 | |||
472 | /** |
|
472 | /** | |
473 | * Gets an attribute on an HTML element. |
|
473 | * Gets an attribute on an HTML element. | |
474 | * Because sometimes this uses node.getAttribute, it should be a string, |
|
474 | * Because sometimes this uses node.getAttribute, it should be a string, | |
475 | * but it can also get any other attribute on a node, therefore it is unsafe |
|
475 | * but it can also get any other attribute on a node, therefore it is unsafe | |
476 | * to type just a string. |
|
476 | * to type just a string. | |
477 | */ |
|
477 | */ | |
478 | get(node: ElementOrString, name: string): any; |
|
478 | get(node: ElementOrString, name: string): any; | |
479 |
|
479 | |||
480 | /** |
|
480 | /** | |
481 | * Sets an attribute on an HTML element. |
|
481 | * Sets an attribute on an HTML element. | |
482 | */ |
|
482 | */ | |
483 | set(node: ElementOrString, name: string, value: any): Element; |
|
483 | set(node: ElementOrString, name: string, value: any): Element; | |
484 | set(node: ElementOrString, map: GenericObject): Element; |
|
484 | set(node: ElementOrString, map: GenericObject): Element; | |
485 |
|
485 | |||
486 | /** |
|
486 | /** | |
487 | * Removes an attribute from an HTML element. |
|
487 | * Removes an attribute from an HTML element. | |
488 | */ |
|
488 | */ | |
489 | remove(node: NodeOrString, name: string): void; |
|
489 | remove(node: NodeOrString, name: string): void; | |
490 |
|
490 | |||
491 | /** |
|
491 | /** | |
492 | * Returns an effective value of a property or an attribute. |
|
492 | * Returns an effective value of a property or an attribute. | |
493 | */ |
|
493 | */ | |
494 | getNodeProp(node: NodeOrString, name: string): any; |
|
494 | getNodeProp(node: NodeOrString, name: string): any; | |
495 | } |
|
495 | } | |
496 |
|
496 | |||
497 | /* dojo/dom-class */ |
|
497 | /* dojo/dom-class */ | |
498 |
|
498 | |||
499 | interface DomClass { |
|
499 | interface DomClass { | |
500 |
|
500 | |||
501 | /** |
|
501 | /** | |
502 | * Returns whether or not the specified classes are a portion of the |
|
502 | * Returns whether or not the specified classes are a portion of the | |
503 | * class list currently applied to the node. |
|
503 | * class list currently applied to the node. | |
504 | */ |
|
504 | */ | |
505 | contains(node: NodeOrString, classStr: string): boolean; |
|
505 | contains(node: NodeOrString, classStr: string): boolean; | |
506 |
|
506 | |||
507 | /** |
|
507 | /** | |
508 | * Adds the specified classes to the end of the class list on the |
|
508 | * Adds the specified classes to the end of the class list on the | |
509 | * passed node. Will not re-apply duplicate classes. |
|
509 | * passed node. Will not re-apply duplicate classes. | |
510 | */ |
|
510 | */ | |
511 | add(node: NodeOrString, classStr: string | string[]): void; |
|
511 | add(node: NodeOrString, classStr: string | string[]): void; | |
512 |
|
512 | |||
513 | /** |
|
513 | /** | |
514 | * Removes the specified classes from node. No `contains()` |
|
514 | * Removes the specified classes from node. No `contains()` | |
515 | * check is required. |
|
515 | * check is required. | |
516 | */ |
|
516 | */ | |
517 | remove(node: NodeOrString, classStr?: string | string[]): void; |
|
517 | remove(node: NodeOrString, classStr?: string | string[]): void; | |
518 |
|
518 | |||
519 | /** |
|
519 | /** | |
520 | * Replaces one or more classes on a node if not present. |
|
520 | * Replaces one or more classes on a node if not present. | |
521 | * Operates more quickly than calling dojo.removeClass and dojo.addClass |
|
521 | * Operates more quickly than calling dojo.removeClass and dojo.addClass | |
522 | */ |
|
522 | */ | |
523 | replace(node: NodeOrString, addClassStr: string | string[], removeClassStr?: string | string[]): void; |
|
523 | replace(node: NodeOrString, addClassStr: string | string[], removeClassStr?: string | string[]): void; | |
524 |
|
524 | |||
525 | /** |
|
525 | /** | |
526 | * Adds a class to node if not present, or removes if present. |
|
526 | * Adds a class to node if not present, or removes if present. | |
527 | * Pass a boolean condition if you want to explicitly add or remove. |
|
527 | * Pass a boolean condition if you want to explicitly add or remove. | |
528 | * Returns the condition that was specified directly or indirectly. |
|
528 | * Returns the condition that was specified directly or indirectly. | |
529 | */ |
|
529 | */ | |
530 | toggle(node: NodeOrString, classStr: string | string[], condition?: boolean): boolean; |
|
530 | toggle(node: NodeOrString, classStr: string | string[], condition?: boolean): boolean; | |
531 | } |
|
531 | } | |
532 |
|
532 | |||
533 | /* dojo/dom-construct */ |
|
533 | /* dojo/dom-construct */ | |
534 |
|
534 | |||
535 | /* TODO implement for TS 1.8 */ |
|
535 | /* TODO implement for TS 1.8 */ | |
536 | /* type PosString = 'first' | 'after' | 'before' | 'last' | 'replace' | 'only'; */ |
|
536 | /* type PosString = 'first' | 'after' | 'before' | 'last' | 'replace' | 'only'; */ | |
537 |
|
537 | |||
538 | interface DomConstruct { |
|
538 | interface DomConstruct { | |
539 |
|
539 | |||
540 | /** |
|
540 | /** | |
541 | * instantiates an HTML fragment returning the corresponding DOM. |
|
541 | * instantiates an HTML fragment returning the corresponding DOM. | |
542 | */ |
|
542 | */ | |
543 | toDom(frag: string, doc?: Document): DocumentFragment | Node; |
|
543 | toDom(frag: string, doc?: Document): DocumentFragment | Node; | |
544 |
|
544 | |||
545 | /** |
|
545 | /** | |
546 | * Attempt to insert node into the DOM, choosing from various positioning options. |
|
546 | * Attempt to insert node into the DOM, choosing from various positioning options. | |
547 | * Returns the first argument resolved to a DOM node. |
|
547 | * Returns the first argument resolved to a DOM node. | |
548 | */ |
|
548 | */ | |
549 | place(node: NodeFragmentOrString, refNode: NodeOrString, position?: string /* PosString */ | number): HTMLElement; |
|
549 | place(node: NodeFragmentOrString, refNode: NodeOrString, position?: string /* PosString */ | number): HTMLElement; | |
550 |
|
550 | |||
551 | /** |
|
551 | /** | |
552 | * Create an element, allowing for optional attribute decoration |
|
552 | * Create an element, allowing for optional attribute decoration | |
553 | * and placement. |
|
553 | * and placement. | |
554 | */ |
|
554 | */ | |
555 | create(tag: NodeOrString, attrs?: GenericObject, refNode?: NodeOrString, pos?: string /* PosString */ | number): HTMLElement; |
|
555 | create(tag: NodeOrString, attrs?: GenericObject, refNode?: NodeOrString, pos?: string /* PosString */ | number): HTMLElement; | |
556 |
|
556 | |||
557 | /** |
|
557 | /** | |
558 | * safely removes all children of the node. |
|
558 | * safely removes all children of the node. | |
559 | */ |
|
559 | */ | |
560 | empty(node: NodeOrString): void; |
|
560 | empty(node: NodeOrString): void; | |
561 |
|
561 | |||
562 | /** |
|
562 | /** | |
563 | * Removes a node from its parent, clobbering it and all of its |
|
563 | * Removes a node from its parent, clobbering it and all of its | |
564 | * children. |
|
564 | * children. | |
565 | */ |
|
565 | */ | |
566 | destroy(node: NodeOrString): void; |
|
566 | destroy(node: NodeOrString): void; | |
567 | } |
|
567 | } | |
568 |
|
568 | |||
569 | /* dojo/dom-form */ |
|
569 | /* dojo/dom-form */ | |
570 |
|
570 | |||
571 | interface DomForm { |
|
571 | interface DomForm { | |
572 | /** |
|
572 | /** | |
573 | * Serialize a form field to a JavaScript object. |
|
573 | * Serialize a form field to a JavaScript object. | |
574 | */ |
|
574 | */ | |
575 | fieldToObject(inputNode: NodeOrString): GenericObject; |
|
575 | fieldToObject(inputNode: NodeOrString): GenericObject; | |
576 |
|
576 | |||
577 | /** |
|
577 | /** | |
578 | * Serialize a form node to a JavaScript object. |
|
578 | * Serialize a form node to a JavaScript object. | |
579 | */ |
|
579 | */ | |
580 | toObject(fromNode: HTMLFormElement | string): GenericObject; |
|
580 | toObject(fromNode: HTMLFormElement | string): GenericObject; | |
581 |
|
581 | |||
582 | /** |
|
582 | /** | |
583 | * Returns a URL-encoded string representing the form passed as either a |
|
583 | * Returns a URL-encoded string representing the form passed as either a | |
584 | * node or string ID identifying the form to serialize |
|
584 | * node or string ID identifying the form to serialize | |
585 | */ |
|
585 | */ | |
586 | toQuery(fromNode: HTMLFormElement | string): string; |
|
586 | toQuery(fromNode: HTMLFormElement | string): string; | |
587 |
|
587 | |||
588 | /** |
|
588 | /** | |
589 | * Create a serialized JSON string from a form node or string |
|
589 | * Create a serialized JSON string from a form node or string | |
590 | * ID identifying the form to serialize |
|
590 | * ID identifying the form to serialize | |
591 | */ |
|
591 | */ | |
592 | toJson(formNode: HTMLFormElement | string, prettyPrint?: boolean): string; |
|
592 | toJson(formNode: HTMLFormElement | string, prettyPrint?: boolean): string; | |
593 | } |
|
593 | } | |
594 |
|
594 | |||
595 | /* dojo/dom-geometry */ |
|
595 | /* dojo/dom-geometry */ | |
596 |
|
596 | |||
597 | interface DomGeometryWidthHeight { |
|
597 | interface DomGeometryWidthHeight { | |
598 | w?: number; |
|
598 | w?: number; | |
599 | h?: number; |
|
599 | h?: number; | |
600 | } |
|
600 | } | |
601 |
|
601 | |||
602 | interface DomGeometryBox extends DomGeometryWidthHeight { |
|
602 | interface DomGeometryBox extends DomGeometryWidthHeight { | |
603 | l?: number; |
|
603 | l?: number; | |
604 | t?: number; |
|
604 | t?: number; | |
605 | } |
|
605 | } | |
606 |
|
606 | |||
607 | interface DomGeometryBoxExtents extends DomGeometryBox { |
|
607 | interface DomGeometryBoxExtents extends DomGeometryBox { | |
608 | r?: number; |
|
608 | r?: number; | |
609 | b?: number; |
|
609 | b?: number; | |
610 | } |
|
610 | } | |
611 |
|
611 | |||
612 | interface Point { |
|
612 | interface Point { | |
613 | x: number; |
|
613 | x: number; | |
614 | y: number; |
|
614 | y: number; | |
615 | } |
|
615 | } | |
616 |
|
616 | |||
617 | interface DomGeometryXYBox extends DomGeometryWidthHeight, Point { |
|
617 | interface DomGeometryXYBox extends DomGeometryWidthHeight, Point { | |
618 | } |
|
618 | } | |
619 |
|
619 | |||
620 | interface DomGeometry { |
|
620 | interface DomGeometry { | |
621 | boxModel: string; /* TODO: string literal 'border-box' | 'content-box' */ |
|
621 | boxModel: string; /* TODO: string literal 'border-box' | 'content-box' */ | |
622 |
|
622 | |||
623 | /** |
|
623 | /** | |
624 | * Returns object with special values specifically useful for node |
|
624 | * Returns object with special values specifically useful for node | |
625 | * fitting. |
|
625 | * fitting. | |
626 | */ |
|
626 | */ | |
627 | getPadExtents(node: Element, computedStyle?: DomComputedStyle): DomGeometryBoxExtents; |
|
627 | getPadExtents(node: Element, computedStyle?: DomComputedStyle): DomGeometryBoxExtents; | |
628 |
|
628 | |||
629 | /** |
|
629 | /** | |
630 | * returns an object with properties useful for noting the border |
|
630 | * returns an object with properties useful for noting the border | |
631 | * dimensions. |
|
631 | * dimensions. | |
632 | */ |
|
632 | */ | |
633 | getBorderExtents(node: Element, computedStyle?: DomComputedStyle): DomGeometryBoxExtents; |
|
633 | getBorderExtents(node: Element, computedStyle?: DomComputedStyle): DomGeometryBoxExtents; | |
634 |
|
634 | |||
635 | /** |
|
635 | /** | |
636 | * Returns object with properties useful for box fitting with |
|
636 | * Returns object with properties useful for box fitting with | |
637 | * regards to padding. |
|
637 | * regards to padding. | |
638 | */ |
|
638 | */ | |
639 | getPadBorderExtents(node: Element, computedStyle?: DomComputedStyle): DomGeometryBoxExtents; |
|
639 | getPadBorderExtents(node: Element, computedStyle?: DomComputedStyle): DomGeometryBoxExtents; | |
640 |
|
640 | |||
641 | /** |
|
641 | /** | |
642 | * returns object with properties useful for box fitting with |
|
642 | * returns object with properties useful for box fitting with | |
643 | * regards to box margins (i.e., the outer-box). |
|
643 | * regards to box margins (i.e., the outer-box). | |
644 | * - l/t = marginLeft, marginTop, respectively |
|
644 | * - l/t = marginLeft, marginTop, respectively | |
645 | * - w = total width, margin inclusive |
|
645 | * - w = total width, margin inclusive | |
646 | * - h = total height, margin inclusive |
|
646 | * - h = total height, margin inclusive | |
647 | * The w/h are used for calculating boxes. |
|
647 | * The w/h are used for calculating boxes. | |
648 | * Normally application code will not need to invoke this |
|
648 | * Normally application code will not need to invoke this | |
649 | * directly, and will use the ...box... functions instead. |
|
649 | * directly, and will use the ...box... functions instead. | |
650 | */ |
|
650 | */ | |
651 | getMarginExtents(node: Element, computedStyle?: DomComputedStyle): DomGeometryBoxExtents; |
|
651 | getMarginExtents(node: Element, computedStyle?: DomComputedStyle): DomGeometryBoxExtents; | |
652 |
|
652 | |||
653 | /** |
|
653 | /** | |
654 | * returns an object that encodes the width, height, left and top |
|
654 | * returns an object that encodes the width, height, left and top | |
655 | * positions of the node's margin box. |
|
655 | * positions of the node's margin box. | |
656 | */ |
|
656 | */ | |
657 | getMarginBox(node: Element, computedStyle?: DomComputedStyle): DomGeometryBox; |
|
657 | getMarginBox(node: Element, computedStyle?: DomComputedStyle): DomGeometryBox; | |
658 |
|
658 | |||
659 | /** |
|
659 | /** | |
660 | * Returns an object that encodes the width, height, left and top |
|
660 | * Returns an object that encodes the width, height, left and top | |
661 | * positions of the node's content box, irrespective of the |
|
661 | * positions of the node's content box, irrespective of the | |
662 | * current box model. |
|
662 | * current box model. | |
663 | */ |
|
663 | */ | |
664 | getContentBox(node: Element, computedStyle?: DomComputedStyle): DomGeometryBox; |
|
664 | getContentBox(node: Element, computedStyle?: DomComputedStyle): DomGeometryBox; | |
665 |
|
665 | |||
666 | /** |
|
666 | /** | |
667 | * Sets the size of the node's contents, irrespective of margins, |
|
667 | * Sets the size of the node's contents, irrespective of margins, | |
668 | * padding, or borders. |
|
668 | * padding, or borders. | |
669 | */ |
|
669 | */ | |
670 | setContentSize(node: Element, box: DomGeometryWidthHeight, computedStyle?: DomComputedStyle): void; |
|
670 | setContentSize(node: Element, box: DomGeometryWidthHeight, computedStyle?: DomComputedStyle): void; | |
671 |
|
671 | |||
672 | /** |
|
672 | /** | |
673 | * sets the size of the node's margin box and placement |
|
673 | * sets the size of the node's margin box and placement | |
674 | * (left/top), irrespective of box model. Think of it as a |
|
674 | * (left/top), irrespective of box model. Think of it as a | |
675 | * passthrough to setBox that handles box-model vagaries for |
|
675 | * passthrough to setBox that handles box-model vagaries for | |
676 | * you. |
|
676 | * you. | |
677 | */ |
|
677 | */ | |
678 | setMarginBox(node: Element, box: DomGeometryBox, computedStyle?: DomComputedStyle): void; |
|
678 | setMarginBox(node: Element, box: DomGeometryBox, computedStyle?: DomComputedStyle): void; | |
679 |
|
679 | |||
680 | /** |
|
680 | /** | |
681 | * Returns true if the current language is left-to-right, and false otherwise. |
|
681 | * Returns true if the current language is left-to-right, and false otherwise. | |
682 | */ |
|
682 | */ | |
683 | isBodyLtr(doc?: Document): boolean; |
|
683 | isBodyLtr(doc?: Document): boolean; | |
684 |
|
684 | |||
685 | /** |
|
685 | /** | |
686 | * Returns an object with {node, x, y} with corresponding offsets. |
|
686 | * Returns an object with {node, x, y} with corresponding offsets. | |
687 | */ |
|
687 | */ | |
688 | docScroll(doc?: Document): Point; |
|
688 | docScroll(doc?: Document): Point; | |
689 |
|
689 | |||
690 | /** |
|
690 | /** | |
691 | * Deprecated method previously used for IE6-IE7. Now, just returns `{x:0, y:0}`. |
|
691 | * Deprecated method previously used for IE6-IE7. Now, just returns `{x:0, y:0}`. | |
692 | */ |
|
692 | */ | |
693 | getIeDocumentElementOffset(doc: Document): Point; |
|
693 | getIeDocumentElementOffset(doc: Document): Point; | |
694 |
|
694 | |||
695 | /** |
|
695 | /** | |
696 | * In RTL direction, scrollLeft should be a negative value, but IE |
|
696 | * In RTL direction, scrollLeft should be a negative value, but IE | |
697 | * returns a positive one. All codes using documentElement.scrollLeft |
|
697 | * returns a positive one. All codes using documentElement.scrollLeft | |
698 | * must call this function to fix this error, otherwise the position |
|
698 | * must call this function to fix this error, otherwise the position | |
699 | * will offset to right when there is a horizontal scrollbar. |
|
699 | * will offset to right when there is a horizontal scrollbar. | |
700 | */ |
|
700 | */ | |
701 | fixIeBiDiScrollLeft(scrollLeft: number, doc?: Document): number; |
|
701 | fixIeBiDiScrollLeft(scrollLeft: number, doc?: Document): number; | |
702 |
|
702 | |||
703 | /** |
|
703 | /** | |
704 | * Gets the position and size of the passed element relative to |
|
704 | * Gets the position and size of the passed element relative to | |
705 | * the viewport (if includeScroll==false), or relative to the |
|
705 | * the viewport (if includeScroll==false), or relative to the | |
706 | * document root (if includeScroll==true). |
|
706 | * document root (if includeScroll==true). | |
707 | */ |
|
707 | */ | |
708 | position(node: Element, includeScroll?: boolean): DomGeometryXYBox; |
|
708 | position(node: Element, includeScroll?: boolean): DomGeometryXYBox; | |
709 |
|
709 | |||
710 | /** |
|
710 | /** | |
711 | * returns an object that encodes the width and height of |
|
711 | * returns an object that encodes the width and height of | |
712 | * the node's margin box |
|
712 | * the node's margin box | |
713 | */ |
|
713 | */ | |
714 | getMarginSize(node: Element, computedStyle?: DomComputedStyle): DomGeometryWidthHeight; |
|
714 | getMarginSize(node: Element, computedStyle?: DomComputedStyle): DomGeometryWidthHeight; | |
715 |
|
715 | |||
716 | /** |
|
716 | /** | |
717 | * Normalizes the geometry of a DOM event, normalizing the pageX, pageY, |
|
717 | * Normalizes the geometry of a DOM event, normalizing the pageX, pageY, | |
718 | * offsetX, offsetY, layerX, and layerX properties |
|
718 | * offsetX, offsetY, layerX, and layerX properties | |
719 | */ |
|
719 | */ | |
720 | normalizeEvent(event: Event): void; |
|
720 | normalizeEvent(event: Event): void; | |
721 | } |
|
721 | } | |
722 |
|
722 | |||
723 | /* dojo/dom-prop */ |
|
723 | /* dojo/dom-prop */ | |
724 |
|
724 | |||
725 | interface DomProp { |
|
725 | interface DomProp { | |
726 | /** |
|
726 | /** | |
727 | * Gets a property on an HTML element. |
|
727 | * Gets a property on an HTML element. | |
728 | */ |
|
728 | */ | |
729 | get(node: ElementOrString, name: string): any; |
|
729 | get(node: ElementOrString, name: string): any; | |
730 |
|
730 | |||
731 | /** |
|
731 | /** | |
732 | * Sets a property on an HTML element. |
|
732 | * Sets a property on an HTML element. | |
733 | */ |
|
733 | */ | |
734 | set(node: ElementOrString, name: string | GenericObject, value?: any): Element; |
|
734 | set(node: ElementOrString, name: string | GenericObject, value?: any): Element; | |
735 | } |
|
735 | } | |
736 |
|
736 | |||
737 | /* dojo/dom-style */ |
|
737 | /* dojo/dom-style */ | |
738 |
|
738 | |||
739 | // TODO move over the most common properties from CSSStyleDeclaration |
|
739 | // TODO move over the most common properties from CSSStyleDeclaration | |
740 | interface DomComputedStyle { |
|
740 | interface DomComputedStyle { | |
741 | position?: string; |
|
741 | position?: string; | |
742 | width?: string; |
|
742 | width?: string; | |
743 | height?: string; |
|
743 | height?: string; | |
744 | [id: string]: any; |
|
744 | [id: string]: any; | |
745 | } |
|
745 | } | |
746 |
|
746 | |||
747 | interface DomStyle { |
|
747 | interface DomStyle { | |
748 | /** |
|
748 | /** | |
749 | * Returns a "computed style" object. |
|
749 | * Returns a "computed style" object. | |
750 | */ |
|
750 | */ | |
751 | getComputedStyle(node: Node): DomComputedStyle; |
|
751 | getComputedStyle(node: Node): DomComputedStyle; | |
752 |
|
752 | |||
753 | /** |
|
753 | /** | |
754 | * Accesses styles on a node. |
|
754 | * Accesses styles on a node. | |
755 | */ |
|
755 | */ | |
756 | get(node: ElementOrString): DomComputedStyle; |
|
756 | get(node: ElementOrString): DomComputedStyle; | |
757 | get(node: ElementOrString, name: string): string | number; |
|
757 | get(node: ElementOrString, name: string): string | number; | |
758 |
|
758 | |||
759 | /** |
|
759 | /** | |
760 | * Sets styles on a node. |
|
760 | * Sets styles on a node. | |
761 | */ |
|
761 | */ | |
762 | set(node: ElementOrString, name: DomComputedStyle): DomComputedStyle; |
|
762 | set(node: ElementOrString, name: DomComputedStyle): DomComputedStyle; | |
763 | set(node: ElementOrString, name: string, value: string | number): DomComputedStyle; |
|
763 | set(node: ElementOrString, name: string, value: string | number): DomComputedStyle; | |
764 |
|
764 | |||
765 | /** |
|
765 | /** | |
766 | * converts style value to pixels on IE or return a numeric value. |
|
766 | * converts style value to pixels on IE or return a numeric value. | |
767 | */ |
|
767 | */ | |
768 | toPixelValue(element: Element, value: string): number; |
|
768 | toPixelValue(element: Element, value: string): number; | |
769 | } |
|
769 | } | |
770 |
|
770 | |||
771 | /* dojo/domReady */ |
|
771 | /* dojo/domReady */ | |
772 |
|
772 | |||
773 | interface DomReady { |
|
773 | interface DomReady { | |
774 | /** |
|
774 | /** | |
775 | * Plugin to delay require()/define() callback from firing until the DOM has finished |
|
775 | * Plugin to delay require()/define() callback from firing until the DOM has finished | |
776 | */ |
|
776 | */ | |
777 | (callback: Function): void; |
|
777 | (callback: Function): void; | |
778 |
|
778 | |||
779 | load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */ |
|
779 | load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */ | |
780 | _Q: Function[]; |
|
780 | _Q: Function[]; | |
781 | _onEmpty(): void; |
|
781 | _onEmpty(): void; | |
782 | } |
|
782 | } | |
783 |
|
783 | |||
784 | /* dojo/Evented */ |
|
784 | /* dojo/Evented */ | |
785 |
|
785 | |||
786 | interface Evented { |
|
786 | interface Evented { | |
787 | on(type: string | ExtensionEvent, listener: EventListener | Function): Handle; |
|
787 | on(type: string | ExtensionEvent, listener: EventListener | Function): Handle; | |
788 | emit(type: string | ExtensionEvent, ...events: any[]): boolean; |
|
788 | emit(type: string | ExtensionEvent, ...events: any[]): boolean; | |
789 | } |
|
789 | } | |
790 |
|
790 | |||
791 | interface EventedConstructor extends _base.DeclareConstructor<Evented> { |
|
791 | interface EventedConstructor extends _base.DeclareConstructor<Evented> { | |
792 | new (params?: Object): Evented; |
|
792 | new (params?: Object): Evented; | |
793 | } |
|
793 | } | |
794 |
|
794 | |||
795 | /* dojo/fx */ |
|
795 | /* dojo/fx */ | |
796 |
|
796 | |||
797 | /* dojo/fx augments the dojo/_base/fx, therefore it is typed in fx.d.ts and not referenced from |
|
797 | /* dojo/fx augments the dojo/_base/fx, therefore it is typed in fx.d.ts and not referenced from | |
798 | index.d.ts or module.d.ts and is self contained typings for dojo/fx and dojo/fx/* */ |
|
798 | index.d.ts or module.d.ts and is self contained typings for dojo/fx and dojo/fx/* */ | |
799 |
|
799 | |||
800 | /* dojo/gears */ |
|
800 | /* dojo/gears */ | |
801 |
|
801 | |||
802 | /* This is long-ago deprecated by Google, so just doing a minimal typing */ |
|
802 | /* This is long-ago deprecated by Google, so just doing a minimal typing */ | |
803 |
|
803 | |||
804 | interface Gears { |
|
804 | interface Gears { | |
805 | _gearsObject(): any; |
|
805 | _gearsObject(): any; | |
806 | available: boolean; |
|
806 | available: boolean; | |
807 | } |
|
807 | } | |
808 |
|
808 | |||
809 | /* dojo/has */ |
|
809 | /* dojo/has */ | |
810 |
|
810 | |||
811 | interface HasCache { |
|
811 | interface HasCache { | |
812 | [feature: string]: any; |
|
812 | [feature: string]: any; | |
813 | } |
|
813 | } | |
814 |
|
814 | |||
815 | interface HasTestFunction { |
|
815 | interface HasTestFunction { | |
816 | /* TypeScript has no way of referring to the global scope see Microsoft/TypeScript#983 */ |
|
816 | /* TypeScript has no way of referring to the global scope see Microsoft/TypeScript#983 */ | |
817 | (global?: any, doc?: Document, element?: Element): any; |
|
817 | (global?: any, doc?: Document, element?: Element): any; | |
818 | } |
|
818 | } | |
819 |
|
819 | |||
820 | interface Has { |
|
820 | interface Has { | |
821 | /** |
|
821 | /** | |
822 | * Return the current value of the named feature. |
|
822 | * Return the current value of the named feature. | |
823 | * @param {string | number} name The name (if a string) or identifier (if an integer) of the feature to test. |
|
823 | * @param {string | number} name The name (if a string) or identifier (if an integer) of the feature to test. | |
824 | */ |
|
824 | */ | |
825 | (name: string | number): any; |
|
825 | (name: string | number): any; | |
826 | (name: 'host-browser'): boolean; |
|
826 | (name: 'host-browser'): boolean; | |
827 | (name: 'host-node'): any; |
|
827 | (name: 'host-node'): any; | |
828 | (name: 'host-rhino'): boolean; |
|
828 | (name: 'host-rhino'): boolean; | |
829 | (name: 'dom'): boolean; |
|
829 | (name: 'dom'): boolean; | |
830 | (name: 'dojo-dom-ready-api'): 1; |
|
830 | (name: 'dojo-dom-ready-api'): 1; | |
831 | (name: 'dojo-sniff'): 1; |
|
831 | (name: 'dojo-sniff'): 1; | |
832 | // if host-browser is true |
|
832 | // if host-browser is true | |
833 | (name: 'dom-addeventlistener'): void | boolean; |
|
833 | (name: 'dom-addeventlistener'): void | boolean; | |
834 | (name: 'touch'): void | boolean; |
|
834 | (name: 'touch'): void | boolean; | |
835 | (name: 'touch-events'): void | boolean; |
|
835 | (name: 'touch-events'): void | boolean; | |
836 | (name: 'pointer-events'): void | boolean; |
|
836 | (name: 'pointer-events'): void | boolean; | |
837 | (name: 'MSPointer'): void | boolean; |
|
837 | (name: 'MSPointer'): void | boolean; | |
838 | (name: 'device-width'): void | number; |
|
838 | (name: 'device-width'): void | number; | |
839 | (name: 'dom-attributes-explicit'): void | boolean; |
|
839 | (name: 'dom-attributes-explicit'): void | boolean; | |
840 | (name: 'dom-attributes-specified-flag'): void | boolean; |
|
840 | (name: 'dom-attributes-specified-flag'): void | boolean; | |
841 | // dojo/_base/browser |
|
841 | // dojo/_base/browser | |
842 | (name: 'config-selectorEngine'): string; |
|
842 | (name: 'config-selectorEngine'): string; | |
843 |
|
843 | |||
844 | cache: HasCache; |
|
844 | cache: HasCache; | |
845 |
|
845 | |||
846 | /** |
|
846 | /** | |
847 | * Register a new feature test for some named feature. |
|
847 | * Register a new feature test for some named feature. | |
848 | */ |
|
848 | */ | |
849 | add(name: string | number, test: HasTestFunction, now?: boolean, force?: boolean): any; |
|
849 | add(name: string | number, test: HasTestFunction, now?: boolean, force?: boolean): any; | |
850 | add<T extends (Object | string | number | boolean | null | void)>(name: string | number, test: T, now?: boolean, force?: boolean): any; |
|
850 | add<T extends (Object | string | number | boolean | null | void)>(name: string | number, test: T, now?: boolean, force?: boolean): any; | |
851 |
|
851 | |||
852 | /** |
|
852 | /** | |
853 | * Deletes the contents of the element passed to test functions. |
|
853 | * Deletes the contents of the element passed to test functions. | |
854 | */ |
|
854 | */ | |
855 | clearElement(element: HTMLElement): HTMLElement; |
|
855 | clearElement(element: HTMLElement): HTMLElement; | |
856 |
|
856 | |||
857 | /** |
|
857 | /** | |
858 | * Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s). |
|
858 | * Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s). | |
859 | */ |
|
859 | */ | |
860 | normalize(id: string, toAbsMid: Function): string; /* TODO: Align with loader api */ |
|
860 | normalize(id: string, toAbsMid: Function): string; /* TODO: Align with loader api */ | |
861 |
|
861 | |||
862 | /** |
|
862 | /** | |
863 | * Conditional loading of AMD modules based on a has feature test value. |
|
863 | * Conditional loading of AMD modules based on a has feature test value. | |
864 | */ |
|
864 | */ | |
865 | load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */ |
|
865 | load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */ | |
866 | } |
|
866 | } | |
867 |
|
867 | |||
868 | /* dojo/hash */ |
|
868 | /* dojo/hash */ | |
869 |
|
869 | |||
870 | interface Hash { |
|
870 | interface Hash { | |
871 | (hash?: string, replace?: boolean): string; |
|
871 | (hash?: string, replace?: boolean): string; | |
872 | } |
|
872 | } | |
873 |
|
873 | |||
874 | /* dojo/hccss */ |
|
874 | /* dojo/hccss */ | |
875 |
|
875 | |||
876 | /* this only does has.add and re-exports the has interface */ |
|
876 | /* this only does has.add and re-exports the has interface */ | |
877 | interface Has { |
|
877 | interface Has { | |
878 | (name: 'highcontrast'): void | boolean; |
|
878 | (name: 'highcontrast'): void | boolean; | |
879 | } |
|
879 | } | |
880 |
|
880 | |||
881 | /* dojo/html */ |
|
881 | /* dojo/html */ | |
882 |
|
882 | |||
883 | type ContentSetterContent = string | Node | ArrayLike<Node>; |
|
883 | type ContentSetterContent = string | Node | ArrayLike<Node>; | |
884 |
|
884 | |||
885 | interface ContentSetterParams { |
|
885 | interface ContentSetterParams { | |
886 | node?: NodeOrString; |
|
886 | node?: NodeOrString; | |
887 | content?: ContentSetterContent; |
|
887 | content?: ContentSetterContent; | |
888 | id?: string; |
|
888 | id?: string; | |
889 | cleanContent?: boolean; |
|
889 | cleanContent?: boolean; | |
890 | extractContent?: boolean; |
|
890 | extractContent?: boolean; | |
891 | parseContent?: boolean; |
|
891 | parseContent?: boolean; | |
892 | parserScope?: boolean; |
|
892 | parserScope?: boolean; | |
893 | startup?: boolean; |
|
893 | startup?: boolean; | |
894 | onBegin?: Function; |
|
894 | onBegin?: Function; | |
895 | onEnd?: Function; |
|
895 | onEnd?: Function; | |
896 | tearDown?: Function; |
|
896 | tearDown?: Function; | |
897 | onContentError?: Function; |
|
897 | onContentError?: Function; | |
898 | onExecError?: Function; |
|
898 | onExecError?: Function; | |
899 | } |
|
899 | } | |
900 |
|
900 | |||
901 | interface ContentSetter { |
|
901 | interface ContentSetter { | |
902 |
|
902 | |||
903 | /** |
|
903 | /** | |
904 | * An node which will be the parent element that we set content into |
|
904 | * An node which will be the parent element that we set content into | |
905 | */ |
|
905 | */ | |
906 | node: NodeOrString; |
|
906 | node: NodeOrString; | |
907 |
|
907 | |||
908 | /** |
|
908 | /** | |
909 | * The content to be placed in the node. Can be an HTML string, a node reference, or a enumerable list of nodes |
|
909 | * The content to be placed in the node. Can be an HTML string, a node reference, or a enumerable list of nodes | |
910 | */ |
|
910 | */ | |
911 | content: ContentSetterContent; |
|
911 | content: ContentSetterContent; | |
912 |
|
912 | |||
913 | /** |
|
913 | /** | |
914 | * Usually only used internally, and auto-generated with each instance |
|
914 | * Usually only used internally, and auto-generated with each instance | |
915 | */ |
|
915 | */ | |
916 | id: string; |
|
916 | id: string; | |
917 |
|
917 | |||
918 | /** |
|
918 | /** | |
919 | * Should the content be treated as a full html document, |
|
919 | * Should the content be treated as a full html document, | |
920 | * and the real content stripped of <html>, <body> wrapper before injection |
|
920 | * and the real content stripped of <html>, <body> wrapper before injection | |
921 | */ |
|
921 | */ | |
922 | cleanContent: boolean; |
|
922 | cleanContent: boolean; | |
923 |
|
923 | |||
924 | /** |
|
924 | /** | |
925 | * Should the content be treated as a full html document, |
|
925 | * Should the content be treated as a full html document, | |
926 | * and the real content stripped of `<html> <body>` wrapper before injection |
|
926 | * and the real content stripped of `<html> <body>` wrapper before injection | |
927 | */ |
|
927 | */ | |
928 | extractContent: boolean; |
|
928 | extractContent: boolean; | |
929 |
|
929 | |||
930 | /** |
|
930 | /** | |
931 | * Should the node by passed to the parser after the new content is set |
|
931 | * Should the node by passed to the parser after the new content is set | |
932 | */ |
|
932 | */ | |
933 | parseContent: boolean; |
|
933 | parseContent: boolean; | |
934 |
|
934 | |||
935 | /** |
|
935 | /** | |
936 | * Flag passed to parser. Root for attribute names to search for. If scopeName is dojo, |
|
936 | * Flag passed to parser. Root for attribute names to search for. If scopeName is dojo, | |
937 | * will search for data-dojo-type (or dojoType). For backwards compatibility |
|
937 | * will search for data-dojo-type (or dojoType). For backwards compatibility | |
938 | * reasons defaults to dojo._scopeName (which is "dojo" except when |
|
938 | * reasons defaults to dojo._scopeName (which is "dojo" except when | |
939 | * multi-version support is used, when it will be something like dojo16, dojo20, etc.) |
|
939 | * multi-version support is used, when it will be something like dojo16, dojo20, etc.) | |
940 | */ |
|
940 | */ | |
941 | parserScope: string; |
|
941 | parserScope: string; | |
942 |
|
942 | |||
943 | /** |
|
943 | /** | |
944 | * Start the child widgets after parsing them. Only obeyed if parseContent is true. |
|
944 | * Start the child widgets after parsing them. Only obeyed if parseContent is true. | |
945 | */ |
|
945 | */ | |
946 | startup: boolean; |
|
946 | startup: boolean; | |
947 |
|
947 | |||
948 | /** |
|
948 | /** | |
949 | * front-end to the set-content sequence |
|
949 | * front-end to the set-content sequence | |
950 | */ |
|
950 | */ | |
951 | set(cont?: ContentSetterContent, params?: ContentSetterParams): promise.Promise<Node> | Node; |
|
951 | set(cont?: ContentSetterContent, params?: ContentSetterParams): promise.Promise<Node> | Node; | |
952 |
|
952 | |||
953 | /** |
|
953 | /** | |
954 | * sets the content on the node |
|
954 | * sets the content on the node | |
955 | */ |
|
955 | */ | |
956 | setContent(): void; |
|
956 | setContent(): void; | |
957 |
|
957 | |||
958 | /** |
|
958 | /** | |
959 | * cleanly empty out existing content |
|
959 | * cleanly empty out existing content | |
960 | */ |
|
960 | */ | |
961 | empty(): void; |
|
961 | empty(): void; | |
962 |
|
962 | |||
963 | /** |
|
963 | /** | |
964 | * Called after instantiation, but before set(); |
|
964 | * Called after instantiation, but before set(); | |
965 | * It allows modification of any of the object properties - |
|
965 | * It allows modification of any of the object properties - | |
966 | * including the node and content provided - before the set operation actually takes place |
|
966 | * including the node and content provided - before the set operation actually takes place | |
967 | */ |
|
967 | */ | |
968 | onBegin(): Node; |
|
968 | onBegin(): Node; | |
969 |
|
969 | |||
970 | /** |
|
970 | /** | |
971 | * Called after set(), when the new content has been pushed into the node |
|
971 | * Called after set(), when the new content has been pushed into the node | |
972 | * It provides an opportunity for post-processing before handing back the node to the caller |
|
972 | * It provides an opportunity for post-processing before handing back the node to the caller | |
973 | * This default implementation checks a parseContent flag to optionally run the dojo parser over the new content |
|
973 | * This default implementation checks a parseContent flag to optionally run the dojo parser over the new content | |
974 | */ |
|
974 | */ | |
975 | onEnd(): Node; |
|
975 | onEnd(): Node; | |
976 |
|
976 | |||
977 | /** |
|
977 | /** | |
978 | * manually reset the Setter instance if its being re-used for example for another set() |
|
978 | * manually reset the Setter instance if its being re-used for example for another set() | |
979 | */ |
|
979 | */ | |
980 | tearDown(): void; |
|
980 | tearDown(): void; | |
981 |
|
981 | |||
982 | onContentError(): string; |
|
982 | onContentError(): string; | |
983 | onExecError(): string; |
|
983 | onExecError(): string; | |
984 | _mixin(params: ContentSetterParams): void; |
|
984 | _mixin(params: ContentSetterParams): void; | |
985 | parseDeferred: Deferred<any[]>; |
|
985 | parseDeferred: Deferred<any[]>; | |
986 |
|
986 | |||
987 | /** |
|
987 | /** | |
988 | * runs the dojo parser over the node contents, storing any results in this.parseResults |
|
988 | * runs the dojo parser over the node contents, storing any results in this.parseResults | |
989 | */ |
|
989 | */ | |
990 | _parse(): void; |
|
990 | _parse(): void; | |
991 |
|
991 | |||
992 | /** |
|
992 | /** | |
993 | * shows user the string that is returned by on[type]Error |
|
993 | * shows user the string that is returned by on[type]Error | |
994 | * override/implement on[type]Error and return your own string to customize |
|
994 | * override/implement on[type]Error and return your own string to customize | |
995 | */ |
|
995 | */ | |
996 | _onError(type: string, err: Error, consoleText?: string): void; |
|
996 | _onError(type: string, err: Error, consoleText?: string): void; | |
997 | } |
|
997 | } | |
998 |
|
998 | |||
999 | interface ContentSetterConstructor extends _base.DeclareConstructor<ContentSetter> { |
|
999 | interface ContentSetterConstructor extends _base.DeclareConstructor<ContentSetter> { | |
1000 | new (params?: ContentSetterParams, node?: NodeOrString): ContentSetter; |
|
1000 | new (params?: ContentSetterParams, node?: NodeOrString): ContentSetter; | |
1001 | } |
|
1001 | } | |
1002 |
|
1002 | |||
1003 | interface Html { |
|
1003 | interface Html { | |
1004 | /** |
|
1004 | /** | |
1005 | * removes !DOCTYPE and title elements from the html string. |
|
1005 | * removes !DOCTYPE and title elements from the html string. | |
1006 | * |
|
1006 | * | |
1007 | * khtml is picky about dom faults, you can't attach a style or `<title>` node as child of body |
|
1007 | * khtml is picky about dom faults, you can't attach a style or `<title>` node as child of body | |
1008 | * must go into head, so we need to cut out those tags |
|
1008 | * must go into head, so we need to cut out those tags | |
1009 | */ |
|
1009 | */ | |
1010 | _secureForInnerHtml(cont: string): string; |
|
1010 | _secureForInnerHtml(cont: string): string; | |
1011 |
|
1011 | |||
1012 | /** |
|
1012 | /** | |
1013 | * Deprecated, should use dojo/dom-constuct.empty() directly, remove in 2.0. |
|
1013 | * Deprecated, should use dojo/dom-constuct.empty() directly, remove in 2.0. | |
1014 | */ |
|
1014 | */ | |
1015 | _emptyNode(node: NodeOrString): void; |
|
1015 | _emptyNode(node: NodeOrString): void; | |
1016 |
|
1016 | |||
1017 | /** |
|
1017 | /** | |
1018 | * inserts the given content into the given node |
|
1018 | * inserts the given content into the given node | |
1019 | */ |
|
1019 | */ | |
1020 | _setNodeContent<T extends Node>(node: Node, cont: string | Node | ArrayLike<T>): Node; |
|
1020 | _setNodeContent<T extends Node>(node: Node, cont: string | Node | ArrayLike<T>): Node; | |
1021 |
|
1021 | |||
1022 | _ContentSetter: ContentSetterConstructor; |
|
1022 | _ContentSetter: ContentSetterConstructor; | |
1023 |
|
1023 | |||
1024 | /** |
|
1024 | /** | |
1025 | * inserts (replaces) the given content into the given node. dojo/dom-construct.place(cont, node, "only") |
|
1025 | * inserts (replaces) the given content into the given node. dojo/dom-construct.place(cont, node, "only") | |
1026 | * may be a better choice for simple HTML insertion. |
|
1026 | * may be a better choice for simple HTML insertion. | |
1027 | */ |
|
1027 | */ | |
1028 | set(node: Node, cont?: ContentSetterContent, params?: ContentSetterParams): promise.Promise<Node> | Node; |
|
1028 | set(node: Node, cont?: ContentSetterContent, params?: ContentSetterParams): promise.Promise<Node> | Node; | |
1029 | } |
|
1029 | } | |
1030 |
|
1030 | |||
1031 | /* dojo/i18n */ |
|
1031 | /* dojo/i18n */ | |
1032 |
|
1032 | |||
1033 | interface I18n { |
|
1033 | interface I18n { | |
1034 | getLocalization(moduleName: string, bundleName: string, locale?: string): any; |
|
1034 | getLocalization(moduleName: string, bundleName: string, locale?: string): any; | |
1035 |
|
1035 | |||
1036 | dynamic: boolean; |
|
1036 | dynamic: boolean; | |
1037 |
|
1037 | |||
1038 | /** |
|
1038 | /** | |
1039 | * Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s). |
|
1039 | * Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s). | |
1040 | */ |
|
1040 | */ | |
1041 | normalize(id: string, toAbsMid: Function): string; /* TODO: Align with loader api */ |
|
1041 | normalize(id: string, toAbsMid: Function): string; /* TODO: Align with loader api */ | |
1042 |
|
1042 | |||
1043 | normalizeLocale(locale?: string): string; |
|
1043 | normalizeLocale(locale?: string): string; | |
1044 |
|
1044 | |||
1045 | /** |
|
1045 | /** | |
1046 | * Conditional loading of AMD modules based on a has feature test value. |
|
1046 | * Conditional loading of AMD modules based on a has feature test value. | |
1047 | */ |
|
1047 | */ | |
1048 | load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */ |
|
1048 | load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */ | |
1049 |
|
1049 | |||
1050 | cache: { [bundle: string]: any }; |
|
1050 | cache: { [bundle: string]: any }; | |
1051 |
|
1051 | |||
1052 | getL10nName(moduleName: string, bundleName: string, locale?: string): string; |
|
1052 | getL10nName(moduleName: string, bundleName: string, locale?: string): string; | |
1053 | } |
|
1053 | } | |
1054 |
|
1054 | |||
1055 | /* dojo/io-query */ |
|
1055 | /* dojo/io-query */ | |
1056 |
|
1056 | |||
1057 | interface IoQuery { |
|
1057 | interface IoQuery { | |
1058 | /** |
|
1058 | /** | |
1059 | * takes a name/value mapping object and returns a string representing |
|
1059 | * takes a name/value mapping object and returns a string representing | |
1060 | * a URL-encoded version of that object. |
|
1060 | * a URL-encoded version of that object. | |
1061 | */ |
|
1061 | */ | |
1062 | objectToQuery(map: GenericObject): string; |
|
1062 | objectToQuery(map: GenericObject): string; | |
1063 |
|
1063 | |||
1064 | /** |
|
1064 | /** | |
1065 | * Create an object representing a de-serialized query section of a |
|
1065 | * Create an object representing a de-serialized query section of a | |
1066 | * URL. Query keys with multiple values are returned in an array. |
|
1066 | * URL. Query keys with multiple values are returned in an array. | |
1067 | */ |
|
1067 | */ | |
1068 | queryToObject(str: string): GenericObject; |
|
1068 | queryToObject(str: string): GenericObject; | |
1069 | } |
|
1069 | } | |
1070 |
|
1070 | |||
1071 | /* dojo/json */ |
|
1071 | /* dojo/json */ | |
1072 |
|
1072 | |||
1073 | interface Json { |
|
1073 | interface Json { | |
1074 |
|
1074 | |||
1075 | /** |
|
1075 | /** | |
1076 | * Parses a [JSON](http://json.org) string to return a JavaScript object. |
|
1076 | * Parses a [JSON](http://json.org) string to return a JavaScript object. | |
1077 | */ |
|
1077 | */ | |
1078 | parse(str: string, strict?: boolean): any; |
|
1078 | parse(str: string, strict?: boolean): any; | |
1079 |
|
1079 | |||
1080 | /** |
|
1080 | /** | |
1081 | * Returns a [JSON](http://json.org) serialization of an object. |
|
1081 | * Returns a [JSON](http://json.org) serialization of an object. | |
1082 | */ |
|
1082 | */ | |
1083 | stringify(value: any, replacer?: (key: string, value: any) => any| any[], space?: string | number): string; |
|
1083 | stringify(value: any, replacer?: (key: string, value: any) => any| any[], space?: string | number): string; | |
1084 | } |
|
1084 | } | |
1085 |
|
1085 | |||
1086 | /* dojo/keys */ |
|
1086 | /* dojo/keys */ | |
1087 |
|
1087 | |||
1088 | interface Keys { |
|
1088 | interface Keys { | |
1089 | BACKSPACE: number; |
|
1089 | BACKSPACE: number; | |
1090 | TAB: number; |
|
1090 | TAB: number; | |
1091 | CLEAR: number; |
|
1091 | CLEAR: number; | |
1092 | ENTER: number; |
|
1092 | ENTER: number; | |
1093 | SHIFT: number; |
|
1093 | SHIFT: number; | |
1094 | CTRL: number; |
|
1094 | CTRL: number; | |
1095 | ALT: number; |
|
1095 | ALT: number; | |
1096 | META: number; |
|
1096 | META: number; | |
1097 | PAUSE: number; |
|
1097 | PAUSE: number; | |
1098 | CAPS_LOCK: number; |
|
1098 | CAPS_LOCK: number; | |
1099 | ESCAPE: number; |
|
1099 | ESCAPE: number; | |
1100 | SPACE: number; |
|
1100 | SPACE: number; | |
1101 | PAGE_UP: number; |
|
1101 | PAGE_UP: number; | |
1102 | PAGE_DOWN: number; |
|
1102 | PAGE_DOWN: number; | |
1103 | END: number; |
|
1103 | END: number; | |
1104 | HOME: number; |
|
1104 | HOME: number; | |
1105 | LEFT_ARROW: number; |
|
1105 | LEFT_ARROW: number; | |
1106 | UP_ARROW: number; |
|
1106 | UP_ARROW: number; | |
1107 | RIGHT_ARROW: number; |
|
1107 | RIGHT_ARROW: number; | |
1108 | DOWN_ARROW: number; |
|
1108 | DOWN_ARROW: number; | |
1109 | INSERT: number; |
|
1109 | INSERT: number; | |
1110 | DELETE: number; |
|
1110 | DELETE: number; | |
1111 | HELP: number; |
|
1111 | HELP: number; | |
1112 | LEFT_WINDOW: number; |
|
1112 | LEFT_WINDOW: number; | |
1113 | RIGHT_WINDOW: number; |
|
1113 | RIGHT_WINDOW: number; | |
1114 | SELECT: number; |
|
1114 | SELECT: number; | |
1115 | NUMPAD_0: number; |
|
1115 | NUMPAD_0: number; | |
1116 | NUMPAD_1: number; |
|
1116 | NUMPAD_1: number; | |
1117 | NUMPAD_2: number; |
|
1117 | NUMPAD_2: number; | |
1118 | NUMPAD_3: number; |
|
1118 | NUMPAD_3: number; | |
1119 | NUMPAD_4: number; |
|
1119 | NUMPAD_4: number; | |
1120 | NUMPAD_5: number; |
|
1120 | NUMPAD_5: number; | |
1121 | NUMPAD_6: number; |
|
1121 | NUMPAD_6: number; | |
1122 | NUMPAD_7: number; |
|
1122 | NUMPAD_7: number; | |
1123 | NUMPAD_8: number; |
|
1123 | NUMPAD_8: number; | |
1124 | NUMPAD_9: number; |
|
1124 | NUMPAD_9: number; | |
1125 | NUMPAD_MULTIPLY: number; |
|
1125 | NUMPAD_MULTIPLY: number; | |
1126 | NUMPAD_PLUS: number; |
|
1126 | NUMPAD_PLUS: number; | |
1127 | NUMPAD_ENTER: number; |
|
1127 | NUMPAD_ENTER: number; | |
1128 | NUMPAD_MINUS: number; |
|
1128 | NUMPAD_MINUS: number; | |
1129 | NUMPAD_PERIOD: number; |
|
1129 | NUMPAD_PERIOD: number; | |
1130 | NUMPAD_DIVIDE: number; |
|
1130 | NUMPAD_DIVIDE: number; | |
1131 | F1: number; |
|
1131 | F1: number; | |
1132 | F2: number; |
|
1132 | F2: number; | |
1133 | F3: number; |
|
1133 | F3: number; | |
1134 | F4: number; |
|
1134 | F4: number; | |
1135 | F5: number; |
|
1135 | F5: number; | |
1136 | F6: number; |
|
1136 | F6: number; | |
1137 | F7: number; |
|
1137 | F7: number; | |
1138 | F8: number; |
|
1138 | F8: number; | |
1139 | F9: number; |
|
1139 | F9: number; | |
1140 | F10: number; |
|
1140 | F10: number; | |
1141 | F11: number; |
|
1141 | F11: number; | |
1142 | F12: number; |
|
1142 | F12: number; | |
1143 | F13: number; |
|
1143 | F13: number; | |
1144 | F14: number; |
|
1144 | F14: number; | |
1145 | F15: number; |
|
1145 | F15: number; | |
1146 | NUM_LOCK: number; |
|
1146 | NUM_LOCK: number; | |
1147 | SCROLL_LOCK: number; |
|
1147 | SCROLL_LOCK: number; | |
1148 | UP_DPAD: number; |
|
1148 | UP_DPAD: number; | |
1149 | DOWN_DPAD: number; |
|
1149 | DOWN_DPAD: number; | |
1150 | LEFT_DPAD: number; |
|
1150 | LEFT_DPAD: number; | |
1151 | RIGHT_DPAD: number; |
|
1151 | RIGHT_DPAD: number; | |
1152 | copyKey: number; |
|
1152 | copyKey: number; | |
1153 | } |
|
1153 | } | |
1154 |
|
1154 | |||
1155 | /* dojo/loadInit */ |
|
1155 | /* dojo/loadInit */ | |
1156 |
|
1156 | |||
1157 | interface LoadInit { |
|
1157 | interface LoadInit { | |
1158 | dynamic: number; |
|
1158 | dynamic: number; | |
1159 |
|
1159 | |||
1160 | /** |
|
1160 | /** | |
1161 | * Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s). |
|
1161 | * Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s). | |
1162 | */ |
|
1162 | */ | |
1163 | normalize(id: string, toAbsMid: Function): string; /* TODO: Align with loader api */ |
|
1163 | normalize(id: string, toAbsMid: Function): string; /* TODO: Align with loader api */ | |
1164 |
|
1164 | |||
1165 | /** |
|
1165 | /** | |
1166 | * Conditional loading of AMD modules based on a has feature test value. |
|
1166 | * Conditional loading of AMD modules based on a has feature test value. | |
1167 | */ |
|
1167 | */ | |
1168 | load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */ |
|
1168 | load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */ | |
1169 | } |
|
1169 | } | |
1170 |
|
1170 | |||
1171 | /* dojo/mouse */ |
|
1171 | /* dojo/mouse */ | |
1172 |
|
1172 | |||
1173 | interface Mouse { |
|
1173 | interface Mouse { | |
1174 | _eventHandler(type: string, selectHandler?: (evt: MouseEvent, listener: EventListener) => void): MouseEvent; |
|
1174 | _eventHandler(type: string, selectHandler?: (evt: MouseEvent, listener: EventListener) => void): MouseEvent; | |
1175 |
|
1175 | |||
1176 | /** |
|
1176 | /** | |
1177 | * This is an extension event for the mouseenter that IE provides, emulating the |
|
1177 | * This is an extension event for the mouseenter that IE provides, emulating the | |
1178 | * behavior on other browsers. |
|
1178 | * behavior on other browsers. | |
1179 | */ |
|
1179 | */ | |
1180 | enter: MouseEvent; |
|
1180 | enter: MouseEvent; | |
1181 |
|
1181 | |||
1182 | /** |
|
1182 | /** | |
1183 | * This is an extension event for the mouseleave that IE provides, emulating the |
|
1183 | * This is an extension event for the mouseleave that IE provides, emulating the | |
1184 | * behavior on other browsers. |
|
1184 | * behavior on other browsers. | |
1185 | */ |
|
1185 | */ | |
1186 | leave: MouseEvent; |
|
1186 | leave: MouseEvent; | |
1187 |
|
1187 | |||
1188 | /** |
|
1188 | /** | |
1189 | * This is an extension event for the mousewheel that non-Mozilla browsers provide, |
|
1189 | * This is an extension event for the mousewheel that non-Mozilla browsers provide, | |
1190 | * emulating the behavior on Mozilla based browsers. |
|
1190 | * emulating the behavior on Mozilla based browsers. | |
1191 | */ |
|
1191 | */ | |
1192 | wheel: string | ExtensionEvent; |
|
1192 | wheel: string | ExtensionEvent; | |
1193 |
|
1193 | |||
1194 | /** |
|
1194 | /** | |
1195 | * Test an event object (from a mousedown event) to see if the left button was pressed. |
|
1195 | * Test an event object (from a mousedown event) to see if the left button was pressed. | |
1196 | */ |
|
1196 | */ | |
1197 | isLeft(e: MouseEvent): boolean; |
|
1197 | isLeft(e: MouseEvent): boolean; | |
1198 |
|
1198 | |||
1199 | /** |
|
1199 | /** | |
1200 | * Test an event object (from a mousedown event) to see if the middle button was pressed. |
|
1200 | * Test an event object (from a mousedown event) to see if the middle button was pressed. | |
1201 | */ |
|
1201 | */ | |
1202 | isMiddle(e: MouseEvent): boolean; |
|
1202 | isMiddle(e: MouseEvent): boolean; | |
1203 |
|
1203 | |||
1204 | /** |
|
1204 | /** | |
1205 | * Test an event object (from a mousedown event) to see if the right button was pressed. |
|
1205 | * Test an event object (from a mousedown event) to see if the right button was pressed. | |
1206 | */ |
|
1206 | */ | |
1207 | isRight(e: MouseEvent): boolean; |
|
1207 | isRight(e: MouseEvent): boolean; | |
1208 | } |
|
1208 | } | |
1209 |
|
1209 | |||
1210 | /* dojo/node */ |
|
1210 | /* dojo/node */ | |
1211 |
|
1211 | |||
1212 | /* should only be used for re-exporting CommonJS modules */ |
|
1212 | /* should only be used for re-exporting CommonJS modules */ | |
1213 |
|
1213 | |||
1214 | /* dojo/NodeList */ |
|
1214 | /* dojo/NodeList */ | |
1215 |
|
1215 | |||
1216 | /* Just proxies dojo/query::NodeList */ |
|
1216 | /* Just proxies dojo/query::NodeList */ | |
1217 |
|
1217 | |||
1218 | /* dojo/NodeList-* are included as seperate .d.ts files */ |
|
1218 | /* dojo/NodeList-* are included as seperate .d.ts files */ | |
1219 |
|
1219 | |||
1220 | /* dojo/number */ |
|
1220 | /* dojo/number */ | |
1221 |
|
1221 | |||
1222 | interface NumberFormatOptions { |
|
1222 | interface NumberFormatOptions { | |
1223 |
|
1223 | |||
1224 | /** |
|
1224 | /** | |
1225 | * override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns) |
|
1225 | * override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns) | |
1226 | * with this string. Default value is based on locale. Overriding this property will defeat |
|
1226 | * with this string. Default value is based on locale. Overriding this property will defeat | |
1227 | * localization. Literal characters in patterns are not supported. |
|
1227 | * localization. Literal characters in patterns are not supported. | |
1228 | */ |
|
1228 | */ | |
1229 | pattern?: string; |
|
1229 | pattern?: string; | |
1230 |
|
1230 | |||
1231 | /** |
|
1231 | /** | |
1232 | * choose a format type based on the locale from the following: |
|
1232 | * choose a format type based on the locale from the following: | |
1233 | * decimal, scientific (not yet supported), percent, currency. decimal by default. |
|
1233 | * decimal, scientific (not yet supported), percent, currency. decimal by default. | |
1234 | */ |
|
1234 | */ | |
1235 | type?: string; |
|
1235 | type?: string; | |
1236 |
|
1236 | |||
1237 | /** |
|
1237 | /** | |
1238 | * fixed number of decimal places to show. This overrides any |
|
1238 | * fixed number of decimal places to show. This overrides any | |
1239 | * information in the provided pattern. |
|
1239 | * information in the provided pattern. | |
1240 | */ |
|
1240 | */ | |
1241 | places?: number; |
|
1241 | places?: number; | |
1242 |
|
1242 | |||
1243 | /** |
|
1243 | /** | |
1244 | * 5 rounds to nearest .5; 0 rounds to nearest whole (default). -1 |
|
1244 | * 5 rounds to nearest .5; 0 rounds to nearest whole (default). -1 | |
1245 | * means do not round. |
|
1245 | * means do not round. | |
1246 | */ |
|
1246 | */ | |
1247 | round?: number; |
|
1247 | round?: number; | |
1248 |
|
1248 | |||
1249 | /** |
|
1249 | /** | |
1250 | * override the locale used to determine formatting rules |
|
1250 | * override the locale used to determine formatting rules | |
1251 | */ |
|
1251 | */ | |
1252 | locale?: string; |
|
1252 | locale?: string; | |
1253 |
|
1253 | |||
1254 | /** |
|
1254 | /** | |
1255 | * If false, show no decimal places, overriding places and pattern settings. |
|
1255 | * If false, show no decimal places, overriding places and pattern settings. | |
1256 | */ |
|
1256 | */ | |
1257 | fractional?: boolean | [ boolean, boolean ]; |
|
1257 | fractional?: boolean | [ boolean, boolean ]; | |
1258 | } |
|
1258 | } | |
1259 |
|
1259 | |||
1260 | interface NumberFormatAbsoluteOptions { |
|
1260 | interface NumberFormatAbsoluteOptions { | |
1261 | /** |
|
1261 | /** | |
1262 | * the decimal separator |
|
1262 | * the decimal separator | |
1263 | */ |
|
1263 | */ | |
1264 | decimal?: string; |
|
1264 | decimal?: string; | |
1265 |
|
1265 | |||
1266 | /** |
|
1266 | /** | |
1267 | * the group separator |
|
1267 | * the group separator | |
1268 | */ |
|
1268 | */ | |
1269 | group?: string; |
|
1269 | group?: string; | |
1270 |
|
1270 | |||
1271 | /** |
|
1271 | /** | |
1272 | * number of decimal places. the range "n,m" will format to m places. |
|
1272 | * number of decimal places. the range "n,m" will format to m places. | |
1273 | */ |
|
1273 | */ | |
1274 | places?: number | string; |
|
1274 | places?: number | string; | |
1275 |
|
1275 | |||
1276 | /** |
|
1276 | /** | |
1277 | * 5 rounds to nearest .5; 0 rounds to nearest whole (default). -1 |
|
1277 | * 5 rounds to nearest .5; 0 rounds to nearest whole (default). -1 | |
1278 | * means don't round. |
|
1278 | * means don't round. | |
1279 | */ |
|
1279 | */ | |
1280 | round?: number; |
|
1280 | round?: number; | |
1281 | } |
|
1281 | } | |
1282 |
|
1282 | |||
1283 | interface NumberRegexpOptions { |
|
1283 | interface NumberRegexpOptions { | |
1284 |
|
1284 | |||
1285 | /** |
|
1285 | /** | |
1286 | * override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns) |
|
1286 | * override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns) | |
1287 | * with this string. Default value is based on locale. Overriding this property will defeat |
|
1287 | * with this string. Default value is based on locale. Overriding this property will defeat | |
1288 | * localization. |
|
1288 | * localization. | |
1289 | */ |
|
1289 | */ | |
1290 | pattern?: string; |
|
1290 | pattern?: string; | |
1291 |
|
1291 | |||
1292 | /** |
|
1292 | /** | |
1293 | * choose a format type based on the locale from the following: |
|
1293 | * choose a format type based on the locale from the following: | |
1294 | * decimal, scientific (not yet supported), percent, currency. decimal by default. |
|
1294 | * decimal, scientific (not yet supported), percent, currency. decimal by default. | |
1295 | */ |
|
1295 | */ | |
1296 | type?: string; |
|
1296 | type?: string; | |
1297 |
|
1297 | |||
1298 | /** |
|
1298 | /** | |
1299 | * override the locale used to determine formatting rules |
|
1299 | * override the locale used to determine formatting rules | |
1300 | */ |
|
1300 | */ | |
1301 | locacle?: string; |
|
1301 | locacle?: string; | |
1302 |
|
1302 | |||
1303 | /** |
|
1303 | /** | |
1304 | * strict parsing, false by default. Strict parsing requires input as produced by the format() method. |
|
1304 | * strict parsing, false by default. Strict parsing requires input as produced by the format() method. | |
1305 | * Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators |
|
1305 | * Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators | |
1306 | */ |
|
1306 | */ | |
1307 | strict?: boolean; |
|
1307 | strict?: boolean; | |
1308 |
|
1308 | |||
1309 | /** |
|
1309 | /** | |
1310 | * number of decimal places to accept: Infinity, a positive number, or |
|
1310 | * number of decimal places to accept: Infinity, a positive number, or | |
1311 | * a range "n,m". Defined by pattern or Infinity if pattern not provided. |
|
1311 | * a range "n,m". Defined by pattern or Infinity if pattern not provided. | |
1312 | */ |
|
1312 | */ | |
1313 | places?: number | string; |
|
1313 | places?: number | string; | |
1314 | } |
|
1314 | } | |
1315 |
|
1315 | |||
1316 | interface NumberParseOptions { |
|
1316 | interface NumberParseOptions { | |
1317 |
|
1317 | |||
1318 | /** |
|
1318 | /** | |
1319 | * override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns) |
|
1319 | * override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns) | |
1320 | * with this string. Default value is based on locale. Overriding this property will defeat |
|
1320 | * with this string. Default value is based on locale. Overriding this property will defeat | |
1321 | * localization. Literal characters in patterns are not supported. |
|
1321 | * localization. Literal characters in patterns are not supported. | |
1322 | */ |
|
1322 | */ | |
1323 | pattern?: string; |
|
1323 | pattern?: string; | |
1324 |
|
1324 | |||
1325 | /** |
|
1325 | /** | |
1326 | * choose a format type based on the locale from the following: |
|
1326 | * choose a format type based on the locale from the following: | |
1327 | * decimal, scientific (not yet supported), percent, currency. decimal by default. |
|
1327 | * decimal, scientific (not yet supported), percent, currency. decimal by default. | |
1328 | */ |
|
1328 | */ | |
1329 | type?: string; |
|
1329 | type?: string; | |
1330 |
|
1330 | |||
1331 | /** |
|
1331 | /** | |
1332 | * override the locale used to determine formatting rules |
|
1332 | * override the locale used to determine formatting rules | |
1333 | */ |
|
1333 | */ | |
1334 | locale?: string; |
|
1334 | locale?: string; | |
1335 |
|
1335 | |||
1336 | /** |
|
1336 | /** | |
1337 | * strict parsing, false by default. Strict parsing requires input as produced by the format() method. |
|
1337 | * strict parsing, false by default. Strict parsing requires input as produced by the format() method. | |
1338 | * Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators |
|
1338 | * Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators | |
1339 | */ |
|
1339 | */ | |
1340 | strict?: boolean; |
|
1340 | strict?: boolean; | |
1341 |
|
1341 | |||
1342 | /** |
|
1342 | /** | |
1343 | * Whether to include the fractional portion, where the number of decimal places are implied by pattern |
|
1343 | * Whether to include the fractional portion, where the number of decimal places are implied by pattern | |
1344 | * or explicit 'places' parameter. The value [true,false] makes the fractional portion optional. |
|
1344 | * or explicit 'places' parameter. The value [true,false] makes the fractional portion optional. | |
1345 | */ |
|
1345 | */ | |
1346 | fractional?: boolean | [boolean, boolean]; |
|
1346 | fractional?: boolean | [boolean, boolean]; | |
1347 | } |
|
1347 | } | |
1348 |
|
1348 | |||
1349 | interface RealNumberRegexpFlags { |
|
1349 | interface RealNumberRegexpFlags { | |
1350 |
|
1350 | |||
1351 | /** |
|
1351 | /** | |
1352 | * The integer number of decimal places or a range given as "n,m". If |
|
1352 | * The integer number of decimal places or a range given as "n,m". If | |
1353 | * not given, the decimal part is optional and the number of places is |
|
1353 | * not given, the decimal part is optional and the number of places is | |
1354 | * unlimited. |
|
1354 | * unlimited. | |
1355 | */ |
|
1355 | */ | |
1356 | places?: number; |
|
1356 | places?: number; | |
1357 |
|
1357 | |||
1358 | /** |
|
1358 | /** | |
1359 | * A string for the character used as the decimal point. Default |
|
1359 | * A string for the character used as the decimal point. Default | |
1360 | * is ".". |
|
1360 | * is ".". | |
1361 | */ |
|
1361 | */ | |
1362 | decimal?: string; |
|
1362 | decimal?: string; | |
1363 |
|
1363 | |||
1364 | /** |
|
1364 | /** | |
1365 | * Whether decimal places are used. Can be true, false, or [true, |
|
1365 | * Whether decimal places are used. Can be true, false, or [true, | |
1366 | * false]. Default is [true, false] which means optional. |
|
1366 | * false]. Default is [true, false] which means optional. | |
1367 | */ |
|
1367 | */ | |
1368 | fractional?: boolean | [boolean, boolean]; |
|
1368 | fractional?: boolean | [boolean, boolean]; | |
1369 |
|
1369 | |||
1370 | /** |
|
1370 | /** | |
1371 | * Express in exponential notation. Can be true, false, or [true, |
|
1371 | * Express in exponential notation. Can be true, false, or [true, | |
1372 | * false]. Default is [true, false], (i.e. will match if the |
|
1372 | * false]. Default is [true, false], (i.e. will match if the | |
1373 | * exponential part is present are not). |
|
1373 | * exponential part is present are not). | |
1374 | */ |
|
1374 | */ | |
1375 | exponent?: boolean | [boolean, boolean]; |
|
1375 | exponent?: boolean | [boolean, boolean]; | |
1376 |
|
1376 | |||
1377 | /** |
|
1377 | /** | |
1378 | * The leading plus-or-minus sign on the exponent. Can be true, |
|
1378 | * The leading plus-or-minus sign on the exponent. Can be true, | |
1379 | * false, or [true, false]. Default is [true, false], (i.e. will |
|
1379 | * false, or [true, false]. Default is [true, false], (i.e. will | |
1380 | * match if it is signed or unsigned). flags in regexp.integer can be |
|
1380 | * match if it is signed or unsigned). flags in regexp.integer can be | |
1381 | * applied. |
|
1381 | * applied. | |
1382 | */ |
|
1382 | */ | |
1383 | eSigned?: boolean | [boolean, boolean]; |
|
1383 | eSigned?: boolean | [boolean, boolean]; | |
1384 | } |
|
1384 | } | |
1385 |
|
1385 | |||
1386 | interface IntegerRegexpFlags { |
|
1386 | interface IntegerRegexpFlags { | |
1387 |
|
1387 | |||
1388 | /** |
|
1388 | /** | |
1389 | * The leading plus-or-minus sign. Can be true, false, or `[true,false]`. |
|
1389 | * The leading plus-or-minus sign. Can be true, false, or `[true,false]`. | |
1390 | * Default is `[true, false]`, (i.e. will match if it is signed |
|
1390 | * Default is `[true, false]`, (i.e. will match if it is signed | |
1391 | * or unsigned). |
|
1391 | * or unsigned). | |
1392 | */ |
|
1392 | */ | |
1393 | signed?: boolean; |
|
1393 | signed?: boolean; | |
1394 |
|
1394 | |||
1395 | /** |
|
1395 | /** | |
1396 | * The character used as the thousands separator. Default is no |
|
1396 | * The character used as the thousands separator. Default is no | |
1397 | * separator. For more than one symbol use an array, e.g. `[",", ""]`, |
|
1397 | * separator. For more than one symbol use an array, e.g. `[",", ""]`, | |
1398 | * makes ',' optional. |
|
1398 | * makes ',' optional. | |
1399 | */ |
|
1399 | */ | |
1400 | separator?: string; |
|
1400 | separator?: string; | |
1401 |
|
1401 | |||
1402 | /** |
|
1402 | /** | |
1403 | * group size between separators |
|
1403 | * group size between separators | |
1404 | */ |
|
1404 | */ | |
1405 | groupSize?: number; |
|
1405 | groupSize?: number; | |
1406 |
|
1406 | |||
1407 | /** |
|
1407 | /** | |
1408 | * second grouping, where separators 2..n have a different interval than the first separator (for India) |
|
1408 | * second grouping, where separators 2..n have a different interval than the first separator (for India) | |
1409 | */ |
|
1409 | */ | |
1410 | groupSize2?: number; |
|
1410 | groupSize2?: number; | |
1411 | } |
|
1411 | } | |
1412 |
|
1412 | |||
1413 | interface Number { |
|
1413 | interface Number { | |
1414 | /** |
|
1414 | /** | |
1415 | * Format a Number as a String, using locale-specific settings |
|
1415 | * Format a Number as a String, using locale-specific settings | |
1416 | */ |
|
1416 | */ | |
1417 | format(value: number, options?: NumberFormatOptions): string; |
|
1417 | format(value: number, options?: NumberFormatOptions): string; | |
1418 |
|
1418 | |||
1419 | /** |
|
1419 | /** | |
1420 | * not precise, but good enough |
|
1420 | * not precise, but good enough | |
1421 | */ |
|
1421 | */ | |
1422 | _numberPatternRE: RegExp; |
|
1422 | _numberPatternRE: RegExp; | |
1423 |
|
1423 | |||
1424 | /** |
|
1424 | /** | |
1425 | * Apply pattern to format value as a string using options. Gives no |
|
1425 | * Apply pattern to format value as a string using options. Gives no | |
1426 | * consideration to local customs. |
|
1426 | * consideration to local customs. | |
1427 | */ |
|
1427 | */ | |
1428 | _applyPattern(value: number, pattern: string, options?: NumberFormatOptions): string; |
|
1428 | _applyPattern(value: number, pattern: string, options?: NumberFormatOptions): string; | |
1429 |
|
1429 | |||
1430 | /** |
|
1430 | /** | |
1431 | * Rounds to the nearest value with the given number of decimal places, away from zero |
|
1431 | * Rounds to the nearest value with the given number of decimal places, away from zero | |
1432 | */ |
|
1432 | */ | |
1433 | round(value: number, places?: number, increment?: number): number; |
|
1433 | round(value: number, places?: number, increment?: number): number; | |
1434 |
|
1434 | |||
1435 | /** |
|
1435 | /** | |
1436 | * Apply numeric pattern to absolute value using options. Gives no |
|
1436 | * Apply numeric pattern to absolute value using options. Gives no | |
1437 | * consideration to local customs. |
|
1437 | * consideration to local customs. | |
1438 | */ |
|
1438 | */ | |
1439 | _formatAbsolute(value: number, pattern: string, options?: NumberFormatAbsoluteOptions): string; |
|
1439 | _formatAbsolute(value: number, pattern: string, options?: NumberFormatAbsoluteOptions): string; | |
1440 |
|
1440 | |||
1441 | /** |
|
1441 | /** | |
1442 | * Builds the regular needed to parse a number |
|
1442 | * Builds the regular needed to parse a number | |
1443 | */ |
|
1443 | */ | |
1444 | regexp(options?: NumberRegexpOptions): string; |
|
1444 | regexp(options?: NumberRegexpOptions): string; | |
1445 |
|
1445 | |||
1446 | _parseInfo(options?: any): { regexp: string, group: string, decimal: string, factor: number }; |
|
1446 | _parseInfo(options?: any): { regexp: string, group: string, decimal: string, factor: number }; | |
1447 |
|
1447 | |||
1448 | /** |
|
1448 | /** | |
1449 | * Convert a properly formatted string to a primitive Number, using |
|
1449 | * Convert a properly formatted string to a primitive Number, using | |
1450 | * locale-specific settings. |
|
1450 | * locale-specific settings. | |
1451 | */ |
|
1451 | */ | |
1452 | parse(expression: string, options?: NumberParseOptions): number; |
|
1452 | parse(expression: string, options?: NumberParseOptions): number; | |
1453 |
|
1453 | |||
1454 | /** |
|
1454 | /** | |
1455 | * Builds a regular expression to match a real number in exponential |
|
1455 | * Builds a regular expression to match a real number in exponential | |
1456 | * notation |
|
1456 | * notation | |
1457 | */ |
|
1457 | */ | |
1458 | _realNumberRegexp(flags: RealNumberRegexpFlags): string; |
|
1458 | _realNumberRegexp(flags: RealNumberRegexpFlags): string; | |
1459 |
|
1459 | |||
1460 | /** |
|
1460 | /** | |
1461 | * Builds a regular expression that matches an integer |
|
1461 | * Builds a regular expression that matches an integer | |
1462 | */ |
|
1462 | */ | |
1463 | _integerRegexp(flags: IntegerRegexpFlags): string; |
|
1463 | _integerRegexp(flags: IntegerRegexpFlags): string; | |
1464 | } |
|
1464 | } | |
1465 |
|
1465 | |||
1466 | /* dojo/on */ |
|
1466 | /* dojo/on */ | |
1467 |
|
1467 | |||
1468 | interface ExtensionEvent { |
|
1468 | interface ExtensionEvent { | |
1469 | (target: Element | GenericObject, listener: EventListener): Handle; |
|
1469 | (target: Element | GenericObject, listener: EventListener): Handle; | |
1470 | } |
|
1470 | } | |
1471 |
|
1471 | |||
1472 | interface PauseHandle extends Handle { |
|
1472 | interface PauseHandle extends Handle { | |
1473 | pause(): void; |
|
1473 | pause(): void; | |
1474 | resume(): void; |
|
1474 | resume(): void; | |
1475 | } |
|
1475 | } | |
1476 |
|
1476 | |||
1477 | interface MatchesTarget { |
|
1477 | interface MatchesTarget { | |
1478 | matches(node: Element, selector: string, context?: any): any[]; |
|
1478 | matches(node: Element, selector: string, context?: any): any[]; | |
1479 | [id: string]: any; |
|
1479 | [id: string]: any; | |
1480 | } |
|
1480 | } | |
1481 |
|
1481 | |||
1482 | interface On { |
|
1482 | interface On { | |
1483 | /** |
|
1483 | /** | |
1484 | * A function that provides core event listening functionality. With this function |
|
1484 | * A function that provides core event listening functionality. With this function | |
1485 | * you can provide a target, event type, and listener to be notified of |
|
1485 | * you can provide a target, event type, and listener to be notified of | |
1486 | * future matching events that are fired. |
|
1486 | * future matching events that are fired. | |
1487 | */ |
|
1487 | */ | |
1488 | (target: Element | GenericObject, type: string | ExtensionEvent, listener: EventListener | Function, dontFix?: boolean): Handle; |
|
1488 | (target: Element | GenericObject, type: string | ExtensionEvent, listener: EventListener | Function, dontFix?: boolean): Handle; | |
1489 |
|
1489 | |||
1490 | /** |
|
1490 | /** | |
1491 | * This function acts the same as on(), but with pausable functionality. The |
|
1491 | * This function acts the same as on(), but with pausable functionality. The | |
1492 | * returned signal object has pause() and resume() functions. Calling the |
|
1492 | * returned signal object has pause() and resume() functions. Calling the | |
1493 | * pause() method will cause the listener to not be called for future events. |
|
1493 | * pause() method will cause the listener to not be called for future events. | |
1494 | */ |
|
1494 | */ | |
1495 | pausable(target: Element | GenericObject, type: string | ExtensionEvent, listener: EventListener | Function, dontFix?: boolean): PauseHandle; |
|
1495 | pausable(target: Element | GenericObject, type: string | ExtensionEvent, listener: EventListener | Function, dontFix?: boolean): PauseHandle; | |
1496 |
|
1496 | |||
1497 | /** |
|
1497 | /** | |
1498 | * This function acts the same as on(), but will only call the listener once. The |
|
1498 | * This function acts the same as on(), but will only call the listener once. The | |
1499 | * listener will be called for the first |
|
1499 | * listener will be called for the first | |
1500 | * event that takes place and then listener will automatically be removed. |
|
1500 | * event that takes place and then listener will automatically be removed. | |
1501 | */ |
|
1501 | */ | |
1502 | once(target: Element | GenericObject, type: string | ExtensionEvent, listener: EventListener | Function, dontFix?: boolean): Handle; |
|
1502 | once(target: Element | GenericObject, type: string | ExtensionEvent, listener: EventListener | Function, dontFix?: boolean): Handle; | |
1503 |
|
1503 | |||
1504 | parse(target: Element | GenericObject, type: string | ExtensionEvent, listener: EventListener | Function, dontFix: boolean, matchesTarget: Element | GenericObject): Handle; |
|
1504 | parse(target: Element | GenericObject, type: string | ExtensionEvent, listener: EventListener | Function, dontFix: boolean, matchesTarget: Element | GenericObject): Handle; | |
1505 |
|
1505 | |||
1506 | /** |
|
1506 | /** | |
1507 | * Check if a node match the current selector within the constraint of a context |
|
1507 | * Check if a node match the current selector within the constraint of a context | |
1508 | */ |
|
1508 | */ | |
1509 | matches(node: Element, selector: string, context: Element, children: boolean, matchesTarget?: MatchesTarget): Element | boolean; |
|
1509 | matches(node: Element, selector: string, context: Element, children: boolean, matchesTarget?: MatchesTarget): Element | boolean; | |
1510 |
|
1510 | |||
1511 | /** |
|
1511 | /** | |
1512 | * Creates a new extension event with event delegation. This is based on |
|
1512 | * Creates a new extension event with event delegation. This is based on | |
1513 | * the provided event type (can be extension event) that |
|
1513 | * the provided event type (can be extension event) that | |
1514 | * only calls the listener when the CSS selector matches the target of the event. |
|
1514 | * only calls the listener when the CSS selector matches the target of the event. | |
1515 | * |
|
1515 | * | |
1516 | * The application must require() an appropriate level of dojo/query to handle the selector. |
|
1516 | * The application must require() an appropriate level of dojo/query to handle the selector. | |
1517 | */ |
|
1517 | */ | |
1518 | selector(selector: string, type: string | ExtensionEvent, children?: boolean): ExtensionEvent; |
|
1518 | selector(selector: string, type: string | ExtensionEvent, children?: boolean): ExtensionEvent; | |
1519 |
|
1519 | |||
1520 | /** |
|
1520 | /** | |
1521 | * Fires an event on the target object. |
|
1521 | * Fires an event on the target object. | |
1522 | */ |
|
1522 | */ | |
1523 | emit(target: Element | GenericObject, type: string | ExtensionEvent, event?: any): boolean; |
|
1523 | emit(target: Element | GenericObject, type: string | ExtensionEvent, event?: any): boolean; | |
1524 |
|
1524 | |||
1525 | /** |
|
1525 | /** | |
1526 | * normalizes properties on the event object including event |
|
1526 | * normalizes properties on the event object including event | |
1527 | * bubbling methods, keystroke normalization, and x/y positions |
|
1527 | * bubbling methods, keystroke normalization, and x/y positions | |
1528 | */ |
|
1528 | */ | |
1529 | _fixEvent(evt: any, sender: any): any; |
|
1529 | _fixEvent(evt: any, sender: any): any; | |
1530 | } |
|
1530 | } | |
1531 |
|
1531 | |||
1532 | /* dojo/parser */ |
|
1532 | /* dojo/parser */ | |
1533 |
|
1533 | |||
1534 | interface ParserOptions { } |
|
1534 | interface ParserOptions { } | |
1535 |
|
1535 | |||
1536 | interface ParserObjects { |
|
1536 | interface ParserObjects { | |
1537 | ctor?: GenericConstructor<any>; |
|
1537 | ctor?: GenericConstructor<any>; | |
1538 | types?: string[]; |
|
1538 | types?: string[]; | |
1539 | node: Node; |
|
1539 | node: Node; | |
1540 | scripts?: HTMLScriptElement[]; |
|
1540 | scripts?: HTMLScriptElement[]; | |
1541 | inherited?: { [prop: string]: any; }; |
|
1541 | inherited?: { [prop: string]: any; }; | |
1542 | } |
|
1542 | } | |
1543 |
|
1543 | |||
1544 | interface InstancesArray extends Array<any>, promise.Promise<any> {} |
|
1544 | interface InstancesArray extends Array<any>, promise.Promise<any> {} | |
1545 |
|
1545 | |||
1546 | interface Parser { |
|
1546 | interface Parser { | |
1547 | /** |
|
1547 | /** | |
1548 | * Clear cached data. Used mainly for benchmarking. |
|
1548 | * Clear cached data. Used mainly for benchmarking. | |
1549 | */ |
|
1549 | */ | |
1550 | _clearCache(): void; |
|
1550 | _clearCache(): void; | |
1551 |
|
1551 | |||
1552 | /** |
|
1552 | /** | |
1553 | * Convert a `<script type="dojo/method" args="a, b, c"> ... </script>` |
|
1553 | * Convert a `<script type="dojo/method" args="a, b, c"> ... </script>` | |
1554 | * into a function |
|
1554 | * into a function | |
1555 | */ |
|
1555 | */ | |
1556 | _functionFromScript(node: HTMLScriptElement, attrData: string): Function; |
|
1556 | _functionFromScript(node: HTMLScriptElement, attrData: string): Function; | |
1557 |
|
1557 | |||
1558 | /** |
|
1558 | /** | |
1559 | * Takes array of nodes, and turns them into class instances and |
|
1559 | * Takes array of nodes, and turns them into class instances and | |
1560 | * potentially calls a startup method to allow them to connect with |
|
1560 | * potentially calls a startup method to allow them to connect with | |
1561 | * any children. |
|
1561 | * any children. | |
1562 | */ |
|
1562 | */ | |
1563 | instantiate(nodes: Node[], mixin?: Object, options?: ParserOptions): any[]; |
|
1563 | instantiate(nodes: Node[], mixin?: Object, options?: ParserOptions): any[]; | |
1564 |
|
1564 | |||
1565 | /** |
|
1565 | /** | |
1566 | * Takes array of objects representing nodes, and turns them into class instances and |
|
1566 | * Takes array of objects representing nodes, and turns them into class instances and | |
1567 | * potentially calls a startup method to allow them to connect with |
|
1567 | * potentially calls a startup method to allow them to connect with | |
1568 | * any children. |
|
1568 | * any children. | |
1569 | */ |
|
1569 | */ | |
1570 | _instantiate(nodes: ParserObjects[], mixin?: Object, options?: ParserOptions, returnPromise?: boolean): any[] | promise.Promise<any[]>; |
|
1570 | _instantiate(nodes: ParserObjects[], mixin?: Object, options?: ParserOptions, returnPromise?: boolean): any[] | promise.Promise<any[]>; | |
1571 |
|
1571 | |||
1572 | /** |
|
1572 | /** | |
1573 | * Calls new ctor(params, node), where params is the hash of parameters specified on the node, |
|
1573 | * Calls new ctor(params, node), where params is the hash of parameters specified on the node, | |
1574 | * excluding data-dojo-type and data-dojo-mixins. Does not call startup(). |
|
1574 | * excluding data-dojo-type and data-dojo-mixins. Does not call startup(). | |
1575 | */ |
|
1575 | */ | |
1576 | construct<T>( |
|
1576 | construct<T>( | |
1577 | ctor: GenericConstructor<T>, |
|
1577 | ctor: GenericConstructor<T>, | |
1578 | node: Node, mixin?: Object, |
|
1578 | node: Node, mixin?: Object, | |
1579 | options?: ParserOptions, |
|
1579 | options?: ParserOptions, | |
1580 | scripts?: HTMLScriptElement[], |
|
1580 | scripts?: HTMLScriptElement[], | |
1581 | inherited?: { [prop: string]: any; } |
|
1581 | inherited?: { [prop: string]: any; } | |
1582 | ): promise.Promise<T> | T; |
|
1582 | ): promise.Promise<T> | T; | |
1583 |
|
1583 | |||
1584 | /** |
|
1584 | /** | |
1585 | * Scan a DOM tree and return an array of objects representing the DOMNodes |
|
1585 | * Scan a DOM tree and return an array of objects representing the DOMNodes | |
1586 | * that need to be turned into widgets. |
|
1586 | * that need to be turned into widgets. | |
1587 | */ |
|
1587 | */ | |
1588 | scan(root?: Node, options?: ParserOptions): promise.Promise<ParserObjects[]>; |
|
1588 | scan(root?: Node, options?: ParserOptions): promise.Promise<ParserObjects[]>; | |
1589 |
|
1589 | |||
1590 | /** |
|
1590 | /** | |
1591 | * Helper for _scanAMD(). Takes a `<script type=dojo/require>bar: "acme/bar", ...</script>` node, |
|
1591 | * Helper for _scanAMD(). Takes a `<script type=dojo/require>bar: "acme/bar", ...</script>` node, | |
1592 | * calls require() to load the specified modules and (asynchronously) assign them to the specified global |
|
1592 | * calls require() to load the specified modules and (asynchronously) assign them to the specified global | |
1593 | * variables, and returns a Promise for when that operation completes. |
|
1593 | * variables, and returns a Promise for when that operation completes. | |
1594 | * |
|
1594 | * | |
1595 | * In the example above, it is effectively doing a require(["acme/bar", ...], function(a){ bar = a; }). |
|
1595 | * In the example above, it is effectively doing a require(["acme/bar", ...], function(a){ bar = a; }). | |
1596 | */ |
|
1596 | */ | |
1597 | _require(script: HTMLScriptElement, options: ParserOptions): promise.Promise<any>; |
|
1597 | _require(script: HTMLScriptElement, options: ParserOptions): promise.Promise<any>; | |
1598 |
|
1598 | |||
1599 | /** |
|
1599 | /** | |
1600 | * Scans the DOM for any declarative requires and returns their values. |
|
1600 | * Scans the DOM for any declarative requires and returns their values. | |
1601 | */ |
|
1601 | */ | |
1602 | _scanAmd(root?: Node, options?: ParserOptions): promise.Promise<boolean>; |
|
1602 | _scanAmd(root?: Node, options?: ParserOptions): promise.Promise<boolean>; | |
1603 |
|
1603 | |||
1604 | /** |
|
1604 | /** | |
1605 | * Scan the DOM for class instances, and instantiate them. |
|
1605 | * Scan the DOM for class instances, and instantiate them. | |
1606 | */ |
|
1606 | */ | |
1607 | parse(rootNode?: Node, options?: ParserOptions): InstancesArray; |
|
1607 | parse(rootNode?: Node, options?: ParserOptions): InstancesArray; | |
1608 | } |
|
1608 | } | |
1609 |
|
1609 | |||
1610 | /* dojo/query */ |
|
1610 | /* dojo/query */ | |
1611 |
|
1611 | |||
1612 | interface NodeListFilterCallback<T extends Node> { |
|
1612 | interface NodeListFilterCallback<T extends Node> { | |
1613 | (item: T, idx: number, nodeList: this): boolean; |
|
1613 | (item: T, idx: number, nodeList: this): boolean; | |
1614 | } |
|
1614 | } | |
1615 |
|
1615 | |||
1616 | type NodeListFilter<T extends Node> = string | NodeListFilterCallback<T>; |
|
1616 | type NodeListFilter<T extends Node> = string | NodeListFilterCallback<T>; | |
1617 |
|
1617 | |||
1618 | interface NodeList<T extends Node> extends ArrayLike<T> { |
|
1618 | interface NodeList<T extends Node> extends ArrayLike<T> { | |
1619 | /** |
|
1619 | /** | |
1620 | * decorate an array to make it look like a `dojo/NodeList`. |
|
1620 | * decorate an array to make it look like a `dojo/NodeList`. | |
1621 | */ |
|
1621 | */ | |
1622 | _wrap<U extends Node, V extends Node>(a: U[], parent?: NodeList<V>, NodeListCtor?: NodeListConstructor): NodeList<U>; |
|
1622 | _wrap<U extends Node, V extends Node>(a: U[], parent?: NodeList<V>, NodeListCtor?: NodeListConstructor): NodeList<U>; | |
1623 |
|
1623 | |||
1624 | _NodeListCtor: NodeListConstructor; |
|
1624 | _NodeListCtor: NodeListConstructor; | |
1625 | toString(): string; |
|
1625 | toString(): string; | |
1626 |
|
1626 | |||
1627 | /** |
|
1627 | /** | |
1628 | * private function to hold to a parent NodeList. end() to return the parent NodeList. |
|
1628 | * private function to hold to a parent NodeList. end() to return the parent NodeList. | |
1629 | */ |
|
1629 | */ | |
1630 | _stash(parent: Node): this; |
|
1630 | _stash(parent: Node): this; | |
1631 |
|
1631 | |||
1632 | /** |
|
1632 | /** | |
1633 | * Listen for events on the nodes in the NodeList. |
|
1633 | * Listen for events on the nodes in the NodeList. | |
1634 | */ |
|
1634 | */ | |
1635 | on(eventName: string, listener: EventListener): Handle[]; |
|
1635 | on(eventName: string, listener: EventListener): Handle[]; | |
1636 |
|
1636 | |||
1637 | /** |
|
1637 | /** | |
1638 | * Ends use of the current `NodeList` by returning the previous NodeList |
|
1638 | * Ends use of the current `NodeList` by returning the previous NodeList | |
1639 | * that generated the current NodeList. |
|
1639 | * that generated the current NodeList. | |
1640 | */ |
|
1640 | */ | |
1641 | end<U extends Node>(): NodeList<U>; |
|
1641 | end<U extends Node>(): NodeList<U>; | |
1642 |
|
1642 | |||
1643 | /** |
|
1643 | /** | |
1644 | * Returns a new NodeList, maintaining this one in place |
|
1644 | * Returns a new NodeList, maintaining this one in place | |
1645 | */ |
|
1645 | */ | |
1646 | slice(begin: number, end?: number): this; |
|
1646 | slice(begin: number, end?: number): this; | |
1647 |
|
1647 | |||
1648 | /** |
|
1648 | /** | |
1649 | * Returns a new NodeList, manipulating this NodeList based on |
|
1649 | * Returns a new NodeList, manipulating this NodeList based on | |
1650 | * the arguments passed, potentially splicing in new elements |
|
1650 | * the arguments passed, potentially splicing in new elements | |
1651 | * at an offset, optionally deleting elements |
|
1651 | * at an offset, optionally deleting elements | |
1652 | */ |
|
1652 | */ | |
1653 | splice(index: number, howmany?: number, ...items: T[]): this; |
|
1653 | splice(index: number, howmany?: number, ...items: T[]): this; | |
1654 |
|
1654 | |||
1655 | /** |
|
1655 | /** | |
1656 | * see `dojo/_base/array.indexOf()`. The primary difference is that the acted-on |
|
1656 | * see `dojo/_base/array.indexOf()`. The primary difference is that the acted-on | |
1657 | * array is implicitly this NodeList |
|
1657 | * array is implicitly this NodeList | |
1658 | */ |
|
1658 | */ | |
1659 | indexOf(value: T, fromIndex?: number, findLast?: boolean): number; |
|
1659 | indexOf(value: T, fromIndex?: number, findLast?: boolean): number; | |
1660 |
|
1660 | |||
1661 | /** |
|
1661 | /** | |
1662 | * see `dojo/_base/array.lastIndexOf()`. The primary difference is that the |
|
1662 | * see `dojo/_base/array.lastIndexOf()`. The primary difference is that the | |
1663 | * acted-on array is implicitly this NodeList |
|
1663 | * acted-on array is implicitly this NodeList | |
1664 | */ |
|
1664 | */ | |
1665 | lastIndexOf(value: T, fromIndex?: number): number; |
|
1665 | lastIndexOf(value: T, fromIndex?: number): number; | |
1666 |
|
1666 | |||
1667 | /** |
|
1667 | /** | |
1668 | * see `dojo/_base/array.every()` and the [Array.every |
|
1668 | * see `dojo/_base/array.every()` and the [Array.every | |
1669 | * docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every). |
|
1669 | * docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every). | |
1670 | * Takes the same structure of arguments and returns as |
|
1670 | * Takes the same structure of arguments and returns as | |
1671 | * dojo/_base/array.every() with the caveat that the passed array is |
|
1671 | * dojo/_base/array.every() with the caveat that the passed array is | |
1672 | * implicitly this NodeList |
|
1672 | * implicitly this NodeList | |
1673 | */ |
|
1673 | */ | |
1674 | every(callback: (item: T, idx: number, nodeList: this) => boolean | string, thisObj?: Object): boolean; |
|
1674 | every(callback: (item: T, idx: number, nodeList: this) => boolean | string, thisObj?: Object): boolean; | |
1675 |
|
1675 | |||
1676 | /** |
|
1676 | /** | |
1677 | * Takes the same structure of arguments and returns as |
|
1677 | * Takes the same structure of arguments and returns as | |
1678 | * `dojo/_base/array.some()` with the caveat that the passed array as |
|
1678 | * `dojo/_base/array.some()` with the caveat that the passed array as | |
1679 | * implicitly this NodeList. See `dojo/_base/array.some()` and Mozillaas |
|
1679 | * implicitly this NodeList. See `dojo/_base/array.some()` and Mozillaas | |
1680 | * [Array.soas |
|
1680 | * [Array.soas | |
1681 | * documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some). |
|
1681 | * documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some). | |
1682 | */ |
|
1682 | */ | |
1683 | some(callback: (item: T, idx: number, nodeList: this) => boolean | string, thisObj?: Object): boolean; |
|
1683 | some(callback: (item: T, idx: number, nodeList: this) => boolean | string, thisObj?: Object): boolean; | |
1684 |
|
1684 | |||
1685 | /** |
|
1685 | /** | |
1686 | * Returns a new NodeList comprised of items in this NodeList |
|
1686 | * Returns a new NodeList comprised of items in this NodeList | |
1687 | * as well as items passed in as parameters |
|
1687 | * as well as items passed in as parameters | |
1688 | */ |
|
1688 | */ | |
1689 | concat(...items: T[]): this; |
|
1689 | concat(...items: T[]): this; | |
1690 |
|
1690 | |||
1691 | /** |
|
1691 | /** | |
1692 | * see `dojo/_base/array.map()`. The primary difference is that the acted-on |
|
1692 | * see `dojo/_base/array.map()`. The primary difference is that the acted-on | |
1693 | * array is implicitly this NodeList and the return is a |
|
1693 | * array is implicitly this NodeList and the return is a | |
1694 | * NodeList (a subclass of Array) |
|
1694 | * NodeList (a subclass of Array) | |
1695 | */ |
|
1695 | */ | |
1696 | map<U extends Node>(func: (item: T, idx: number, nodeList: this) => U, obj?: Object): NodeList<U>; |
|
1696 | map<U extends Node>(func: (item: T, idx: number, nodeList: this) => U, obj?: Object): NodeList<U>; | |
1697 |
|
1697 | |||
1698 | /** |
|
1698 | /** | |
1699 | * see `dojo/_base/array.forEach()`. The primary difference is that the acted-on |
|
1699 | * see `dojo/_base/array.forEach()`. The primary difference is that the acted-on | |
1700 | * array is implicitly this NodeList. If you want the option to break out |
|
1700 | * array is implicitly this NodeList. If you want the option to break out | |
1701 | * of the forEach loop, use every() or some() instead. |
|
1701 | * of the forEach loop, use every() or some() instead. | |
1702 | */ |
|
1702 | */ | |
1703 | forEach(callback: (item: T, idx: number, nodeList: this) => void, thisObj?: Object): this; |
|
1703 | forEach(callback: (item: T, idx: number, nodeList: this) => void, thisObj?: Object): this; | |
1704 |
|
1704 | |||
1705 | /** |
|
1705 | /** | |
1706 | * "masks" the built-in javascript filter() method (supported |
|
1706 | * "masks" the built-in javascript filter() method (supported | |
1707 | * in Dojo via `dojo/_base/array.filter`) to support passing a simple |
|
1707 | * in Dojo via `dojo/_base/array.filter`) to support passing a simple | |
1708 | * string filter in addition to supporting filtering function |
|
1708 | * string filter in addition to supporting filtering function | |
1709 | * objects. |
|
1709 | * objects. | |
1710 | */ |
|
1710 | */ | |
1711 | filter<U extends Node>(filter: NodeListFilter<T>, thisObj?: Object): NodeList<U>; |
|
1711 | filter<U extends Node>(filter: NodeListFilter<T>, thisObj?: Object): NodeList<U>; | |
1712 |
|
1712 | |||
1713 | /** |
|
1713 | /** | |
1714 | * Create a new instance of a specified class, using the |
|
1714 | * Create a new instance of a specified class, using the | |
1715 | * specified properties and each node in the NodeList as a |
|
1715 | * specified properties and each node in the NodeList as a | |
1716 | * srcNodeRef. |
|
1716 | * srcNodeRef. | |
1717 | */ |
|
1717 | */ | |
1718 | instantiate(declaredClass: string | GenericConstructor<any>, properties?: Object): this; |
|
1718 | instantiate(declaredClass: string | GenericConstructor<any>, properties?: Object): this; | |
1719 |
|
1719 | |||
1720 | /** |
|
1720 | /** | |
1721 | * Returns a new NodeList comprised of items in this NodeList |
|
1721 | * Returns a new NodeList comprised of items in this NodeList | |
1722 | * at the given index or indices. |
|
1722 | * at the given index or indices. | |
1723 | */ |
|
1723 | */ | |
1724 | at(...indices: number[]): this; |
|
1724 | at(...indices: number[]): this; | |
1725 |
|
1725 | |||
1726 | } |
|
1726 | } | |
1727 |
|
1727 | |||
1728 | interface NodeListConstructor { |
|
1728 | interface NodeListConstructor { | |
1729 | new <T extends Node>(array: number | Array<T>): NodeList<T>; |
|
1729 | new <T extends Node>(array: number | Array<T>): NodeList<T>; | |
1730 | new <T extends Node>(...args: T[]): NodeList<T>; |
|
1730 | new <T extends Node>(...args: T[]): NodeList<T>; | |
1731 | <T extends Node>(array: number | Array<T>): NodeList<T>; |
|
1731 | <T extends Node>(array: number | Array<T>): NodeList<T>; | |
1732 | <T extends Node>(...args: T[]): NodeList<T>; |
|
1732 | <T extends Node>(...args: T[]): NodeList<T>; | |
1733 |
|
1733 | |||
1734 | prototype: NodeList<any>; |
|
1734 | prototype: NodeList<any>; | |
1735 |
|
1735 | |||
1736 | /** |
|
1736 | /** | |
1737 | * decorate an array to make it look like a `dojo/NodeList`. |
|
1737 | * decorate an array to make it look like a `dojo/NodeList`. | |
1738 | */ |
|
1738 | */ | |
1739 | _wrap<U extends Node, V extends Node>(a: U[], parent?: NodeList<V>, NodeListCtor?: NodeListConstructor): NodeList<U>; |
|
1739 | _wrap<U extends Node, V extends Node>(a: U[], parent?: NodeList<V>, NodeListCtor?: NodeListConstructor): NodeList<U>; | |
1740 |
|
1740 | |||
1741 | /** |
|
1741 | /** | |
1742 | * adapts a single node function to be used in the map-type |
|
1742 | * adapts a single node function to be used in the map-type | |
1743 | * actions. The return is a new array of values, as via `dojo/_base/array.map` |
|
1743 | * actions. The return is a new array of values, as via `dojo/_base/array.map` | |
1744 | */ |
|
1744 | */ | |
1745 | _adaptAsMap<T extends Node, U extends Node>(f: (node: T) => U, o?: Object): NodeList<U>; |
|
1745 | _adaptAsMap<T extends Node, U extends Node>(f: (node: T) => U, o?: Object): NodeList<U>; | |
1746 |
|
1746 | |||
1747 | /** |
|
1747 | /** | |
1748 | * adapts a single node function to be used in the forEach-type |
|
1748 | * adapts a single node function to be used in the forEach-type | |
1749 | * actions. The initial object is returned from the specialized |
|
1749 | * actions. The initial object is returned from the specialized | |
1750 | * function. |
|
1750 | * function. | |
1751 | */ |
|
1751 | */ | |
1752 | _adaptAsForEach<T extends Node>(f: (node: T) => void, o?: Object): this; |
|
1752 | _adaptAsForEach<T extends Node>(f: (node: T) => void, o?: Object): this; | |
1753 |
|
1753 | |||
1754 | /** |
|
1754 | /** | |
1755 | * adapts a single node function to be used in the filter-type actions |
|
1755 | * adapts a single node function to be used in the filter-type actions | |
1756 | */ |
|
1756 | */ | |
1757 | _adaptAsFilter<T extends Node>(f: (node: T) => boolean, o?: Object): this; |
|
1757 | _adaptAsFilter<T extends Node>(f: (node: T) => boolean, o?: Object): this; | |
1758 |
|
1758 | |||
1759 | /** |
|
1759 | /** | |
1760 | * adapts a single node function to be used in the map-type |
|
1760 | * adapts a single node function to be used in the map-type | |
1761 | * actions, behaves like forEach() or map() depending on arguments |
|
1761 | * actions, behaves like forEach() or map() depending on arguments | |
1762 | */ |
|
1762 | */ | |
1763 | _adaptWithCondition<T extends Node, U extends Node>(f: (node: T) => U | void, g: (...args: any[]) => boolean, o?: Object): NodeList<U> | this; |
|
1763 | _adaptWithCondition<T extends Node, U extends Node>(f: (node: T) => U | void, g: (...args: any[]) => boolean, o?: Object): NodeList<U> | this; | |
1764 | } |
|
1764 | } | |
1765 |
|
1765 | |||
1766 | interface Query { |
|
1766 | interface Query { | |
1767 | /** |
|
1767 | /** | |
1768 | * Returns nodes which match the given CSS selector, searching the |
|
1768 | * Returns nodes which match the given CSS selector, searching the | |
1769 | * entire document by default but optionally taking a node to scope |
|
1769 | * entire document by default but optionally taking a node to scope | |
1770 | * the search by. Returns an instance of NodeList. |
|
1770 | * the search by. Returns an instance of NodeList. | |
1771 | */ |
|
1771 | */ | |
1772 | <T extends Node>(query: string, root?: NodeOrString): NodeList<T>; |
|
1772 | <T extends Node>(query: string, root?: NodeOrString): NodeList<T>; | |
1773 |
|
1773 | |||
1774 | /** |
|
1774 | /** | |
1775 | * Test to see if a node matches a selector |
|
1775 | * Test to see if a node matches a selector | |
1776 | */ |
|
1776 | */ | |
1777 | matches(node: Node, selector: string, root?: NodeOrString): boolean; |
|
1777 | matches(node: Node, selector: string, root?: NodeOrString): boolean; | |
1778 |
|
1778 | |||
1779 | /** |
|
1779 | /** | |
1780 | * Filters an array of nodes. Note that this does not guarantee to return a NodeList, just an array. |
|
1780 | * Filters an array of nodes. Note that this does not guarantee to return a NodeList, just an array. | |
1781 | */ |
|
1781 | */ | |
1782 | filter<T extends Node>(nodes: NodeList<T> | T[], select: string, root?: NodeOrString): T[] | NodeList<T>; |
|
1782 | filter<T extends Node>(nodes: NodeList<T> | T[], select: string, root?: NodeOrString): T[] | NodeList<T>; | |
1783 |
|
1783 | |||
1784 | /** |
|
1784 | /** | |
1785 | * can be used as AMD plugin to conditionally load new query engine |
|
1785 | * can be used as AMD plugin to conditionally load new query engine | |
1786 | */ |
|
1786 | */ | |
1787 | load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */ |
|
1787 | load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */ | |
1788 | } |
|
1788 | } | |
1789 |
|
1789 | |||
1790 | /* dojo/ready */ |
|
1790 | /* dojo/ready */ | |
1791 |
|
1791 | |||
1792 | interface Ready { |
|
1792 | interface Ready { | |
1793 | /** |
|
1793 | /** | |
1794 | * Add a function to execute on DOM content loaded and all requested modules have arrived and been evaluated. |
|
1794 | * Add a function to execute on DOM content loaded and all requested modules have arrived and been evaluated. | |
1795 | * In most cases, the `domReady` plug-in should suffice and this method should not be needed. |
|
1795 | * In most cases, the `domReady` plug-in should suffice and this method should not be needed. | |
1796 | * |
|
1796 | * | |
1797 | * When called in a non-browser environment, just checks that all requested modules have arrived and been |
|
1797 | * When called in a non-browser environment, just checks that all requested modules have arrived and been | |
1798 | * evaluated. |
|
1798 | * evaluated. | |
1799 | */ |
|
1799 | */ | |
1800 | (callback: Function): void; |
|
1800 | (callback: Function): void; | |
1801 | (context: Object, callback: Function | string): void; |
|
1801 | (context: Object, callback: Function | string): void; | |
1802 | (priority: number, callback: Function): void; |
|
1802 | (priority: number, callback: Function): void; | |
1803 | (priority: number, context: Object, callback: Function | string): void; |
|
1803 | (priority: number, context: Object, callback: Function | string): void; | |
1804 | } |
|
1804 | } | |
1805 |
|
1805 | |||
1806 | /* dojo/regexp */ |
|
1806 | /* dojo/regexp */ | |
1807 |
|
1807 | |||
1808 | interface RegExpModule { |
|
1808 | interface RegExpModule { | |
1809 | /** |
|
1809 | /** | |
1810 | * Adds escape sequences for special characters in regular expressions |
|
1810 | * Adds escape sequences for special characters in regular expressions | |
1811 | */ |
|
1811 | */ | |
1812 | escapeString(str: string, except?: string): string; |
|
1812 | escapeString(str: string, except?: string): string; | |
1813 |
|
1813 | |||
1814 | /** |
|
1814 | /** | |
1815 | * Builds a regular expression that groups subexpressions |
|
1815 | * Builds a regular expression that groups subexpressions | |
1816 | */ |
|
1816 | */ | |
1817 | buildGroupRE(arr: any[] | Object, re: (item: any) => string, nonCapture?: boolean): string; |
|
1817 | buildGroupRE(arr: any[] | Object, re: (item: any) => string, nonCapture?: boolean): string; | |
1818 |
|
1818 | |||
1819 | /** |
|
1819 | /** | |
1820 | * adds group match to expression |
|
1820 | * adds group match to expression | |
1821 | */ |
|
1821 | */ | |
1822 | group(expression: string, nonCapture?: boolean): string; |
|
1822 | group(expression: string, nonCapture?: boolean): string; | |
1823 | } |
|
1823 | } | |
1824 |
|
1824 | |||
1825 | /* dojo/request */ |
|
1825 | /* dojo/request */ | |
1826 |
|
1826 | |||
1827 | /* This is contained in request.d.ts */ |
|
1827 | /* This is contained in request.d.ts */ | |
1828 |
|
1828 | |||
1829 | /* dojo/require */ |
|
1829 | /* dojo/require */ | |
1830 |
|
1830 | |||
1831 | interface RequirePlugin { |
|
1831 | interface RequirePlugin { | |
1832 | dynamic: number; |
|
1832 | dynamic: number; | |
1833 | normalize(id: string): string; |
|
1833 | normalize(id: string): string; | |
1834 | load(mid: string, require: any, loaded: (...modules: any[]) => void): void; |
|
1834 | load(mid: string, require: any, loaded: (...modules: any[]) => void): void; | |
1835 | } |
|
1835 | } | |
1836 |
|
1836 | |||
1837 | /* dojo/robot */ |
|
1837 | /* dojo/robot */ | |
1838 |
|
1838 | |||
1839 | interface Robot extends doh.Robot { |
|
1839 | interface Robot extends doh.Robot { | |
1840 | _resolveNode(n: NodeOrString | (() => Node)): Node; |
|
1840 | _resolveNode(n: NodeOrString | (() => Node)): Node; | |
1841 | _scrollIntoView(n: Node): void; |
|
1841 | _scrollIntoView(n: Node): void; | |
1842 | _position(n: Node): DomGeometryBoxExtents; |
|
1842 | _position(n: Node): DomGeometryBoxExtents; | |
1843 | _getWindowChain(n: Node): Window[]; |
|
1843 | _getWindowChain(n: Node): Window[]; | |
1844 |
|
1844 | |||
1845 | /** |
|
1845 | /** | |
1846 | * Scroll the passed node into view, if it is not. |
|
1846 | * Scroll the passed node into view, if it is not. | |
1847 | */ |
|
1847 | */ | |
1848 | scrollIntoView(node: NodeOrString | (() => Node), delay?: number): void; |
|
1848 | scrollIntoView(node: NodeOrString | (() => Node), delay?: number): void; | |
1849 |
|
1849 | |||
1850 | /** |
|
1850 | /** | |
1851 | * Moves the mouse over the specified node at the specified relative x,y offset. |
|
1851 | * Moves the mouse over the specified node at the specified relative x,y offset. | |
1852 | */ |
|
1852 | */ | |
1853 | mouseMoveAt( |
|
1853 | mouseMoveAt( | |
1854 | node: NodeOrString | (() => Node), |
|
1854 | node: NodeOrString | (() => Node), | |
1855 | delay?: number, |
|
1855 | delay?: number, | |
1856 | duration?: number, |
|
1856 | duration?: number, | |
1857 | offsetX?: number, |
|
1857 | offsetX?: number, | |
1858 | offsetY?: number |
|
1858 | offsetY?: number | |
1859 | ): void; |
|
1859 | ): void; | |
1860 | } |
|
1860 | } | |
1861 |
|
1861 | |||
1862 | /* dojo/robotx */ |
|
1862 | /* dojo/robotx */ | |
1863 |
|
1863 | |||
1864 | interface RobotX extends Robot { |
|
1864 | interface RobotX extends Robot { | |
1865 | /** |
|
1865 | /** | |
1866 | * Called every time a new page is loaded into the iframe, to setup variables |
|
1866 | * Called every time a new page is loaded into the iframe, to setup variables | |
1867 | * Point dojo.global, dojo.publish, etc. to refer to iframe. |
|
1867 | * Point dojo.global, dojo.publish, etc. to refer to iframe. | |
1868 | * Remove for 2.0? |
|
1868 | * Remove for 2.0? | |
1869 | */ |
|
1869 | */ | |
1870 | _updateDocument(): void; |
|
1870 | _updateDocument(): void; | |
1871 |
|
1871 | |||
1872 | /** |
|
1872 | /** | |
1873 | * Opens the application at the specified URL for testing, redirecting dojo to point to the application |
|
1873 | * Opens the application at the specified URL for testing, redirecting dojo to point to the application | |
1874 | * environment instead of the test environment. |
|
1874 | * environment instead of the test environment. | |
1875 | */ |
|
1875 | */ | |
1876 | initRobot(url: string): void; |
|
1876 | initRobot(url: string): void; | |
1877 |
|
1877 | |||
1878 | /** |
|
1878 | /** | |
1879 | * Notifies DOH that the doh.robot is about to make a page change in the application it is driving, |
|
1879 | * Notifies DOH that the doh.robot is about to make a page change in the application it is driving, | |
1880 | * returning a doh.Deferred object the user should return in their runTest function as part of a DOH test. |
|
1880 | * returning a doh.Deferred object the user should return in their runTest function as part of a DOH test. | |
1881 | */ |
|
1881 | */ | |
1882 | waitForPageToLoad(submitActions: () => void): any; |
|
1882 | waitForPageToLoad(submitActions: () => void): any; | |
1883 | } |
|
1883 | } | |
1884 |
|
1884 | |||
1885 | /* dojo/router */ |
|
1885 | /* dojo/router */ | |
1886 |
|
1886 | |||
1887 | /* Module just exports instance of dojo.router.BaseRouter */ |
|
1887 | /* Module just exports instance of dojo.router.BaseRouter */ | |
1888 |
|
1888 | |||
1889 | /* dojo/sniff */ |
|
1889 | /* dojo/sniff */ | |
1890 |
|
1890 | |||
1891 | interface Has { |
|
1891 | interface Has { | |
1892 | (name: 'air'): boolean; |
|
1892 | (name: 'air'): boolean; | |
1893 | (name: 'wp'): void | number; |
|
1893 | (name: 'wp'): void | number; | |
1894 | (name: 'msapp'): void | number; |
|
1894 | (name: 'msapp'): void | number; | |
1895 | (name: 'khtml'): void | number; |
|
1895 | (name: 'khtml'): void | number; | |
1896 | (name: 'edge'): void | number; |
|
1896 | (name: 'edge'): void | number; | |
1897 | (name: 'opr'): void | number; |
|
1897 | (name: 'opr'): void | number; | |
1898 | (name: 'webkit'): void | number; |
|
1898 | (name: 'webkit'): void | number; | |
1899 | (name: 'chrome'): void | number; |
|
1899 | (name: 'chrome'): void | number; | |
1900 | (name: 'android'): void | number; |
|
1900 | (name: 'android'): void | number; | |
1901 | (name: 'safari'): void | number; |
|
1901 | (name: 'safari'): void | number; | |
1902 | (name: 'mac'): boolean; |
|
1902 | (name: 'mac'): boolean; | |
1903 | (name: 'quirks'): boolean; |
|
1903 | (name: 'quirks'): boolean; | |
1904 | (name: 'iphone'): void | number; |
|
1904 | (name: 'iphone'): void | number; | |
1905 | (name: 'ipod'): void | number; |
|
1905 | (name: 'ipod'): void | number; | |
1906 | (name: 'ipad'): void | number; |
|
1906 | (name: 'ipad'): void | number; | |
1907 | (name: 'ios'): void | number; |
|
1907 | (name: 'ios'): void | number; | |
1908 | (name: 'bb'): void | number | boolean; |
|
1908 | (name: 'bb'): void | number | boolean; | |
1909 | (name: 'trident'): void | number; |
|
1909 | (name: 'trident'): void | number; | |
1910 | (name: 'svg'): boolean; |
|
1910 | (name: 'svg'): boolean; | |
1911 | (name: 'opera'): void | number; |
|
1911 | (name: 'opera'): void | number; | |
1912 | (name: 'mozilla'): void | number; |
|
1912 | (name: 'mozilla'): void | number; | |
1913 | (name: 'ff'): void | number; |
|
1913 | (name: 'ff'): void | number; | |
1914 | (name: 'ie'): void | number; |
|
1914 | (name: 'ie'): void | number; | |
1915 | (name: 'wii'): boolean | any; |
|
1915 | (name: 'wii'): boolean | any; | |
1916 | } |
|
1916 | } | |
1917 |
|
1917 | |||
1918 | /* Just rexports has after adding features */ |
|
1918 | /* Just rexports has after adding features */ | |
1919 |
|
1919 | |||
1920 | /* dojo/Stateful */ |
|
1920 | /* dojo/Stateful */ | |
1921 |
|
1921 | |||
1922 | interface WatchHandle extends Handle { |
|
1922 | interface WatchHandle extends Handle { | |
1923 | unwatch(): void; |
|
1923 | unwatch(): void; | |
1924 | } |
|
1924 | } | |
1925 |
|
1925 | |||
1926 | interface Stateful<T = any> { |
|
1926 | interface Stateful<T = any> { | |
1927 | /** |
|
1927 | /** | |
1928 | * Used across all instances a hash to cache attribute names and their getter |
|
1928 | * Used across all instances a hash to cache attribute names and their getter | |
1929 | * and setter names. |
|
1929 | * and setter names. | |
1930 | */ |
|
1930 | */ | |
1931 | _attrPairNames: { [attr: string]: string }; |
|
1931 | _attrPairNames: { [attr: string]: string }; | |
1932 |
|
1932 | |||
1933 | /** |
|
1933 | /** | |
1934 | * Helper function for get() and set(). |
|
1934 | * Helper function for get() and set(). | |
1935 | * Caches attribute name values so we don't do the string ops every time. |
|
1935 | * Caches attribute name values so we don't do the string ops every time. | |
1936 | */ |
|
1936 | */ | |
1937 | _getAttrNames(name: string): string; |
|
1937 | _getAttrNames(name: string): string; | |
1938 |
|
1938 | |||
1939 | /** |
|
1939 | /** | |
1940 | * Automatic setting of params during construction |
|
1940 | * Automatic setting of params during construction | |
1941 | */ |
|
1941 | */ | |
1942 | postscript(params?: Object): void; |
|
1942 | postscript(params?: Object): void; | |
1943 |
|
1943 | |||
1944 | /** |
|
1944 | /** | |
1945 | * Get a property on a Stateful instance. |
|
1945 | * Get a property on a Stateful instance. | |
1946 | */ |
|
1946 | */ | |
1947 | get<K extends keyof T & string>(name: K): T[K]; |
|
1947 | get<K extends keyof T & string>(name: K): T[K]; | |
1948 |
|
1948 | |||
1949 | /** |
|
1949 | /** | |
1950 | * Set a property on a Stateful instance |
|
1950 | * Set a property on a Stateful instance | |
1951 | */ |
|
1951 | */ | |
1952 | set<K extends keyof T & string>(name: K, value: T[K]): this; |
|
1952 | set<K extends keyof T & string>(name: K, value: T[K]): this; | |
1953 | set<K extends { [p in keyof T]: T[p] extends any[] ? p : never; }[keyof T & string] >(name: K, ...values: T[K]): this; |
|
1953 | set<K extends { [p in keyof T]: T[p] extends any[] ? p : never; }[keyof T & string] >(name: K, ...values: T[K]): this; | |
1954 | set(values: Partial<T>): this; |
|
1954 | set(values: Partial<T>): this; | |
1955 |
|
1955 | |||
1956 | /** |
|
1956 | /** | |
1957 | * Internal helper for directly changing an attribute value. |
|
1957 | * Internal helper for directly changing an attribute value. | |
1958 | */ |
|
1958 | */ | |
1959 | _changeAttrValue(name: string, value: any): this; |
|
1959 | _changeAttrValue(name: string, value: any): this; | |
1960 |
|
1960 | |||
1961 | /** |
|
1961 | /** | |
1962 | * Watches a property for changes |
|
1962 | * Watches a property for changes | |
1963 | */ |
|
1963 | */ | |
1964 |
watch(callback: |
|
1964 | watch(callback:(prop: keyof any, oldValue: any, newValue: any) => void): WatchHandle; | |
1965 | watch<K extends keyof T>(name: K, callback: (prop: K, oldValue: T[K], newValue: T[K]) => void): WatchHandle; |
|
1965 | watch<K extends keyof T>(name: K, callback: (prop: K, oldValue: T[K], newValue: T[K]) => void): WatchHandle; | |
1966 | } |
|
1966 | } | |
1967 |
|
1967 | |||
1968 | interface StatefulConstructor extends _base.DeclareConstructor<Stateful> { |
|
1968 | interface StatefulConstructor extends _base.DeclareConstructor<Stateful> { | |
1969 | new <T>(params?: Partial<T>): Stateful<T>; |
|
1969 | new <T>(params?: Partial<T>): Stateful<T>; | |
1970 | } |
|
1970 | } | |
1971 |
|
1971 | |||
1972 | /* dojo/string */ |
|
1972 | /* dojo/string */ | |
1973 |
|
1973 | |||
1974 | interface String { |
|
1974 | interface String { | |
1975 |
|
1975 | |||
1976 | /** |
|
1976 | /** | |
1977 | * Efficiently escape a string for insertion into HTML (innerHTML or attributes), replacing &, <, >, ", ', and / characters. |
|
1977 | * Efficiently escape a string for insertion into HTML (innerHTML or attributes), replacing &, <, >, ", ', and / characters. | |
1978 | */ |
|
1978 | */ | |
1979 | escape(str: string): string; |
|
1979 | escape(str: string): string; | |
1980 |
|
1980 | |||
1981 | /** |
|
1981 | /** | |
1982 | * Efficiently replicate a string `n` times. |
|
1982 | * Efficiently replicate a string `n` times. | |
1983 | */ |
|
1983 | */ | |
1984 | rep(str: string, num: number): string; |
|
1984 | rep(str: string, num: number): string; | |
1985 |
|
1985 | |||
1986 | /** |
|
1986 | /** | |
1987 | * Pad a string to guarantee that it is at least `size` length by |
|
1987 | * Pad a string to guarantee that it is at least `size` length by | |
1988 | * filling with the character `ch` at either the start or end of the |
|
1988 | * filling with the character `ch` at either the start or end of the | |
1989 | * string. Pads at the start, by default. |
|
1989 | * string. Pads at the start, by default. | |
1990 | */ |
|
1990 | */ | |
1991 | pad(text: string, size: number, ch?: string, end?: boolean): string; |
|
1991 | pad(text: string, size: number, ch?: string, end?: boolean): string; | |
1992 |
|
1992 | |||
1993 | /** |
|
1993 | /** | |
1994 | * Performs parameterized substitutions on a string. Throws an |
|
1994 | * Performs parameterized substitutions on a string. Throws an | |
1995 | * exception if any parameter is unmatched. |
|
1995 | * exception if any parameter is unmatched. | |
1996 | */ |
|
1996 | */ | |
1997 | substitute(template: string, map: Object | any[], transform?: (value: any, key: string) => any, thisObject?: Object): string; |
|
1997 | substitute(template: string, map: Object | any[], transform?: (value: any, key: string) => any, thisObject?: Object): string; | |
1998 |
|
1998 | |||
1999 | /** |
|
1999 | /** | |
2000 | * Trims whitespace from both sides of the string |
|
2000 | * Trims whitespace from both sides of the string | |
2001 | */ |
|
2001 | */ | |
2002 | trim(str: string): string; |
|
2002 | trim(str: string): string; | |
2003 | } |
|
2003 | } | |
2004 |
|
2004 | |||
2005 | /* dojo/text */ |
|
2005 | /* dojo/text */ | |
2006 |
|
2006 | |||
2007 | /** |
|
2007 | /** | |
2008 | * A getter and setter for storing the string content associated with the |
|
2008 | * A getter and setter for storing the string content associated with the | |
2009 | * module and url arguments. |
|
2009 | * module and url arguments. | |
2010 | */ |
|
2010 | */ | |
2011 | interface Cache { |
|
2011 | interface Cache { | |
2012 | (module: string | GenericObject, url: string, value?: string | { value: string, sanitize?: boolean }): string; |
|
2012 | (module: string | GenericObject, url: string, value?: string | { value: string, sanitize?: boolean }): string; | |
2013 | } |
|
2013 | } | |
2014 |
|
2014 | |||
2015 | interface Text { |
|
2015 | interface Text { | |
2016 | /** |
|
2016 | /** | |
2017 | * the dojo/text caches it's own resources because of dojo.cache |
|
2017 | * the dojo/text caches it's own resources because of dojo.cache | |
2018 | */ |
|
2018 | */ | |
2019 | dynamic: boolean; |
|
2019 | dynamic: boolean; | |
2020 |
|
2020 | |||
2021 | normalize(id: string, toAbsMid: Function): string; /* TODO: Align with loader api */ |
|
2021 | normalize(id: string, toAbsMid: Function): string; /* TODO: Align with loader api */ | |
2022 |
|
2022 | |||
2023 | load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */ |
|
2023 | load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */ | |
2024 | } |
|
2024 | } | |
2025 |
|
2025 | |||
2026 | /* dojo/throttle */ |
|
2026 | /* dojo/throttle */ | |
2027 |
|
2027 | |||
2028 | interface Throttle { |
|
2028 | interface Throttle { | |
2029 | <T extends Function>(cb: T, wait: number): T; |
|
2029 | <T extends Function>(cb: T, wait: number): T; | |
2030 | } |
|
2030 | } | |
2031 |
|
2031 | |||
2032 | /* dojo/topic */ |
|
2032 | /* dojo/topic */ | |
2033 |
|
2033 | |||
2034 | interface Topic { |
|
2034 | interface Topic { | |
2035 | /** |
|
2035 | /** | |
2036 | * Publishes a message to a topic on the pub/sub hub. All arguments after |
|
2036 | * Publishes a message to a topic on the pub/sub hub. All arguments after | |
2037 | * the first will be passed to the subscribers, so any number of arguments |
|
2037 | * the first will be passed to the subscribers, so any number of arguments | |
2038 | * can be provided (not just event). |
|
2038 | * can be provided (not just event). | |
2039 | */ |
|
2039 | */ | |
2040 | publish(topic: string | ExtensionEvent, ...event: any[]): boolean; |
|
2040 | publish(topic: string | ExtensionEvent, ...event: any[]): boolean; | |
2041 |
|
2041 | |||
2042 | /** |
|
2042 | /** | |
2043 | * Subscribes to a topic on the pub/sub hub |
|
2043 | * Subscribes to a topic on the pub/sub hub | |
2044 | */ |
|
2044 | */ | |
2045 | subscribe(topic: string | ExtensionEvent, listener: EventListener | Function): Handle; |
|
2045 | subscribe(topic: string | ExtensionEvent, listener: EventListener | Function): Handle; | |
2046 | } |
|
2046 | } | |
2047 |
|
2047 | |||
2048 | /* dojo/touch */ |
|
2048 | /* dojo/touch */ | |
2049 |
|
2049 | |||
2050 | interface Touch { |
|
2050 | interface Touch { | |
2051 | press: ExtensionEvent; |
|
2051 | press: ExtensionEvent; | |
2052 | move: ExtensionEvent; |
|
2052 | move: ExtensionEvent; | |
2053 | release: ExtensionEvent; |
|
2053 | release: ExtensionEvent; | |
2054 | cancel: ExtensionEvent; |
|
2054 | cancel: ExtensionEvent; | |
2055 | over: ExtensionEvent; |
|
2055 | over: ExtensionEvent; | |
2056 | out: ExtensionEvent; |
|
2056 | out: ExtensionEvent; | |
2057 | enter: ExtensionEvent; |
|
2057 | enter: ExtensionEvent; | |
2058 | leave: ExtensionEvent; |
|
2058 | leave: ExtensionEvent; | |
2059 | } |
|
2059 | } | |
2060 |
|
2060 | |||
2061 | /* dojo/uacss */ |
|
2061 | /* dojo/uacss */ | |
2062 |
|
2062 | |||
2063 | /* rexports has after adding classes to dom */ |
|
2063 | /* rexports has after adding classes to dom */ | |
2064 |
|
2064 | |||
2065 | /* dojo/when */ |
|
2065 | /* dojo/when */ | |
2066 |
|
2066 | |||
2067 | interface When { |
|
2067 | interface When { | |
2068 | /** |
|
2068 | /** | |
2069 | * Transparently applies callbacks to values and/or promises. |
|
2069 | * Transparently applies callbacks to values and/or promises. | |
2070 | */ |
|
2070 | */ | |
2071 | <T>(value: T | dojo.promise.Promise<T>): dojo.promise.Promise<T>; |
|
2071 | <T>(value: T | dojo.promise.Promise<T>): dojo.promise.Promise<T>; | |
2072 | <T>(value: T | dojo.promise.Promise<T>, |
|
2072 | <T>(value: T | dojo.promise.Promise<T>, | |
2073 | callback?: dojo.promise.PromiseCallback<T, T>, |
|
2073 | callback?: dojo.promise.PromiseCallback<T, T>, | |
2074 | errback?: dojo.promise.PromiseErrback<T>, |
|
2074 | errback?: dojo.promise.PromiseErrback<T>, | |
2075 | progress?: dojo.promise.PromiseProgback): T | dojo.promise.Promise<T>; |
|
2075 | progress?: dojo.promise.PromiseProgback): T | dojo.promise.Promise<T>; | |
2076 | <T, U>(value: T | dojo.promise.Promise<T>, |
|
2076 | <T, U>(value: T | dojo.promise.Promise<T>, | |
2077 | callback?: dojo.promise.PromiseCallback<T, U>, |
|
2077 | callback?: dojo.promise.PromiseCallback<T, U>, | |
2078 | errback?: dojo.promise.PromiseErrback<U>, |
|
2078 | errback?: dojo.promise.PromiseErrback<U>, | |
2079 | progress?: dojo.promise.PromiseProgback): U | dojo.promise.Promise<U>; |
|
2079 | progress?: dojo.promise.PromiseProgback): U | dojo.promise.Promise<U>; | |
2080 | } |
|
2080 | } | |
2081 |
|
2081 | |||
2082 | /* dojo/window */ |
|
2082 | /* dojo/window */ | |
2083 |
|
2083 | |||
2084 | interface WindowModule { |
|
2084 | interface WindowModule { | |
2085 |
|
2085 | |||
2086 | /** |
|
2086 | /** | |
2087 | * Returns the dimensions and scroll position of the viewable area of a browser window |
|
2087 | * Returns the dimensions and scroll position of the viewable area of a browser window | |
2088 | */ |
|
2088 | */ | |
2089 | getBox(doc?: Document): DomGeometryBox; |
|
2089 | getBox(doc?: Document): DomGeometryBox; | |
2090 |
|
2090 | |||
2091 | /** |
|
2091 | /** | |
2092 | * Get window object associated with document doc. |
|
2092 | * Get window object associated with document doc. | |
2093 | */ |
|
2093 | */ | |
2094 | get(doc?: Document): Window; |
|
2094 | get(doc?: Document): Window; | |
2095 |
|
2095 | |||
2096 | /** |
|
2096 | /** | |
2097 | * Scroll the passed node into view using minimal movement, if it is not already. |
|
2097 | * Scroll the passed node into view using minimal movement, if it is not already. | |
2098 | */ |
|
2098 | */ | |
2099 | scrollIntoView(node: Element, pos?: DomGeometryXYBox): void; |
|
2099 | scrollIntoView(node: Element, pos?: DomGeometryXYBox): void; | |
2100 | } |
|
2100 | } | |
2101 | } |
|
2101 | } |
@@ -1,824 +1,824 | |||||
1 | /// <reference path="index.d.ts" /> |
|
1 | /// <reference path="index.d.ts" /> | |
2 |
|
2 | |||
3 | declare module 'dojo/_base/array' { |
|
3 | declare module 'dojo/_base/array' { | |
4 | const dojoArray: dojo._base.Array; |
|
4 | const dojoArray: dojo._base.Array; | |
5 | export = dojoArray; |
|
5 | export = dojoArray; | |
6 | } |
|
6 | } | |
7 |
|
7 | |||
8 | declare module 'dojo/_base/browser' { |
|
8 | declare module 'dojo/_base/browser' { | |
9 | const ready: dojo.Ready; |
|
9 | const ready: dojo.Ready; | |
10 | export = ready; |
|
10 | export = ready; | |
11 | } |
|
11 | } | |
12 |
|
12 | |||
13 | declare module 'dojo/_base/Color' { |
|
13 | declare module 'dojo/_base/Color' { | |
14 | type Color = dojo._base.Color; |
|
14 | type Color = dojo._base.Color; | |
15 | const Color: dojo._base.ColorConstructor; |
|
15 | const Color: dojo._base.ColorConstructor; | |
16 | export = Color; |
|
16 | export = Color; | |
17 | } |
|
17 | } | |
18 |
|
18 | |||
19 | declare module 'dojo/_base/config' { |
|
19 | declare module 'dojo/_base/config' { | |
20 | const config: dojo._base.Config; |
|
20 | const config: dojo._base.Config; | |
21 | export = config; |
|
21 | export = config; | |
22 | } |
|
22 | } | |
23 |
|
23 | |||
24 | declare module 'dojo/_base/connect' { |
|
24 | declare module 'dojo/_base/connect' { | |
25 | const connect: dojo._base.Connect; |
|
25 | const connect: dojo._base.Connect; | |
26 | export = connect; |
|
26 | export = connect; | |
27 | } |
|
27 | } | |
28 |
|
28 | |||
29 | declare module 'dojo/_base/declare' { |
|
29 | declare module 'dojo/_base/declare' { | |
30 | const dojoDeclare: dojo._base.Declare; |
|
30 | const dojoDeclare: dojo._base.Declare; | |
31 | export = dojoDeclare; |
|
31 | export = dojoDeclare; | |
32 | } |
|
32 | } | |
33 |
|
33 | |||
34 | declare module 'dojo/_base/Deferred' { |
|
34 | declare module 'dojo/_base/Deferred' { | |
35 | type Deferred<T> = dojo._base.Deferred<T>; |
|
35 | type Deferred<T> = dojo._base.Deferred<T>; | |
36 | const Deferred: dojo._base.DeferredConstructor; |
|
36 | const Deferred: dojo._base.DeferredConstructor; | |
37 | export = Deferred; |
|
37 | export = Deferred; | |
38 | } |
|
38 | } | |
39 |
|
39 | |||
40 | declare module 'dojo/_base/event' { |
|
40 | declare module 'dojo/_base/event' { | |
41 | const event: dojo._base.EventModule; |
|
41 | const event: dojo._base.EventModule; | |
42 | export = event; |
|
42 | export = event; | |
43 | } |
|
43 | } | |
44 |
|
44 | |||
45 | declare module 'dojo/_base/fx' { |
|
45 | declare module 'dojo/_base/fx' { | |
46 | const fx: dojo._base.Fx; |
|
46 | const fx: dojo._base.Fx; | |
47 | export = fx; |
|
47 | export = fx; | |
48 | } |
|
48 | } | |
49 |
|
49 | |||
50 | declare module 'dojo/_base/html' { |
|
50 | declare module 'dojo/_base/html' { | |
51 | const dojo: dojo._base.Dojo; |
|
51 | const dojo: dojo._base.Dojo; | |
52 | export = dojo; |
|
52 | export = dojo; | |
53 | } |
|
53 | } | |
54 |
|
54 | |||
55 | declare module 'dojo/_base/json' { |
|
55 | declare module 'dojo/_base/json' { | |
56 | const dojo: dojo._base.Dojo; |
|
56 | const dojo: dojo._base.Dojo; | |
57 | export = dojo; |
|
57 | export = dojo; | |
58 | } |
|
58 | } | |
59 |
|
59 | |||
60 | declare module 'dojo/_base/kernel' { |
|
60 | declare module 'dojo/_base/kernel' { | |
61 | const dojo: dojo._base.Dojo; |
|
61 | const dojo: dojo._base.Dojo; | |
62 | export = dojo; |
|
62 | export = dojo; | |
63 | } |
|
63 | } | |
64 |
|
64 | |||
65 | declare module 'dojo/_base/lang' { |
|
65 | declare module 'dojo/_base/lang' { | |
66 | const lang: dojo._base.Lang; |
|
66 | const lang: dojo._base.Lang; | |
67 | export = lang; |
|
67 | export = lang; | |
68 | } |
|
68 | } | |
69 |
|
69 | |||
70 | declare module 'dojo/_base/loader' { |
|
70 | declare module 'dojo/_base/loader' { | |
71 | const loader: dojo._base.Loader; |
|
71 | const loader: dojo._base.Loader; | |
72 | export = loader; |
|
72 | export = loader; | |
73 | } |
|
73 | } | |
74 |
|
74 | |||
75 | declare module 'dojo/_base/NodeList' { |
|
75 | declare module 'dojo/_base/NodeList' { | |
76 | type NodeList<T extends Node> = dojo.NodeList<T>; |
|
76 | type NodeList<T extends Node> = dojo.NodeList<T>; | |
77 | const NodeList: dojo.NodeListConstructor; |
|
77 | const NodeList: dojo.NodeListConstructor; | |
78 | export = NodeList; |
|
78 | export = NodeList; | |
79 | } |
|
79 | } | |
80 |
|
80 | |||
81 | declare module 'dojo/_base/query' { |
|
81 | declare module 'dojo/_base/query' { | |
82 | const query: dojo.Query; |
|
82 | const query: dojo.Query; | |
83 | export = query; |
|
83 | export = query; | |
84 | } |
|
84 | } | |
85 |
|
85 | |||
86 | declare module 'dojo/_base/sniff' { |
|
86 | declare module 'dojo/_base/sniff' { | |
87 | const has: dojo.Has; |
|
87 | const has: dojo.Has; | |
88 | export = has; |
|
88 | export = has; | |
89 | } |
|
89 | } | |
90 |
|
90 | |||
91 | declare module 'dojo/_base/unload' { |
|
91 | declare module 'dojo/_base/unload' { | |
92 | const unload: dojo._base.Unload; |
|
92 | const unload: dojo._base.Unload; | |
93 | export = unload; |
|
93 | export = unload; | |
94 | } |
|
94 | } | |
95 |
|
95 | |||
96 | declare module 'dojo/_base/url' { |
|
96 | declare module 'dojo/_base/url' { | |
97 | type Url = dojo._base.Url; |
|
97 | type Url = dojo._base.Url; | |
98 | const Url: dojo._base.UrlConstructor; |
|
98 | const Url: dojo._base.UrlConstructor; | |
99 | export = Url; |
|
99 | export = Url; | |
100 | } |
|
100 | } | |
101 |
|
101 | |||
102 | declare module 'dojo/_base/window' { |
|
102 | declare module 'dojo/_base/window' { | |
103 | const window: dojo._base.Window; |
|
103 | const window: dojo._base.Window; | |
104 | export = window; |
|
104 | export = window; | |
105 | } |
|
105 | } | |
106 |
|
106 | |||
107 | declare module 'dojo/_base/xhr' { |
|
107 | declare module 'dojo/_base/xhr' { | |
108 | const xhr: dojo._base.Xhr; |
|
108 | const xhr: dojo._base.Xhr; | |
109 | export = xhr; |
|
109 | export = xhr; | |
110 | } |
|
110 | } | |
111 |
|
111 | |||
112 | declare module 'dojo/AdapterRegistry' { |
|
112 | declare module 'dojo/AdapterRegistry' { | |
113 | type AdapterRegistry = dojo.AdapterRegistry; |
|
113 | type AdapterRegistry = dojo.AdapterRegistry; | |
114 | const AdapterRegistry: dojo.AdapterRegistryConstructor; |
|
114 | const AdapterRegistry: dojo.AdapterRegistryConstructor; | |
115 | export = AdapterRegistry; |
|
115 | export = AdapterRegistry; | |
116 | } |
|
116 | } | |
117 |
|
117 | |||
118 | declare module 'dojo/aspect' { |
|
118 | declare module 'dojo/aspect' { | |
119 | const aspect: dojo.Aspect; |
|
119 | const aspect: dojo.Aspect; | |
120 | export = aspect; |
|
120 | export = aspect; | |
121 | } |
|
121 | } | |
122 |
|
122 | |||
123 | declare module 'dojo/back' { |
|
123 | declare module 'dojo/back' { | |
124 | const back: dojo.Back; |
|
124 | const back: dojo.Back; | |
125 | export = back; |
|
125 | export = back; | |
126 | } |
|
126 | } | |
127 |
|
127 | |||
128 | declare module 'dojo/behavior' { |
|
128 | declare module 'dojo/behavior' { | |
129 | const behavior: dojo.Behavior; |
|
129 | const behavior: dojo.Behavior; | |
130 | export = behavior; |
|
130 | export = behavior; | |
131 | } |
|
131 | } | |
132 |
|
132 | |||
133 | declare module 'dojo/cache' { |
|
133 | declare module 'dojo/cache' { | |
134 | const cache: dojo.Cache; |
|
134 | const cache: dojo.Cache; | |
135 | export = cache; |
|
135 | export = cache; | |
136 | } |
|
136 | } | |
137 |
|
137 | |||
138 | declare module 'dojo/cldr/monetary' { |
|
138 | declare module 'dojo/cldr/monetary' { | |
139 | const monetary: dojo.cldr.Monetary; |
|
139 | const monetary: dojo.cldr.Monetary; | |
140 | export = monetary; |
|
140 | export = monetary; | |
141 | } |
|
141 | } | |
142 |
|
142 | |||
143 | declare module 'dojo/cldr/supplemental' { |
|
143 | declare module 'dojo/cldr/supplemental' { | |
144 | const supplemental: dojo.cldr.Supplemental; |
|
144 | const supplemental: dojo.cldr.Supplemental; | |
145 | export = supplemental; |
|
145 | export = supplemental; | |
146 | } |
|
146 | } | |
147 |
|
147 | |||
148 | declare module 'dojo/colors' { |
|
148 | declare module 'dojo/colors' { | |
149 | type Color = dojo._base.Color; |
|
149 | type Color = dojo._base.Color; | |
150 | const Color: dojo._base.ColorConstructor; |
|
150 | const Color: dojo._base.ColorConstructor; | |
151 | export = Color; |
|
151 | export = Color; | |
152 | } |
|
152 | } | |
153 |
|
153 | |||
154 | declare module 'dojo/cookie' { |
|
154 | declare module 'dojo/cookie' { | |
155 | const cookie: dojo.Cookie; |
|
155 | const cookie: dojo.Cookie; | |
156 | export = cookie; |
|
156 | export = cookie; | |
157 | } |
|
157 | } | |
158 |
|
158 | |||
159 | declare module 'dojo/currency' { |
|
159 | declare module 'dojo/currency' { | |
160 | const currency: dojo.Currency; |
|
160 | const currency: dojo.Currency; | |
161 | export = currency; |
|
161 | export = currency; | |
162 | } |
|
162 | } | |
163 |
|
163 | |||
164 | declare module 'dojo/data/api/Identity' { |
|
164 | declare module 'dojo/data/api/Identity' { | |
165 | type Identity<T> = dojo.data.api.Identity<T>; |
|
165 | type Identity<T> = dojo.data.api.Identity<T>; | |
166 | const Identity: dojo.data.api.IdentityConstructor; |
|
166 | const Identity: dojo.data.api.IdentityConstructor; | |
167 | export = Identity; |
|
167 | export = Identity; | |
168 | } |
|
168 | } | |
169 |
|
169 | |||
170 | declare module 'dojo/data/api/Item' { |
|
170 | declare module 'dojo/data/api/Item' { | |
171 | type Item = dojo.data.api.Item; |
|
171 | type Item = dojo.data.api.Item; | |
172 | const Item: dojo.data.api.ItemConstructor; |
|
172 | const Item: dojo.data.api.ItemConstructor; | |
173 | export = Item; |
|
173 | export = Item; | |
174 | } |
|
174 | } | |
175 |
|
175 | |||
176 | declare module 'dojo/data/api/Notification' { |
|
176 | declare module 'dojo/data/api/Notification' { | |
177 | type Notification<T> = dojo.data.api.Notification<T>; |
|
177 | type Notification<T> = dojo.data.api.Notification<T>; | |
178 | const Notification: dojo.data.api.NotificationConstructor; |
|
178 | const Notification: dojo.data.api.NotificationConstructor; | |
179 | export = Notification; |
|
179 | export = Notification; | |
180 | } |
|
180 | } | |
181 |
|
181 | |||
182 | declare module 'dojo/data/api/Read' { |
|
182 | declare module 'dojo/data/api/Read' { | |
183 | type Read<T> = dojo.data.api.Read<T>; |
|
183 | type Read<T> = dojo.data.api.Read<T>; | |
184 | const Read: dojo.data.api.ReadConstructor; |
|
184 | const Read: dojo.data.api.ReadConstructor; | |
185 | export = Read; |
|
185 | export = Read; | |
186 | } |
|
186 | } | |
187 |
|
187 | |||
188 | declare module 'dojo/data/api/Request' { |
|
188 | declare module 'dojo/data/api/Request' { | |
189 | type Request = dojo.data.api.Request; |
|
189 | type Request = dojo.data.api.Request; | |
190 | const Request: dojo.data.api.RequestConstructor; |
|
190 | const Request: dojo.data.api.RequestConstructor; | |
191 | export = Request; |
|
191 | export = Request; | |
192 | } |
|
192 | } | |
193 |
|
193 | |||
194 | declare module 'dojo/data/api/Write' { |
|
194 | declare module 'dojo/data/api/Write' { | |
195 | type Write<T> = dojo.data.api.Write<T>; |
|
195 | type Write<T> = dojo.data.api.Write<T>; | |
196 | const Write: dojo.data.api.WriteConstructor; |
|
196 | const Write: dojo.data.api.WriteConstructor; | |
197 | export = Write; |
|
197 | export = Write; | |
198 | } |
|
198 | } | |
199 |
|
199 | |||
200 | declare module 'dojo/data/util/filter' { |
|
200 | declare module 'dojo/data/util/filter' { | |
201 | const filter: dojo.data.util.Filter; |
|
201 | const filter: dojo.data.util.Filter; | |
202 | export = filter; |
|
202 | export = filter; | |
203 | } |
|
203 | } | |
204 |
|
204 | |||
205 | declare module 'dojo/data/util/simpleFetch' { |
|
205 | declare module 'dojo/data/util/simpleFetch' { | |
206 | const simpleFetch: dojo.data.util.SimpleFetch; |
|
206 | const simpleFetch: dojo.data.util.SimpleFetch; | |
207 | export = simpleFetch; |
|
207 | export = simpleFetch; | |
208 | } |
|
208 | } | |
209 |
|
209 | |||
210 | declare module 'dojo/data/util/sorter' { |
|
210 | declare module 'dojo/data/util/sorter' { | |
211 | const sorter: dojo.data.util.Sorter; |
|
211 | const sorter: dojo.data.util.Sorter; | |
212 | export = sorter; |
|
212 | export = sorter; | |
213 | } |
|
213 | } | |
214 |
|
214 | |||
215 | declare module 'dojo/data/ItemFileReadStore' { |
|
215 | declare module 'dojo/data/ItemFileReadStore' { | |
216 | type ItemFileReadStore<T> = dojo.data.ItemFileReadStore<T>; |
|
216 | type ItemFileReadStore<T> = dojo.data.ItemFileReadStore<T>; | |
217 | const ItemFileReadStore: dojo.data.ItemFileReadStoreConstructor; |
|
217 | const ItemFileReadStore: dojo.data.ItemFileReadStoreConstructor; | |
218 | export = ItemFileReadStore; |
|
218 | export = ItemFileReadStore; | |
219 | } |
|
219 | } | |
220 |
|
220 | |||
221 | declare module 'dojo/data/ItemFileWriteStore' { |
|
221 | declare module 'dojo/data/ItemFileWriteStore' { | |
222 | type ItemFileWriteStore<T> = dojo.data.ItemFileWriteStore<T>; |
|
222 | type ItemFileWriteStore<T> = dojo.data.ItemFileWriteStore<T>; | |
223 | const ItemFileWriteStore: dojo.data.ItemFileWriteStoreConstructor; |
|
223 | const ItemFileWriteStore: dojo.data.ItemFileWriteStoreConstructor; | |
224 | export = ItemFileWriteStore; |
|
224 | export = ItemFileWriteStore; | |
225 | } |
|
225 | } | |
226 |
|
226 | |||
227 | declare module 'dojo/data/ObjectStore' { |
|
227 | declare module 'dojo/data/ObjectStore' { | |
228 | type ObjectStore<T> = dojo.data.ObjectStore<T>; |
|
228 | type ObjectStore<T> = dojo.data.ObjectStore<T>; | |
229 | const ObjectStore: dojo.data.ObjectStoreConstructor; |
|
229 | const ObjectStore: dojo.data.ObjectStoreConstructor; | |
230 | export = ObjectStore; |
|
230 | export = ObjectStore; | |
231 | } |
|
231 | } | |
232 |
|
232 | |||
233 | declare module 'dojo/date' { |
|
233 | declare module 'dojo/date' { | |
234 | const date: dojo.date.DateBase; |
|
234 | const date: dojo.date.DateBase; | |
235 | export = date; |
|
235 | export = date; | |
236 | } |
|
236 | } | |
237 |
|
237 | |||
238 | declare module 'dojo/date/locale' { |
|
238 | declare module 'dojo/date/locale' { | |
239 | const dateLocale: dojo.date.DateLocale; |
|
239 | const dateLocale: dojo.date.DateLocale; | |
240 | export = dateLocale; |
|
240 | export = dateLocale; | |
241 | } |
|
241 | } | |
242 |
|
242 | |||
243 | declare module 'dojo/date/stamp' { |
|
243 | declare module 'dojo/date/stamp' { | |
244 | const stamp: dojo.date.Stamp; |
|
244 | const stamp: dojo.date.Stamp; | |
245 | export = stamp; |
|
245 | export = stamp; | |
246 | } |
|
246 | } | |
247 |
|
247 | |||
248 | declare module 'dojo/debounce' { |
|
248 | declare module 'dojo/debounce' { | |
249 | const debounce: dojo.Debounce; |
|
249 | const debounce: dojo.Debounce; | |
250 | export = debounce; |
|
250 | export = debounce; | |
251 | } |
|
251 | } | |
252 |
|
252 | |||
253 | declare module 'dojo/Deferred' { |
|
253 | declare module 'dojo/Deferred' { | |
254 | type Deferred<T> = dojo.Deferred<T>; |
|
254 | type Deferred<T> = dojo.Deferred<T>; | |
255 | const Deferred: dojo.DeferredConstructor; |
|
255 | const Deferred: dojo.DeferredConstructor; | |
256 | export = Deferred; |
|
256 | export = Deferred; | |
257 | } |
|
257 | } | |
258 |
|
258 | |||
259 | declare module 'dojo/DeferredList' { |
|
259 | declare module 'dojo/DeferredList' { | |
260 | type DeferredList<T> = dojo.DeferredList<T>; |
|
260 | type DeferredList<T> = dojo.DeferredList<T>; | |
261 | const DeferredList: dojo.DeferredListConstructor; |
|
261 | const DeferredList: dojo.DeferredListConstructor; | |
262 | export = DeferredList; |
|
262 | export = DeferredList; | |
263 | } |
|
263 | } | |
264 |
|
264 | |||
265 | declare module 'dojo/dnd/autoscroll' { |
|
265 | declare module 'dojo/dnd/autoscroll' { | |
266 | const autoscroll: dojo.dnd.AutoScroll; |
|
266 | const autoscroll: dojo.dnd.AutoScroll; | |
267 | export = autoscroll; |
|
267 | export = autoscroll; | |
268 | } |
|
268 | } | |
269 |
|
269 | |||
270 | declare module 'dojo/dnd/AutoSource' { |
|
270 | declare module 'dojo/dnd/AutoSource' { | |
271 | const AutoSource: dojo.dnd.AutoSourceConstructor; |
|
271 | const AutoSource: dojo.dnd.AutoSourceConstructor; | |
272 | export = AutoSource; |
|
272 | export = AutoSource; | |
273 | } |
|
273 | } | |
274 |
|
274 | |||
275 | declare module 'dojo/dnd/Avatar' { |
|
275 | declare module 'dojo/dnd/Avatar' { | |
276 | type Avatar = dojo.dnd.Avatar; |
|
276 | type Avatar = dojo.dnd.Avatar; | |
277 | const Avatar: dojo.dnd.AvatarConstructor; |
|
277 | const Avatar: dojo.dnd.AvatarConstructor; | |
278 | export = Avatar; |
|
278 | export = Avatar; | |
279 | } |
|
279 | } | |
280 |
|
280 | |||
281 | declare module 'dojo/dnd/common' { |
|
281 | declare module 'dojo/dnd/common' { | |
282 | const common: dojo.dnd.Common; |
|
282 | const common: dojo.dnd.Common; | |
283 | export = common; |
|
283 | export = common; | |
284 | } |
|
284 | } | |
285 |
|
285 | |||
286 | declare module 'dojo/dnd/Container' { |
|
286 | declare module 'dojo/dnd/Container' { | |
287 | type Container = dojo.dnd.Container; |
|
287 | type Container = dojo.dnd.Container; | |
288 | const Container: dojo.dnd.ContainerConstructor; |
|
288 | const Container: dojo.dnd.ContainerConstructor; | |
289 | export = Container; |
|
289 | export = Container; | |
290 | } |
|
290 | } | |
291 |
|
291 | |||
292 | declare module 'dojo/dnd/Manager' { |
|
292 | declare module 'dojo/dnd/Manager' { | |
293 | type Manager = dojo.dnd.Manager; |
|
293 | type Manager = dojo.dnd.Manager; | |
294 | const Manager: dojo.dnd.ManagerConstructor; |
|
294 | const Manager: dojo.dnd.ManagerConstructor; | |
295 | export = Manager; |
|
295 | export = Manager; | |
296 | } |
|
296 | } | |
297 |
|
297 | |||
298 | declare module 'dojo/dnd/move' { |
|
298 | declare module 'dojo/dnd/move' { | |
299 | const Move: dojo.dnd.Move; |
|
299 | const Move: dojo.dnd.Move; | |
300 | export = Move; |
|
300 | export = Move; | |
301 | } |
|
301 | } | |
302 |
|
302 | |||
303 | declare module 'dojo/dnd/Moveable' { |
|
303 | declare module 'dojo/dnd/Moveable' { | |
304 | type Moveable = dojo.dnd.Moveable; |
|
304 | type Moveable = dojo.dnd.Moveable; | |
305 | const Moveable: dojo.dnd.Moveable; |
|
305 | const Moveable: dojo.dnd.Moveable; | |
306 | export = Moveable; |
|
306 | export = Moveable; | |
307 | } |
|
307 | } | |
308 |
|
308 | |||
309 | declare module 'dojo/dnd/Mover' { |
|
309 | declare module 'dojo/dnd/Mover' { | |
310 | type Mover = dojo.dnd.Mover; |
|
310 | type Mover = dojo.dnd.Mover; | |
311 | const Mover: dojo.dnd.MoverConstructor; |
|
311 | const Mover: dojo.dnd.MoverConstructor; | |
312 | export = Mover; |
|
312 | export = Mover; | |
313 | } |
|
313 | } | |
314 |
|
314 | |||
315 | declare module 'dojo/dnd/Selector' { |
|
315 | declare module 'dojo/dnd/Selector' { | |
316 | type Selector = dojo.dnd.Selector; |
|
316 | type Selector = dojo.dnd.Selector; | |
317 | const Selector: dojo.dnd.SelectorConstructor; |
|
317 | const Selector: dojo.dnd.SelectorConstructor; | |
318 | export = Selector; |
|
318 | export = Selector; | |
319 | } |
|
319 | } | |
320 |
|
320 | |||
321 | declare module 'dojo/dnd/Source' { |
|
321 | declare module 'dojo/dnd/Source' { | |
322 | type Source = dojo.dnd.Source; |
|
322 | type Source = dojo.dnd.Source; | |
323 | const Source: dojo.dnd.SourceConstructor; |
|
323 | const Source: dojo.dnd.SourceConstructor; | |
324 | export = Source; |
|
324 | export = Source; | |
325 | } |
|
325 | } | |
326 |
|
326 | |||
327 | declare module 'dojo/dnd/Target' { |
|
327 | declare module 'dojo/dnd/Target' { | |
328 | type Target = dojo.dnd.Target; |
|
328 | type Target = dojo.dnd.Target; | |
329 | const Target: dojo.dnd.TargetConstructor; |
|
329 | const Target: dojo.dnd.TargetConstructor; | |
330 | export = Target; |
|
330 | export = Target; | |
331 | } |
|
331 | } | |
332 |
|
332 | |||
333 | declare module 'dojo/dnd/TimedMoveable' { |
|
333 | declare module 'dojo/dnd/TimedMoveable' { | |
334 | type TimedMoveable = dojo.dnd.TimedMoveable; |
|
334 | type TimedMoveable = dojo.dnd.TimedMoveable; | |
335 | const TimedMoveable: dojo.dnd.TimedMoveableConstructor; |
|
335 | const TimedMoveable: dojo.dnd.TimedMoveableConstructor; | |
336 | export = TimedMoveable; |
|
336 | export = TimedMoveable; | |
337 | } |
|
337 | } | |
338 |
|
338 | |||
339 | declare module 'dojo/dojo' { |
|
339 | declare module 'dojo/dojo' { | |
340 | const require: dojo.Require; |
|
340 | const require: dojo.Require; | |
341 | export = require; |
|
341 | export = require; | |
342 | } |
|
342 | } | |
343 |
|
343 | |||
344 | declare module 'require' { |
|
344 | declare module 'require' { | |
345 | const require: dojo.Require; |
|
345 | const require: dojo.Require; | |
346 | export = require; |
|
346 | export = require; | |
347 | } |
|
347 | } | |
348 |
|
348 | |||
349 | declare module 'dojo/dom' { |
|
349 | declare module 'dojo/dom' { | |
350 | const dom: dojo.Dom; |
|
350 | const dom: dojo.Dom; | |
351 | export = dom; |
|
351 | export = dom; | |
352 | } |
|
352 | } | |
353 |
|
353 | |||
354 | declare module 'dojo/dom-attr' { |
|
354 | declare module 'dojo/dom-attr' { | |
355 | const domAttr: dojo.DomAttr; |
|
355 | const domAttr: dojo.DomAttr; | |
356 | export = domAttr; |
|
356 | export = domAttr; | |
357 | } |
|
357 | } | |
358 |
|
358 | |||
359 | declare module 'dojo/dom-class' { |
|
359 | declare module 'dojo/dom-class' { | |
360 | const domClass: dojo.DomClass; |
|
360 | const domClass: dojo.DomClass; | |
361 | export = domClass; |
|
361 | export = domClass; | |
362 | } |
|
362 | } | |
363 |
|
363 | |||
364 | declare module 'dojo/dom-construct' { |
|
364 | declare module 'dojo/dom-construct' { | |
365 | const domConstruct: dojo.DomConstruct; |
|
365 | const domConstruct: dojo.DomConstruct; | |
366 | export = domConstruct; |
|
366 | export = domConstruct; | |
367 | } |
|
367 | } | |
368 |
|
368 | |||
369 | declare module 'dojo/dom-form' { |
|
369 | declare module 'dojo/dom-form' { | |
370 | const domForm: dojo.DomForm; |
|
370 | const domForm: dojo.DomForm; | |
371 | export = domForm; |
|
371 | export = domForm; | |
372 | } |
|
372 | } | |
373 |
|
373 | |||
374 | declare module 'dojo/dom-geometry' { |
|
374 | declare module 'dojo/dom-geometry' { | |
375 | const domGeom: dojo.DomGeometry; |
|
375 | const domGeom: dojo.DomGeometry; | |
376 | export = domGeom; |
|
376 | export = domGeom; | |
377 | } |
|
377 | } | |
378 |
|
378 | |||
379 | declare module 'dojo/dom-prop' { |
|
379 | declare module 'dojo/dom-prop' { | |
380 | const domProp: dojo.DomProp; |
|
380 | const domProp: dojo.DomProp; | |
381 | export = domProp; |
|
381 | export = domProp; | |
382 | } |
|
382 | } | |
383 |
|
383 | |||
384 | declare module 'dojo/dom-style' { |
|
384 | declare module 'dojo/dom-style' { | |
385 | const domStyle: dojo.DomStyle; |
|
385 | const domStyle: dojo.DomStyle; | |
386 | export = domStyle; |
|
386 | export = domStyle; | |
387 | } |
|
387 | } | |
388 |
|
388 | |||
389 | declare module 'dojo/domReady' { |
|
389 | declare module 'dojo/domReady' { | |
390 | const domReady: dojo.DomReady; |
|
390 | const domReady: dojo.DomReady; | |
391 | export = domReady; |
|
391 | export = domReady; | |
392 | } |
|
392 | } | |
393 |
|
393 | |||
394 | declare module 'dojo/domReady!' { |
|
394 | declare module 'dojo/domReady!' { | |
395 | const callback: any; |
|
395 | const callback: any; | |
396 | export = callback; |
|
396 | export = callback; | |
397 | } |
|
397 | } | |
398 |
|
398 | |||
399 | declare module 'dojo/errors/CancelError' { |
|
399 | declare module 'dojo/errors/CancelError' { | |
400 | type CancelError = dojo.errors.CancelError; |
|
400 | type CancelError = dojo.errors.CancelError; | |
401 | const CancelError: dojo.errors.CancelErrorConstructor; |
|
401 | const CancelError: dojo.errors.CancelErrorConstructor; | |
402 | export = CancelError; |
|
402 | export = CancelError; | |
403 | } |
|
403 | } | |
404 |
|
404 | |||
405 | declare module 'dojo/errors/create' { |
|
405 | declare module 'dojo/errors/create' { | |
406 | const create: dojo.errors.Create; |
|
406 | const create: dojo.errors.Create; | |
407 | export = create; |
|
407 | export = create; | |
408 | } |
|
408 | } | |
409 |
|
409 | |||
410 | declare module 'dojo/errors/RequestError' { |
|
410 | declare module 'dojo/errors/RequestError' { | |
411 | type RequestError = dojo.errors.RequestError; |
|
411 | type RequestError = dojo.errors.RequestError; | |
412 | const RequestError: dojo.errors.RequestErrorConstructor; |
|
412 | const RequestError: dojo.errors.RequestErrorConstructor; | |
413 | export = RequestError; |
|
413 | export = RequestError; | |
414 | } |
|
414 | } | |
415 |
|
415 | |||
416 | declare module 'dojo/errors/RequestTimeoutError' { |
|
416 | declare module 'dojo/errors/RequestTimeoutError' { | |
417 | type RequestTimeoutError = dojo.errors.RequestError; |
|
417 | type RequestTimeoutError = dojo.errors.RequestError; | |
418 | const RequestTimeoutError: dojo.errors.RequestTimeoutErrorConstructor; |
|
418 | const RequestTimeoutError: dojo.errors.RequestTimeoutErrorConstructor; | |
419 | export = RequestTimeoutError; |
|
419 | export = RequestTimeoutError; | |
420 | } |
|
420 | } | |
421 |
|
421 | |||
422 | declare module 'dojo/Evented' { |
|
422 | declare module 'dojo/Evented' { | |
423 | type Evented = dojo.Evented; |
|
423 | type Evented = dojo.Evented; | |
424 | const Evented: dojo.EventedConstructor; |
|
424 | const Evented: dojo.EventedConstructor; | |
425 | export = Evented; |
|
425 | export = Evented; | |
426 | } |
|
426 | } | |
427 |
|
427 | |||
428 | declare module 'dojo/gears' { |
|
428 | declare module 'dojo/gears' { | |
429 | const gears: dojo.Gears; |
|
429 | const gears: dojo.Gears; | |
430 | export = gears; |
|
430 | export = gears; | |
431 | } |
|
431 | } | |
432 |
|
432 | |||
433 | declare module 'dojo/has' { |
|
433 | declare module 'dojo/has' { | |
434 | const has: dojo.Has; |
|
434 | const has: dojo.Has; | |
435 | export = has; |
|
435 | export = has; | |
436 | } |
|
436 | } | |
437 |
|
437 | |||
438 | declare module 'dojo/hash' { |
|
438 | declare module 'dojo/hash' { | |
439 | const hash: dojo.Hash; |
|
439 | const hash: dojo.Hash; | |
440 | export = hash; |
|
440 | export = hash; | |
441 | } |
|
441 | } | |
442 |
|
442 | |||
443 | declare module 'dojo/hccss' { |
|
443 | declare module 'dojo/hccss' { | |
444 | const hccss: dojo.Has; |
|
444 | const hccss: dojo.Has; | |
445 | export = hccss; |
|
445 | export = hccss; | |
446 | } |
|
446 | } | |
447 |
|
447 | |||
448 | declare module 'dojo/html' { |
|
448 | declare module 'dojo/html' { | |
449 | const html: dojo.Html; |
|
449 | const html: dojo.Html; | |
450 | export = html; |
|
450 | export = html; | |
451 | } |
|
451 | } | |
452 |
|
452 | |||
453 | declare module 'dojo/i18n' { |
|
453 | declare module 'dojo/i18n' { | |
454 | const i18n: dojo.I18n; |
|
454 | const i18n: dojo.I18n; | |
455 | export = i18n; |
|
455 | export = i18n; | |
456 | } |
|
456 | } | |
457 |
|
457 | |||
458 | declare module 'dojo/io/iframe' { |
|
458 | declare module 'dojo/io/iframe' { | |
459 | const iframe: dojo.io.IFrame; |
|
459 | const iframe: dojo.io.IFrame; | |
460 | export = iframe; |
|
460 | export = iframe; | |
461 | } |
|
461 | } | |
462 |
|
462 | |||
463 | declare module 'dojo/io/script' { |
|
463 | declare module 'dojo/io/script' { | |
464 | const script: dojo.io.Script; |
|
464 | const script: dojo.io.Script; | |
465 | export = script; |
|
465 | export = script; | |
466 | } |
|
466 | } | |
467 |
|
467 | |||
468 | declare module 'dojo/io-query' { |
|
468 | declare module 'dojo/io-query' { | |
469 | const ioQuery: dojo.IoQuery; |
|
469 | const ioQuery: dojo.IoQuery; | |
470 | export = ioQuery; |
|
470 | export = ioQuery; | |
471 | } |
|
471 | } | |
472 |
|
472 | |||
473 | declare module 'dojo/json' { |
|
473 | declare module 'dojo/json' { | |
474 | const json: dojo.Json; |
|
474 | const json: dojo.Json; | |
475 | export = json; |
|
475 | export = json; | |
476 | } |
|
476 | } | |
477 |
|
477 | |||
478 | declare module 'dojo/keys' { |
|
478 | declare module 'dojo/keys' { | |
479 | const keys: dojo.Keys; |
|
479 | const keys: dojo.Keys; | |
480 | export = keys; |
|
480 | export = keys; | |
481 | } |
|
481 | } | |
482 |
|
482 | |||
483 | declare module 'dojo/loadInit' { |
|
483 | declare module 'dojo/loadInit' { | |
484 | const loadInit: dojo.LoadInit; |
|
484 | const loadInit: dojo.LoadInit; | |
485 | export = loadInit; |
|
485 | export = loadInit; | |
486 | } |
|
486 | } | |
487 |
|
487 | |||
488 | declare module 'dojo/loadInit!' { |
|
488 | declare module 'dojo/loadInit!' { | |
489 | const loadInit: (mid: string, require: any, loaded: (...modules: any[]) => void) => void; |
|
489 | const loadInit: (mid: string, require: any, loaded: (...modules: any[]) => void) => void; | |
490 | export = loadInit; |
|
490 | export = loadInit; | |
491 | } |
|
491 | } | |
492 |
|
492 | |||
493 | declare module 'dojo/main' { |
|
493 | declare module 'dojo/main' { | |
494 | const main: dojo._base.Dojo; |
|
494 | const main: dojo._base.Dojo; | |
495 | export = main; |
|
495 | export = main; | |
496 | } |
|
496 | } | |
497 |
|
497 | |||
498 | declare module 'dojo/mouse' { |
|
498 | declare module 'dojo/mouse' { | |
499 | const mouse: dojo.Mouse; |
|
499 | const mouse: dojo.Mouse; | |
500 | export = mouse; |
|
500 | export = mouse; | |
501 | } |
|
501 | } | |
502 |
|
502 | |||
503 | declare module 'dojo/NodeList' { |
|
503 | declare module 'dojo/NodeList' { | |
504 | type NodeList<T extends Node> = dojo.NodeList<T>; |
|
504 | type NodeList<T extends Node> = dojo.NodeList<T>; | |
505 | const NodeList: dojo.NodeListConstructor; |
|
505 | const NodeList: dojo.NodeListConstructor; | |
506 | export = NodeList; |
|
506 | export = NodeList; | |
507 | } |
|
507 | } | |
508 |
|
508 | |||
509 | declare module 'dojo/number' { |
|
509 | declare module 'dojo/number' { | |
510 | const value: dojo.Number; |
|
510 | const value: dojo.Number; | |
511 | export = value; |
|
511 | export = value; | |
512 | } |
|
512 | } | |
513 |
|
513 | |||
514 | declare module 'dojo/on' { |
|
514 | declare module 'dojo/on' { | |
515 | const on: dojo.On; |
|
515 | const on: dojo.On; | |
516 | export = on; |
|
516 | export = on; | |
517 | } |
|
517 | } | |
518 |
|
518 | |||
519 | declare module 'dojo/on/asyncEventListener' { |
|
519 | declare module 'dojo/on/asyncEventListener' { | |
520 | const asyncEventListener: dojo.on.AsyncEventListener; |
|
520 | const asyncEventListener: dojo.on.AsyncEventListener; | |
521 | export = asyncEventListener; |
|
521 | export = asyncEventListener; | |
522 | } |
|
522 | } | |
523 |
|
523 | |||
524 | declare module 'dojo/on/debounce' { |
|
524 | declare module 'dojo/on/debounce' { | |
525 | const debounce: dojo.on.Debounce; |
|
525 | const debounce: dojo.on.Debounce; | |
526 | export = debounce; |
|
526 | export = debounce; | |
527 | } |
|
527 | } | |
528 |
|
528 | |||
529 | declare module 'dojo/on/throttle' { |
|
529 | declare module 'dojo/on/throttle' { | |
530 | const throttle: dojo.on.Throttle; |
|
530 | const throttle: dojo.on.Throttle; | |
531 | export = throttle; |
|
531 | export = throttle; | |
532 | } |
|
532 | } | |
533 |
|
533 | |||
534 | declare module 'dojo/parser' { |
|
534 | declare module 'dojo/parser' { | |
535 | const parser: dojo.Parser; |
|
535 | const parser: dojo.Parser; | |
536 | export = parser; |
|
536 | export = parser; | |
537 | } |
|
537 | } | |
538 |
|
538 | |||
539 | declare module 'dojo/promise/all' { |
|
539 | declare module 'dojo/promise/all' { | |
540 | const all: dojo.promise.All; |
|
540 | const all: dojo.promise.All; | |
541 | export = all; |
|
541 | export = all; | |
542 | } |
|
542 | } | |
543 |
|
543 | |||
544 | declare module 'dojo/promise/first' { |
|
544 | declare module 'dojo/promise/first' { | |
545 | const first: dojo.promise.First; |
|
545 | const first: dojo.promise.First; | |
546 | export = first; |
|
546 | export = first; | |
547 | } |
|
547 | } | |
548 |
|
548 | |||
549 | declare module 'dojo/promise/instrumentation' { |
|
549 | declare module 'dojo/promise/instrumentation' { | |
550 | const instrumentation: dojo.promise.Instrumentation; |
|
550 | const instrumentation: dojo.promise.Instrumentation; | |
551 | export = instrumentation; |
|
551 | export = instrumentation; | |
552 | } |
|
552 | } | |
553 |
|
553 | |||
554 | declare module 'dojo/promise/Promise' { |
|
554 | declare module 'dojo/promise/Promise' { | |
555 | type Promise<T> = dojo.promise.Promise<T>; |
|
555 | type Promise<T> = dojo.promise.Promise<T>; | |
556 | const Promise: dojo.promise.PromiseConstructor; |
|
556 | const Promise: dojo.promise.PromiseConstructor; | |
557 | export = Promise; |
|
557 | export = Promise; | |
558 | } |
|
558 | } | |
559 |
|
559 | |||
560 | declare module 'dojo/promise/tracer' { |
|
560 | declare module 'dojo/promise/tracer' { | |
561 | const tracer: dojo.promise.Tracer; |
|
561 | const tracer: dojo.promise.Tracer; | |
562 | export = tracer; |
|
562 | export = tracer; | |
563 | } |
|
563 | } | |
564 |
|
564 | |||
565 | declare module 'dojo/query' { |
|
565 | declare module 'dojo/query' { | |
566 | const query: dojo.Query; |
|
566 | const query: dojo.Query; | |
567 | export = query; |
|
567 | export = query; | |
568 | } |
|
568 | } | |
569 |
|
569 | |||
570 | /* modules for included selector engines */ |
|
570 | /* modules for included selector engines */ | |
571 |
|
571 | |||
572 | declare module 'dojo/query!acme' { |
|
572 | declare module 'dojo/query!acme' { | |
573 | const query: dojo.Query; |
|
573 | const query: dojo.Query; | |
574 | export = query; |
|
574 | export = query; | |
575 | } |
|
575 | } | |
576 |
|
576 | |||
577 | declare module 'dojo/query!lite' { |
|
577 | declare module 'dojo/query!lite' { | |
578 | const query: dojo.Query; |
|
578 | const query: dojo.Query; | |
579 | export = query; |
|
579 | export = query; | |
580 | } |
|
580 | } | |
581 |
|
581 | |||
582 | declare module 'dojo/ready' { |
|
582 | declare module 'dojo/ready' { | |
583 | const ready: dojo.Ready; |
|
583 | const ready: dojo.Ready; | |
584 | export = ready; |
|
584 | export = ready; | |
585 | } |
|
585 | } | |
586 |
|
586 | |||
587 | declare module 'dojo/regexp' { |
|
587 | declare module 'dojo/regexp' { | |
588 | const regexp: dojo.RegExpModule; |
|
588 | const regexp: dojo.RegExpModule; | |
589 | export = regexp; |
|
589 | export = regexp; | |
590 | } |
|
590 | } | |
591 |
|
591 | |||
592 | declare module 'dojo/request' { |
|
592 | declare module 'dojo/request' { | |
593 | const request: dojo.request.Request; |
|
593 | const request: dojo.request.Request; | |
594 | export = request; |
|
594 | export = request; | |
595 | } |
|
595 | } | |
596 |
|
596 | |||
597 | declare module 'dojo/request/default' { |
|
597 | declare module 'dojo/request/default' { | |
598 | const def: dojo.request.Default; |
|
598 | const def: dojo.request.Default; | |
599 | export = def; |
|
599 | export = def; | |
600 | } |
|
600 | } | |
601 |
|
601 | |||
602 | declare module 'dojo/request/default!' { |
|
602 | declare module 'dojo/request/default!' { | |
603 | const def: dojo.request.Request; |
|
603 | const def: dojo.request.Request; | |
604 | export = def; |
|
604 | export = def; | |
605 | } |
|
605 | } | |
606 |
|
606 | |||
607 | declare module 'dojo/request/handlers' { |
|
607 | declare module 'dojo/request/handlers' { | |
608 | const handlers: dojo.request.Handlers; |
|
608 | const handlers: dojo.request.Handlers; | |
609 | export = handlers; |
|
609 | export = handlers; | |
610 | } |
|
610 | } | |
611 |
|
611 | |||
612 | declare module 'dojo/request/iframe' { |
|
612 | declare module 'dojo/request/iframe' { | |
613 | const iframe: dojo.request.IFrame; |
|
613 | const iframe: dojo.request.IFrame; | |
614 | export = iframe; |
|
614 | export = iframe; | |
615 | } |
|
615 | } | |
616 |
|
616 | |||
617 | declare module 'dojo/request/node' { |
|
617 | declare module 'dojo/request/node' { | |
618 | const node: dojo.request.Node; |
|
618 | const node: dojo.request.Node; | |
619 | export = node; |
|
619 | export = node; | |
620 | } |
|
620 | } | |
621 |
|
621 | |||
622 | declare module 'dojo/request/registry' { |
|
622 | declare module 'dojo/request/registry' { | |
623 | const registry: dojo.request.Registry; |
|
623 | const registry: dojo.request.Registry; | |
624 | export = registry; |
|
624 | export = registry; | |
625 | } |
|
625 | } | |
626 |
|
626 | |||
627 | declare module 'dojo/request/script' { |
|
627 | declare module 'dojo/request/script' { | |
628 | const script: dojo.request.Script; |
|
628 | const script: dojo.request.Script; | |
629 | export = script; |
|
629 | export = script; | |
630 | } |
|
630 | } | |
631 |
|
631 | |||
632 | declare module 'dojo/request/util' { |
|
632 | declare module 'dojo/request/util' { | |
633 | const util: dojo.request.Util; |
|
633 | const util: dojo.request.Util; | |
634 | export = util; |
|
634 | export = util; | |
635 | } |
|
635 | } | |
636 |
|
636 | |||
637 | declare module 'dojo/request/watch' { |
|
637 | declare module 'dojo/request/watch' { | |
638 | const watch: dojo.request.Watch; |
|
638 | const watch: dojo.request.Watch; | |
639 | export = watch; |
|
639 | export = watch; | |
640 | } |
|
640 | } | |
641 |
|
641 | |||
642 | declare module 'dojo/request/xhr' { |
|
642 | declare module 'dojo/request/xhr' { | |
643 | const xhr: dojo.request.Xhr; |
|
643 | const xhr: dojo.request.Xhr; | |
644 | export = xhr; |
|
644 | export = xhr; | |
645 | } |
|
645 | } | |
646 |
|
646 | |||
647 | declare module 'dojo/require' { |
|
647 | declare module 'dojo/require' { | |
648 | const require: dojo.RequirePlugin; |
|
648 | const require: dojo.RequirePlugin; | |
649 | export = require; |
|
649 | export = require; | |
650 | } |
|
650 | } | |
651 |
|
651 | |||
652 | declare module 'dojo/robot' { |
|
652 | declare module 'dojo/robot' { | |
653 | const robot: dojo.Robot; |
|
653 | const robot: dojo.Robot; | |
654 | export = robot; |
|
654 | export = robot; | |
655 | } |
|
655 | } | |
656 |
|
656 | |||
657 | declare module 'dojo/robotx' { |
|
657 | declare module 'dojo/robotx' { | |
658 | const robotx: dojo.RobotX; |
|
658 | const robotx: dojo.RobotX; | |
659 | export = robotx; |
|
659 | export = robotx; | |
660 | } |
|
660 | } | |
661 |
|
661 | |||
662 | declare module 'dojo/router' { |
|
662 | declare module 'dojo/router' { | |
663 | const router: dojo.router.RouterBase; |
|
663 | const router: dojo.router.RouterBase; | |
664 | export = router; |
|
664 | export = router; | |
665 | } |
|
665 | } | |
666 |
|
666 | |||
667 | declare module 'dojo/router/RouterBase' { |
|
667 | declare module 'dojo/router/RouterBase' { | |
668 | type RouterBase = dojo.router.RouterBase; |
|
668 | type RouterBase = dojo.router.RouterBase; | |
669 | const RouterBase: dojo.router.RouterBaseConstructor; |
|
669 | const RouterBase: dojo.router.RouterBaseConstructor; | |
670 | export = RouterBase; |
|
670 | export = RouterBase; | |
671 | } |
|
671 | } | |
672 |
|
672 | |||
673 | declare module 'dojo/rpc/JsonpService' { |
|
673 | declare module 'dojo/rpc/JsonpService' { | |
674 | type JsonpService<T> = dojo.rpc.JsonpService<T>; |
|
674 | type JsonpService<T> = dojo.rpc.JsonpService<T>; | |
675 | const JsonpService: dojo.rpc.JsonpServiceConstructor; |
|
675 | const JsonpService: dojo.rpc.JsonpServiceConstructor; | |
676 | export = JsonpService; |
|
676 | export = JsonpService; | |
677 | } |
|
677 | } | |
678 |
|
678 | |||
679 | declare module 'dojo/rpc/JsonService' { |
|
679 | declare module 'dojo/rpc/JsonService' { | |
680 | type JsonService<T> = dojo.rpc.JsonService<T>; |
|
680 | type JsonService<T> = dojo.rpc.JsonService<T>; | |
681 | const JsonService: dojo.rpc.JsonServiceConstructor; |
|
681 | const JsonService: dojo.rpc.JsonServiceConstructor; | |
682 | export = JsonService; |
|
682 | export = JsonService; | |
683 | } |
|
683 | } | |
684 |
|
684 | |||
685 | declare module 'dojo/rpc/RpcService' { |
|
685 | declare module 'dojo/rpc/RpcService' { | |
686 | type RpcService<T> = dojo.rpc.RpcService<T>; |
|
686 | type RpcService<T> = dojo.rpc.RpcService<T>; | |
687 | const RpcService: dojo.rpc.RpcServiceConstructor; |
|
687 | const RpcService: dojo.rpc.RpcServiceConstructor; | |
688 | export = RpcService; |
|
688 | export = RpcService; | |
689 | } |
|
689 | } | |
690 |
|
690 | |||
691 | declare module 'dojo/selector/_loader' { |
|
691 | declare module 'dojo/selector/_loader' { | |
692 | const loader: dojo.selector.Loader; |
|
692 | const loader: dojo.selector.Loader; | |
693 | export = loader; |
|
693 | export = loader; | |
694 | } |
|
694 | } | |
695 |
|
695 | |||
696 | declare module 'dojo/selector/_loader!' { |
|
696 | declare module 'dojo/selector/_loader!' { | |
697 | const lite: dojo.selector.LiteQueryEnegine; |
|
697 | const lite: dojo.selector.LiteQueryEnegine; | |
698 | export = lite; |
|
698 | export = lite; | |
699 | } |
|
699 | } | |
700 |
|
700 | |||
701 | declare module 'dojo/selector/_loader!acme' { |
|
701 | declare module 'dojo/selector/_loader!acme' { | |
702 | const acme: dojo.selector.AcmeQueryEngine; |
|
702 | const acme: dojo.selector.AcmeQueryEngine; | |
703 | export = acme; |
|
703 | export = acme; | |
704 | } |
|
704 | } | |
705 |
|
705 | |||
706 | declare module 'dojo/selector/_loader!lite' { |
|
706 | declare module 'dojo/selector/_loader!lite' { | |
707 | const lite: dojo.selector.LiteQueryEnegine; |
|
707 | const lite: dojo.selector.LiteQueryEnegine; | |
708 | export = lite; |
|
708 | export = lite; | |
709 | } |
|
709 | } | |
710 |
|
710 | |||
711 | declare module 'dojo/selector/acme' { |
|
711 | declare module 'dojo/selector/acme' { | |
712 | const acme: dojo.selector.AcmeQueryEngine; |
|
712 | const acme: dojo.selector.AcmeQueryEngine; | |
713 | export = acme; |
|
713 | export = acme; | |
714 | } |
|
714 | } | |
715 |
|
715 | |||
716 | declare module 'dojo/selector/lite' { |
|
716 | declare module 'dojo/selector/lite' { | |
717 | const lite: dojo.selector.LiteQueryEnegine; |
|
717 | const lite: dojo.selector.LiteQueryEnegine; | |
718 | export = lite; |
|
718 | export = lite; | |
719 | } |
|
719 | } | |
720 |
|
720 | |||
721 | declare module 'dojo/sniff' { |
|
721 | declare module 'dojo/sniff' { | |
722 | const sniff: dojo.Has; |
|
722 | const sniff: dojo.Has; | |
723 | export = sniff; |
|
723 | export = sniff; | |
724 | } |
|
724 | } | |
725 |
|
725 | |||
726 | declare module 'dojo/Stateful' { |
|
726 | declare module 'dojo/Stateful' { | |
727 |
type Stateful<T = any> = dojo.Stateful< |
|
727 | type Stateful<T = any> = dojo.Stateful<T>; | |
728 | const Stateful: dojo.StatefulConstructor; |
|
728 | const Stateful: dojo.StatefulConstructor; | |
729 | export = Stateful; |
|
729 | export = Stateful; | |
730 | } |
|
730 | } | |
731 |
|
731 | |||
732 | declare module 'dojo/store/api/Store' { |
|
732 | declare module 'dojo/store/api/Store' { | |
733 | type Store<T extends Object, Q extends string | Object | Function, O extends dojo.store.api.QueryOptions> = dojo.store.api.Store<T, Q, O>; |
|
733 | type Store<T extends Object, Q extends string | Object | Function, O extends dojo.store.api.QueryOptions> = dojo.store.api.Store<T, Q, O>; | |
734 | const Store: dojo.store.api.StoreConstructor; |
|
734 | const Store: dojo.store.api.StoreConstructor; | |
735 | export = Store; |
|
735 | export = Store; | |
736 | } |
|
736 | } | |
737 |
|
737 | |||
738 | declare module 'dojo/store/util/QueryResults' { |
|
738 | declare module 'dojo/store/util/QueryResults' { | |
739 | const QueryResults: dojo.store.util.QueryResultsFunction; |
|
739 | const QueryResults: dojo.store.util.QueryResultsFunction; | |
740 | export = QueryResults; |
|
740 | export = QueryResults; | |
741 | } |
|
741 | } | |
742 |
|
742 | |||
743 | declare module 'dojo/store/util/SimpleQueryEngine' { |
|
743 | declare module 'dojo/store/util/SimpleQueryEngine' { | |
744 | const SimpleQueryEngine: dojo.store.util.SimpleQueryEngine; |
|
744 | const SimpleQueryEngine: dojo.store.util.SimpleQueryEngine; | |
745 | export = SimpleQueryEngine; |
|
745 | export = SimpleQueryEngine; | |
746 | } |
|
746 | } | |
747 |
|
747 | |||
748 | declare module 'dojo/store/Cache' { |
|
748 | declare module 'dojo/store/Cache' { | |
749 | const Cache: dojo.store.Cache; |
|
749 | const Cache: dojo.store.Cache; | |
750 | export = Cache; |
|
750 | export = Cache; | |
751 | } |
|
751 | } | |
752 |
|
752 | |||
753 | declare module 'dojo/store/DataStore' { |
|
753 | declare module 'dojo/store/DataStore' { | |
754 | type DataStore<T extends Object> = dojo.store.DataStore<T>; |
|
754 | type DataStore<T extends Object> = dojo.store.DataStore<T>; | |
755 | const DataStore: dojo.store.DataStoreConstructor; |
|
755 | const DataStore: dojo.store.DataStoreConstructor; | |
756 | export = DataStore; |
|
756 | export = DataStore; | |
757 | } |
|
757 | } | |
758 |
|
758 | |||
759 | declare module 'dojo/store/JsonRest' { |
|
759 | declare module 'dojo/store/JsonRest' { | |
760 | type JsonRest<T extends object, Q extends dojo.store.api.BaseQueryType, O extends dojo.store.JsonRestQueryOptions> = dojo.store.JsonRest<T, Q, O>; |
|
760 | type JsonRest<T extends object, Q extends dojo.store.api.BaseQueryType, O extends dojo.store.JsonRestQueryOptions> = dojo.store.JsonRest<T, Q, O>; | |
761 | const JsonRest: dojo.store.JsonRestConstructor; |
|
761 | const JsonRest: dojo.store.JsonRestConstructor; | |
762 | export = JsonRest; |
|
762 | export = JsonRest; | |
763 | } |
|
763 | } | |
764 |
|
764 | |||
765 | declare module 'dojo/store/Memory' { |
|
765 | declare module 'dojo/store/Memory' { | |
766 | type Memory<T extends Object> = dojo.store.Memory<T>; |
|
766 | type Memory<T extends Object> = dojo.store.Memory<T>; | |
767 | const Memory: dojo.store.MemoryConstructor; |
|
767 | const Memory: dojo.store.MemoryConstructor; | |
768 | export = Memory; |
|
768 | export = Memory; | |
769 | } |
|
769 | } | |
770 |
|
770 | |||
771 | declare module 'dojo/store/Observable' { |
|
771 | declare module 'dojo/store/Observable' { | |
772 | const Observerable: dojo.store.Observable; |
|
772 | const Observerable: dojo.store.Observable; | |
773 | export = Observerable; |
|
773 | export = Observerable; | |
774 | } |
|
774 | } | |
775 |
|
775 | |||
776 | declare module 'dojo/string' { |
|
776 | declare module 'dojo/string' { | |
777 | const value: dojo.String; |
|
777 | const value: dojo.String; | |
778 | export = value; |
|
778 | export = value; | |
779 | } |
|
779 | } | |
780 |
|
780 | |||
781 | declare module 'dojo/text' { |
|
781 | declare module 'dojo/text' { | |
782 | const text: dojo.Text; |
|
782 | const text: dojo.Text; | |
783 | export = text; |
|
783 | export = text; | |
784 | } |
|
784 | } | |
785 |
|
785 | |||
786 | declare module 'dojo/throttle' { |
|
786 | declare module 'dojo/throttle' { | |
787 | const throttle: dojo.Throttle; |
|
787 | const throttle: dojo.Throttle; | |
788 | export = throttle; |
|
788 | export = throttle; | |
789 | } |
|
789 | } | |
790 |
|
790 | |||
791 | declare module 'dojo/topic' { |
|
791 | declare module 'dojo/topic' { | |
792 | const hub: dojo.Topic; |
|
792 | const hub: dojo.Topic; | |
793 | export = hub; |
|
793 | export = hub; | |
794 | } |
|
794 | } | |
795 |
|
795 | |||
796 | declare module 'dojo/touch' { |
|
796 | declare module 'dojo/touch' { | |
797 | const touch: dojo.Touch; |
|
797 | const touch: dojo.Touch; | |
798 | export = touch; |
|
798 | export = touch; | |
799 | } |
|
799 | } | |
800 |
|
800 | |||
801 | declare module 'dojo/uacss' { |
|
801 | declare module 'dojo/uacss' { | |
802 | const uacss: dojo.Has; |
|
802 | const uacss: dojo.Has; | |
803 | export = uacss; |
|
803 | export = uacss; | |
804 | } |
|
804 | } | |
805 |
|
805 | |||
806 | declare module 'dojo/when' { |
|
806 | declare module 'dojo/when' { | |
807 | const when: dojo.When; |
|
807 | const when: dojo.When; | |
808 | export = when; |
|
808 | export = when; | |
809 | } |
|
809 | } | |
810 |
|
810 | |||
811 | declare module 'dojo/window' { |
|
811 | declare module 'dojo/window' { | |
812 | const window: dojo.WindowModule; |
|
812 | const window: dojo.WindowModule; | |
813 | export = window; |
|
813 | export = window; | |
814 | } |
|
814 | } | |
815 |
|
815 | |||
816 | declare module 'dojo/i18n!*' { |
|
816 | declare module 'dojo/i18n!*' { | |
817 | const value: any; |
|
817 | const value: any; | |
818 | export = value; |
|
818 | export = value; | |
819 | } |
|
819 | } | |
820 |
|
820 | |||
821 | declare module 'dojo/text!*' { |
|
821 | declare module 'dojo/text!*' { | |
822 | const content: string; |
|
822 | const content: string; | |
823 | export = content; |
|
823 | export = content; | |
824 | } |
|
824 | } |
@@ -1,21 +1,26 | |||||
1 |
import Stateful |
|
1 | import * as Stateful from "dojo/Stateful"; | |
|
2 | import { StatefulAttrs, watch } from "./traits"; | |||
2 |
|
3 | |||
3 | interface ScheduleAttrs { |
|
4 | interface ScheduleAttrs { | |
4 | title: string; |
|
5 | title: string; | |
5 |
|
6 | |||
6 | duration: number; |
|
7 | duration: number; | |
7 |
|
8 | |||
8 | } |
|
9 | } | |
9 |
|
10 | |||
10 | declare class Schedule extends Stateful<ScheduleAttrs> { |
|
11 | declare class Schedule extends Stateful<ScheduleAttrs> { | |
11 | title: string; |
|
12 | title: string; | |
12 |
|
13 | |||
13 |
|
14 | |||
14 | } |
|
15 | } | |
15 |
|
16 | |||
16 | const model = new Schedule({duration: 10, title: "Test event"}); |
|
17 | const model = new Schedule({duration: 10, title: "Test event"}); | |
17 |
|
18 | |||
18 | model.get("title"); |
|
19 | model.get("title"); | |
19 | model.get("duration"); |
|
20 | model.get("duration"); | |
20 |
|
21 | |||
21 | model.set("duration", 12); No newline at end of file |
|
22 | model.set("duration", 12); | |
|
23 | ||||
|
24 | watch(model, "duration", v => v); | |||
|
25 | ||||
|
26 | declare const o : StatefulAttrs<Schedule>; No newline at end of file |
@@ -1,28 +1,26 | |||||
1 |
import Memory |
|
1 | import * as Memory from "dojo/store/Memory"; | |
2 |
import Observable |
|
2 | import * as Observable from "dojo/store/Observable"; | |
3 |
|
3 | |||
4 | interface Schedule { |
|
4 | interface Schedule { | |
5 |
|
5 | |||
6 | id?: string; |
|
6 | id?: string; | |
7 |
|
7 | |||
8 | title: string; |
|
8 | title: string; | |
9 |
|
9 | |||
10 | duration: number; |
|
10 | duration: number; | |
11 | } |
|
11 | } | |
12 |
|
12 | |||
13 | declare const store: dojo.store.api.Store<Schedule>; |
|
13 | declare const store: dojo.store.api.Store<Schedule>; | |
14 |
|
14 | |||
15 | const observable = new Observable(store); |
|
15 | const observable = new Observable(store); | |
16 |
|
16 | |||
17 | const mem = new Memory<Schedule>(); |
|
17 | const mem = new Memory<Schedule>(); | |
18 |
|
18 | |||
19 | (async () => { |
|
19 | observable.query().observe(() => { }); | |
20 |
|
|
20 | store.query().forEach(() => { }); | |
21 | store.query().forEach(() => {}); |
|
21 | const total = await store.query().total; | |
22 |
|
|
22 | const result = await store.query(); | |
23 | const result = await store.query(); |
|
|||
24 |
|
23 | |||
25 |
|
|
24 | mem.query(); | |
26 |
|
25 | |||
27 |
|
|
26 | mem.add({ duration: 10, title: "Test event" }); | |
28 | })(); No newline at end of file |
|
@@ -1,17 +1,41 | |||||
1 |
import _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); |
@@ -1,22 +1,24 | |||||
1 | { |
|
1 | { | |
2 | "extends": "../tsconfig", |
|
2 | "extends": "../tsconfig", | |
3 | "compilerOptions": { |
|
3 | "compilerOptions": { | |
4 | "baseUrl": ".", |
|
4 | "baseUrl": ".", | |
5 | "rootDir": "ts", |
|
5 | "rootDir": "ts", | |
6 | "rootDirs": [ |
|
6 | "rootDirs": [ | |
7 | "ts", |
|
7 | "ts", | |
|
8 | "typings", | |||
8 | "../main/ts" |
|
9 | "../main/ts" | |
9 | ], |
|
10 | ], | |
10 | "types": [ |
|
11 | "types": [ | |
11 | "requirejs", |
|
12 | "requirejs", | |
12 | "../main/typings/dojo/modules", |
|
13 | "../main/typings/dojo/modules", | |
13 | "../main/typings/dijit/modules" |
|
14 | "../main/typings/dijit/modules" | |
14 | ], |
|
15 | ], | |
15 |
"module": " |
|
16 | "module": "ESNext", | |
|
17 | "target": "ESNext" | |||
16 | }, |
|
18 | }, | |
17 | "include": [ |
|
19 | "include": [ | |
18 | "typings/**/*.ts", |
|
20 | "typings/**/*.ts", | |
19 | "ts/**/*.ts", |
|
21 | "ts/**/*.ts", | |
20 | "ts/**/*.tsx" |
|
22 | "ts/**/*.tsx" | |
21 | ] |
|
23 | ] | |
22 | } No newline at end of file |
|
24 | } |
General Comments 0
You need to be logged in to leave comments.
Login now