From d4460ea9416b21c08bdc894dc81f2142250e1de1 Mon Sep 17 00:00:00 2001 From: David Gardiner Date: Thu, 15 Jan 2015 12:02:30 +1030 Subject: [PATCH 1/7] Missing methods and optional arguments --- ember/ember.d.ts | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/ember/ember.d.ts b/ember/ember.d.ts index b6cdde9d6..a599782f9 100644 --- a/ember/ember.d.ts +++ b/ember/ember.d.ts @@ -88,16 +88,17 @@ interface Array { every(callback: Function, target?: any): boolean; everyBy(key: string, value?: string): boolean; everyProperty(key: string, value?: any): boolean; - filter(callback: Function, target: any): any[]; + filter(callback: Function, target?: any): any[]; filterBy(key: string, value?: string): any[]; - find(callback: Function, target: any): any; + find(callback: Function, target?: any): any; findBy(key: string, value?: string): any; forEach(callback: Function, target?: any): any; getEach(key: string): any[]; - indexOf(object: any, startAt: number): number; + indexOf(object: any, startAt?: number): number; insertAt(idx: number, object: any): any[]; invoke(methodName: string, ...args: any[]): any[]; - lastIndexOf(object: any, startAt: number): number; + lastIndexOf(object: any, startAt?: number): number; + map(callback: Function, target?: any): any[]; mapBy(key: string): any[]; nextObject(index: number, previousObject: any, context: any): any; objectAt(idx: number): any; @@ -154,6 +155,9 @@ interface Array { toggleProperty(keyName: string): any; copy(deep: boolean): any[]; frozenCopy(): any[]; + // 1.3 + isAny(key: string, value?: string): boolean; + isEvery(key: string, value?: string): boolean; } interface ApplicationCreateArguments { From ad18fda593e59d74a80f2ffc36a8501fb9f83547 Mon Sep 17 00:00:00 2001 From: David Gardiner Date: Wed, 21 Jan 2015 10:44:13 +1030 Subject: [PATCH 2/7] jsdocs for find() Optional arguments for find() and Handlebars.helper() --- ember/ember.d.ts | 29 ++++++++++++++++++++++++++--- 1 file changed, 26 insertions(+), 3 deletions(-) diff --git a/ember/ember.d.ts b/ember/ember.d.ts index a599782f9..3f926ae12 100644 --- a/ember/ember.d.ts +++ b/ember/ember.d.ts @@ -90,6 +90,29 @@ interface Array { everyProperty(key: string, value?: any): boolean; filter(callback: Function, target?: any): any[]; filterBy(key: string, value?: string): any[]; + + /** + Returns the first item in the array for which the callback returns true. + This method works similar to the `filter()` method defined in JavaScript 1.6 + except that it will stop working on the array once a match is found. + The callback method you provide should have the following signature (all + parameters are optional): + ```javascript + function(item, index, enumerable); + ``` + - `item` is the current item in the iteration. + - `index` is the current index in the iteration. + - `enumerable` is the enumerable object itself. + It should return the `true` to include the item in the results, `false` + otherwise. + Note that in addition to a callback, you can also pass an optional target + object that will be set as `this` on the context. This is a good way + to give your iterator function access to the current object. + @function find + @arg callback The callback to execute + @arg {Object} [target] The target object to use + @return {Object} Found item or `undefined`. +*/ find(callback: Function, target?: any): any; findBy(key: string, value?: string): any; forEach(callback: Function, target?: any): any; @@ -403,7 +426,7 @@ declare module Ember { everyProperty(key: string, value?: string): boolean; filter(callback: Function, target: any): any[]; filterBy(key: string, value?: string): any[]; - find(callback: Function, target: any): any; + find(callback: Function, target?: any): any; findBy(key: string, value?: string): any; forEach(callback: Function, target?: any): any; getEach(key: string): any[]; @@ -1005,8 +1028,8 @@ declare module Ember { module Handlebars { function compile(string: string): Function; function get(root: any, path: string, options?: {}): any; - function helper(name: string, func: Function, dependentKeys: string): void; - function helper(name: string, view: View, dependentKeys: string): void; + function helper(name: string, func: Function, dependentKeys?: string): void; + function helper(name: string, view: View, dependentKeys?: string): void; class helpers { action(actionName: string, context: any, options?: {}): void; bindAttr(options?: {}): string; From 93928c19d6b9cb13c357b6a458f1b81bd81caa05 Mon Sep 17 00:00:00 2001 From: David Gardiner Date: Wed, 21 Jan 2015 11:50:50 +1030 Subject: [PATCH 3/7] Change any[] to Enumerable --- ember/ember.d.ts | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/ember/ember.d.ts b/ember/ember.d.ts index 3f926ae12..682f796d6 100644 --- a/ember/ember.d.ts +++ b/ember/ember.d.ts @@ -522,7 +522,7 @@ declare module Ember { static isClass: boolean; static isMethod: boolean; addArrayObserver(target: any, opts?: EnumerableConfigurationOptions): any[]; - addEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): any[]; + addEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): Enumerable; any(callback: Function, target?: any): boolean; anyBy(key: string, value?: string): boolean; arrayContentDidChange(startIdx: number, removeAmt: number, addAmt: number): any[]; @@ -539,10 +539,10 @@ declare module Ember { enumerableContentDidChange(removing: Enumerable, adding: number): any; enumerableContentDidChange(removing: number, adding: Enumerable): any; enumerableContentDidChange(removing: Enumerable, adding: Enumerable): any; - enumerableContentWillChange(removing: number, adding: number): any[]; - enumerableContentWillChange(removing: Enumerable, adding: number): any[]; - enumerableContentWillChange(removing: number, adding: Enumerable): any[]; - enumerableContentWillChange(removing: Enumerable, adding: Enumerable): any[]; + enumerableContentWillChange(removing: number, adding: number): Enumerable; + enumerableContentWillChange(removing: Enumerable, adding: number): Enumerable; + enumerableContentWillChange(removing: number, adding: Enumerable): Enumerable; + enumerableContentWillChange(removing: Enumerable, adding: Enumerable): Enumerable; every(callback: Function, target?: any): boolean; everyBy(key: string, value?: string): boolean; everyProperty(key: string, value?: string): boolean; @@ -570,7 +570,7 @@ declare module Ember { rejectBy(key: string, value?: string): any[]; removeArrayObserver(target: any, opts: EnumerableConfigurationOptions): any[]; removeAt(start: number, len: number): any; - removeEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): any[]; + removeEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): Enumerable; replace(idx: number, amt: number, objects: any[]): any; replaceContent(idx: number, amt: number, objects: any[]): void; reverseObjects(): any[]; @@ -580,10 +580,10 @@ declare module Ember { slice(beginIndex?: number, endIndex?: number): any[]; some(callback: Function, target?: any): boolean; toArray(): any[]; - uniq(): any[]; + uniq(): Enumerable; unshiftObject(object: any): any; unshiftObjects(objects: any[]): any[]; - without(value: any): any[]; + without(value: any): Enumerable; '[]': any[]; '@each': EachProxy; Boolean: boolean; @@ -592,9 +592,9 @@ declare module Ember { lastObject: any; length: number; addObject(object: any): any; - addObjects(objects: Enumerable): any[]; + addObjects(objects: Enumerable): MutableEnumberable; removeObject(object: any): any; - removeObjects(objects: Enumerable): any[]; + removeObjects(objects: Enumerable): MutableEnumberable; } var BOOTED: boolean; /** From 6f6dd3c30939f00493f621467784f7b439254aea Mon Sep 17 00:00:00 2001 From: David Gardiner Date: Wed, 21 Jan 2015 12:02:18 +1030 Subject: [PATCH 4/7] Update EmberStates.Transition --- ember/ember.d.ts | 201 +++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 168 insertions(+), 33 deletions(-) diff --git a/ember/ember.d.ts b/ember/ember.d.ts index 682f796d6..2fd4ec555 100644 --- a/ember/ember.d.ts +++ b/ember/ember.d.ts @@ -11,15 +11,147 @@ declare var Handlebars: HandlebarsStatic; declare module EmberStates { interface Transition { - abort(): void; - addInitialStates(): void; - matchContextsToStates(contexts: any[]): void; - normalize(manager: Ember.StateManager, contexts: any[]): void; - removeUnchangedContexts(manager: Ember.StateManager): void; - retry(): void; - sendEvents(eventName: string, sendRecursiveArguments: boolean, isUnhandledPass: boolean): void; - sendRecursively(event: string, currentState: Ember.State, isUnhandledPass: boolean): void; targetName: string; + urlMethod: string; + intent: any; + params: {}; + pivotHandler: any; + resolveIndex: number; + handlerInfos: any; + resolvedModels: {}; + isActive: boolean; + state: any; + queryParams: {}; + queryParamsOnly: boolean; + + isTransition: boolean; + + /** + The Transition's internal promise. Calling `.then` on this property + is that same as calling `.then` on the Transition object itself, but + this property is exposed for when you want to pass around a + Transition's promise, but not the Transition object itself, since + Transition object can be externally `abort`ed, while the promise + cannot. + */ + promise: Ember.RSVP.Promise; + + /** + Custom state can be stored on a Transition's `data` object. + This can be useful for decorating a Transition within an earlier + hook and shared with a later hook. Properties set on `data` will + be copied to new transitions generated by calling `retry` on this + transition. + */ + data: any; + + /** + A standard promise hook that resolves if the transition + succeeds and rejects if it fails/redirects/aborts. + + Forwards to the internal `promise` property which you can + use in situations where you want to pass around a thennable, + but not the Transition itself. + + @arg {Function} onFulfilled + @arg {Function} onRejected + @arg {String} label optional string for labeling the promise. Useful for tooling. + @return {Promise} + */ + then(onFulfilled: Function, onRejected: Function, label?: string): Ember.RSVP.Promise; + + /** + Forwards to the internal `promise` property which you can + use in situations where you want to pass around a thennable, + but not the Transition itself. + + @method catch + @arg {Function} onRejection + @arg {String} label optional string for labeling the promise. + Useful for tooling. + @return {Promise} + */ + catch(onRejection: Function, label?: string): Ember.RSVP.Promise; + + /** + Forwards to the internal `promise` property which you can + use in situations where you want to pass around a thennable, + but not the Transition itself. + + @method finally + @arg {Function} callback + @arg {String} label optional string for labeling the promise. + Useful for tooling. + @return {Promise} + */ + finally(callback: Function, label?: string): Ember.RSVP.Promise; + + /** + Aborts the Transition. Note you can also implicitly abort a transition + by initiating another transition while a previous one is underway. + */ + abort(): EmberStates.Transition; + normalize(manager: Ember.StateManager, contexts: any[]): void; + + /** + Retries a previously-aborted transition (making sure to abort the + transition if it's still active). Returns a new transition that + represents the new attempt to transition. + */ + retry(): EmberStates.Transition; + + /** + Sets the URL-changing method to be employed at the end of a + successful transition. By default, a new Transition will just + use `updateURL`, but passing 'replace' to this method will + cause the URL to update using 'replaceWith' instead. Omitting + a parameter will disable the URL change, allowing for transitions + that don't update the URL at completion (this is also used for + handleURL, since the URL has already changed before the + transition took place). + + @arg {String} method the type of URL-changing method to use + at the end of a transition. Accepted values are 'replace', + falsy values, or any other non-falsy value (which is + interpreted as an updateURL transition). + + @return {Transition} this transition + */ + method(method: string): EmberStates.Transition; + + /** + Fires an event on the current list of resolved/resolving + handlers within this transition. Useful for firing events + on route hierarchies that haven't fully been entered yet. + + Note: This method is also aliased as `send` + + @arg {Boolean} [ignoreFailure=false] a boolean specifying whether unhandled events throw an error + @arg {String} name the name of the event to fire + */ + trigger(ignoreFailure:boolean, eventName: string); + /** + Fires an event on the current list of resolved/resolving + handlers within this transition. Useful for firing events + on route hierarchies that haven't fully been entered yet. + + Note: This method is also aliased as `send` + + @arg {String} name the name of the event to fire + */ + trigger(eventName: string); + + /** + Transitions are aborted and their promises rejected + when redirects occur; this method returns a promise + that will follow any redirects that occur and fulfill + with the value fulfilled by any redirecting transitions + that occur. + + @return {Promise} a promise that fulfills with the same + value that the final redirecting transition fulfills with + */ + followRedirects(): Ember.RSVP.Promise; } } @@ -1334,7 +1466,7 @@ declare module Ember { constructor(arr: any[]); static activate(): void; addArrayObserver(target: any, opts?: EnumerableConfigurationOptions): any[]; - addEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): any[]; + addEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): Enumerable; any(callback: Function, target?: any): boolean; anyBy(key: string, value?: string): boolean; arrayContentDidChange(startIdx: number, removeAmt: number, addAmt: number): any[]; @@ -1351,10 +1483,10 @@ declare module Ember { enumerableContentDidChange(removing: Enumerable, adding: number): any; enumerableContentDidChange(removing: number, adding: Enumerable): any; enumerableContentDidChange(removing: Enumerable, adding: Enumerable): any; - enumerableContentWillChange(removing: number, adding: number): any[]; - enumerableContentWillChange(removing: Enumerable, adding: number): any[]; - enumerableContentWillChange(removing: number, adding: Enumerable): any[]; - enumerableContentWillChange(removing: Enumerable, adding: Enumerable): any[]; + enumerableContentWillChange(removing: number, adding: number): Enumerable; + enumerableContentWillChange(removing: Enumerable, adding: number): Enumerable; + enumerableContentWillChange(removing: number, adding: Enumerable): Enumerable; + enumerableContentWillChange(removing: Enumerable, adding: Enumerable): Enumerable; every(callback: Function, target?: any): boolean; everyBy(key: string, value?: string): boolean; everyProperty(key: string, value?: any): boolean; @@ -1381,7 +1513,7 @@ declare module Ember { rejectBy(key: string, value?: string): any[]; removeArrayObserver(target: any, opts: EnumerableConfigurationOptions): any[]; removeAt(start: number, len: number): any; - removeEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): any[]; + removeEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): Enumerable; replace(idx: number, amt: number, objects: any[]): any; reverseObjects(): any[]; setEach(key: string, value?: any): any; @@ -1390,10 +1522,10 @@ declare module Ember { slice(beginIndex?: number, endIndex?: number): any[]; some(callback: Function, target?: any): boolean; toArray(): any[]; - uniq(): any[]; + uniq(): Enumerable; unshiftObject(object: any): any; unshiftObjects(objects: any[]): any[]; - without(value: any): any[]; + without(value: any): Enumerable; '[]': any[]; '@each': EachProxy; Boolean: boolean; @@ -1402,30 +1534,30 @@ declare module Ember { lastObject: any; length: number; addObject(object: any): any; - addObjects(objects: Enumerable): any[]; + addObjects(objects: Enumerable): MutableEnumberable; removeObject(object: any): any; - removeObjects(objects: Enumerable): any[]; + removeObjects(objects: Enumerable): MutableEnumberable; addObserver: ModifyObserver; - beginPropertyChanges(): any[]; + beginPropertyChanges(): Observable; cacheFor(keyName: string): any; decrementProperty(keyName: string, decrement?: number): number; - endPropertyChanges(): any[]; + endPropertyChanges(): Observable; get(keyName: string): any; getProperties(...args: string[]): {}; getProperties(keys: string[]): {}; getWithDefault(keyName: string, defaultValue: any): any; hasObserverFor(key: string): boolean; incrementProperty(keyName: string, increment?: number): number; - notifyPropertyChange(keyName: string): any[]; - propertyDidChange(keyName: string): any[]; - propertyWillChange(keyName: string): any[]; - removeObserver(key: string, target: any, method: string): Observable; - removeObserver(key: string, target: any, method: Function): Observable; - set(keyName: string, value: any): any[]; - setProperties(hash: {}): any[]; + notifyPropertyChange(keyName: string): Observable; + propertyDidChange(keyName: string): Observable; + propertyWillChange(keyName: string): Observable; + removeObserver(key: string, target: any, method: string): void; + removeObserver(key: string, target: any, method: Function): void; + set(keyName: string, value: any): Observable; + setProperties(hash: {}): Observable; toggleProperty(keyName: string): any; - copy(deep: boolean): any[]; - frozenCopy(): any[]; + copy(deep: boolean): Copyable; + frozenCopy(): Copyable; } class NoneLocation extends Object { static detect(obj: any): boolean; @@ -1549,11 +1681,14 @@ declare module Ember { notifyPropertyChange(keyName: string): Observable; propertyDidChange(keyName: string): Observable; propertyWillChange(keyName: string): Observable; - removeObserver(key: string, target: {}, method: string): Observable; - removeObserver(key: string, target: {}, method: Function): Observable; + removeObserver(key: string, target: {}, method: string): void; + removeObserver(key: string, target: {}, method: Function): void; set(keyName: string, value: any): Observable; setProperties(hash: {}): Observable; - toggleProperty(keyName: string): any; + /** + Set the value of a boolean property to the opposite of its current value. + */ + toggleProperty(keyName: string): boolean; } class OrderedSet { add(obj: any): void; @@ -1623,7 +1758,7 @@ declare module Ember { serialize(model: {}, params: string[]): string; setupController(controller: Controller, model: {}): void; // ReSharper disable once InconsistentNaming - transitionTo(name: string, ...object: any[]): void; + transitionTo(name: string, ...object: any[]): EmberStates.Transition; actions: ActionsHash; } class Router extends Object { From c5e9ada526e016b8a1a1f7c0a88815966b223aa2 Mon Sep 17 00:00:00 2001 From: David Gardiner Date: Wed, 25 Feb 2015 14:56:10 +1030 Subject: [PATCH 5/7] Arrays are more flexible extend can take mixin parameter Add external ambient module --- ember/ember.d.ts | 248 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 245 insertions(+), 3 deletions(-) diff --git a/ember/ember.d.ts b/ember/ember.d.ts index 2fd4ec555..2ba1a1aab 100644 --- a/ember/ember.d.ts +++ b/ember/ember.d.ts @@ -14,14 +14,14 @@ declare module EmberStates { targetName: string; urlMethod: string; intent: any; - params: {}; + params: any; pivotHandler: any; resolveIndex: number; handlerInfos: any; - resolvedModels: {}; + resolvedModels: any; isActive: boolean; state: any; - queryParams: {}; + queryParams: any; queryParamsOnly: boolean; isTransition: boolean; @@ -1581,6 +1581,7 @@ declare module Ember { Creates a subclass of the Object class. **/ static extend(arguments?: CoreObjectArguments): T; + static extend(mixins? : Mixin, arguments?: CoreObjectArguments): T; /** Creates an instance of the class. @param arguments A hash containing values with which to initialize the newly instantiated object. @@ -2612,3 +2613,244 @@ declare module Em { var watchedEvents: typeof Ember.watchedEvents; var wrap: typeof Ember.wrap; } + +/** + * External ambient module - to allow "import Ember = require('Ember');" to work correctly + */ + +declare module "Ember" { + + var $: typeof Ember.$; + var A: typeof Ember.A; + class ActionHandlerMixin extends Ember.ActionHandlerMixin { } + class Application extends Ember.Application { } + class Array extends Ember.Array { } + class ArrayController extends Ember.ArrayController { } + var ArrayPolyfills: typeof Ember.ArrayPolyfills; + class ArrayProxy extends Ember.ArrayProxy { } + var BOOTED: typeof Ember.BOOTED; + class Binding extends Ember.Binding { } + class Button extends Ember.Button { } + class Checkbox extends Ember.Checkbox { } + class CollectionView extends Ember.CollectionView { } + class Comparable extends Ember.Comparable { } + class Component extends Ember.Component { } + class ComputedProperty extends Ember.ComputedProperty { } + class Container extends Ember.Container { } + class ContainerView extends Ember.ContainerView { } + class Controller extends Ember.Controller { } + class ControllerMixin extends Ember.ControllerMixin { } + class Copyable extends Ember.Copyable { } + class CoreObject extends Ember.CoreObject { } + class CoreView extends Ember.CoreView { } + class DAG extends Ember.DAG { } + var DEFAULT_GETTER_FUNCTION: typeof Ember.DEFAULT_GETTER_FUNCTION; + class DefaultResolver extends Ember.DefaultResolver { } + class Deffered extends Ember.Deferred { } + class DeferredMixin extends Ember.DeferredMixin { } + class Descriptor extends Ember.Descriptor { } + var EMPTY_META: typeof Ember.EMPTY_META; + var ENV: typeof Ember.ENV; + var EXTEND_PROTOTYPES: typeof Ember.EXTEND_PROTOTYPES; + class EachProxy extends Ember.EachProxy { } + class Enumerable extends Ember.Enumerable { } + var EnumerableUtils: typeof Ember.EnumerableUtils; + var Error: typeof Ember.Error; + class EventDispatcher extends Ember.EventDispatcher { } + class Evented extends Ember.Evented { } + var FROZEN_ERROR: typeof Ember.FROZEN_ERROR; + class Freezable extends Ember.Freezable { } + var GUID_KEY: typeof Ember.GUID_KEY; + module Handlebars { + var compile: typeof Ember.Handlebars.compile; + var get: typeof Ember.Handlebars.get; + var helper: typeof Ember.Handlebars.helper; + class helpers extends Ember.Handlebars.helpers { } + var precompile: typeof Ember.Handlebars.precompile; + var registerBoundHelper: typeof Ember.Handlebars.registerBoundHelper; + class Compiler extends Ember.Handlebars.Compiler { } + class JavaScriptCompiler extends Ember.Handlebars.JavaScriptCompiler { } + var registerHelper: typeof Ember.Handlebars.registerHelper; + var registerPartial: typeof Ember.Handlebars.registerPartial; + var K: typeof Ember.Handlebars.K; + var createFrame: typeof Ember.Handlebars.createFrame; + var Exception: typeof Ember.Handlebars.Exception; + class SafeString extends Ember.Handlebars.SafeString { } + var parse: typeof Ember.Handlebars.parse; + var print: typeof Ember.Handlebars.print; + var logger: typeof Ember.Handlebars.logger; + var log: typeof Ember.Handlebars.log; + } + class HashLocation extends Ember.HashLocation { } + class HistoryLocation extends Ember.HistoryLocation { } + var IS_BINDING: typeof Ember.IS_BINDING; + class Instrumentation extends Ember.Instrumentation { } + var K: typeof Ember.K; + var LOG_BINDINGS: typeof Ember.LOG_BINDINGS; + var LOG_STACKTRACE_ON_DEPRECATION: typeof Ember.LOG_STACKTRACE_ON_DEPRECATION; + var LOG_VERSION: typeof Ember.LOG_VERSION; + class LinkView extends Ember.LinkView { } + class Location extends Ember.Location { } + var Logger: typeof Ember.Logger; + var MANDATORY_SETTER_FUNCTION: typeof Ember.MANDATORY_SETTER_FUNCTION; + var META_KEY: typeof Ember.META_KEY; + class Map extends Ember.Map { } + class MapWithDefault extends Ember.MapWithDefault { } + class Mixin extends Ember.Mixin { } + class MutableArray extends Ember.MutableArray { } + class MutableEnumerable extends Ember.MutableEnumberable { } + var NAME_KEY: typeof Ember.NAME_KEY; + class Namespace extends Ember.Namespace { } + class NativeArray extends Ember.NativeArray { } + class NoneLocation extends Ember.NoneLocation { } + var ORDER_DEFINITION: typeof Ember.ORDER_DEFINITION; + class Object extends Ember.Object { } + class ObjectController extends Ember.ObjectController { } + class ObjectProxy extends Ember.ObjectProxy { } + class Observable extends Ember.Observable { } + class OrderedSet extends Ember.OrderedSet { } + module RSVP { + class Promise extends Ember.RSVP.Promise { } + } + class RenderBuffer extends Ember.RenderBuffer { } + class Route extends Ember.Route { } + class Router extends Ember.Router { } + class RouterDSL extends Ember.RouterDSL { } + var SHIM_ES5: typeof Ember.SHIM_ES5; + var STRINGS: typeof Ember.STRINGS; + class Select extends Ember.Select { } + class SelectOption extends Ember.SelectOption { } + class Set extends Ember.Set { } + class SortableMixin extends Ember.SortableMixin { } + class State extends Ember.State { } + class StateManager extends Ember.StateManager { } + module String { + var camelize: typeof Ember.String.camelize; + var capitalize: typeof Ember.String.capitalize; + var classify: typeof Ember.String.classify; + var dasherize: typeof Ember.String.dasherize; + var decamelize: typeof Ember.String.decamelize; + var fmt: typeof Ember.String.fmt; + var htmlSafe: typeof Ember.String.htmlSafe; + var loc: typeof Ember.String.loc; + var underscore: typeof Ember.String.underscore; + var w: typeof Ember.String.w; + } + var TEMPLATES: typeof Ember.TEMPLATES; + class TargetActionSupport extends Ember.TargetActionSupport { } + class Test extends Ember.Test { } + class TextArea extends Ember.TextArea { } + class TextField extends Ember.TextField { } + class TextSupport extends Ember.TextSupport { } + var VERSION: typeof Ember.VERSION; + class View extends Ember.View { } + class ViewTargetActionSupport extends Ember.ViewTargetActionSupport { } + var ViewUtils: typeof Ember.ViewUtils; + var addBeforeObserver: typeof Ember.addBeforeObserver; + var addListener: typeof Ember.addListener; + var addObserver: typeof Ember.addObserver; + var alias: typeof Ember.alias; + var aliasMethod: typeof Ember.aliasMethod; + var anyUnprocessedMixins: typeof Ember.anyUnprocessedMixins; + var assert: typeof Ember.assert; + var beforeObserver: typeof Ember.beforeObserver; + var beforeObserversFor: typeof Ember.beforeObserversFor; + var beginPropertyChanges: typeof Ember.beginPropertyChanges; + var bind: typeof Ember.bind; + var cacheFor: typeof Ember.cacheFor; + var canInvoke: typeof Ember.canInvoke; + var changeProperties: typeof Ember.changeProperties; + var compare: typeof Ember.compare; + var computed: typeof Ember.computed; + var config: typeof Ember.config; + var controllerFor: typeof Ember.controllerFor; + var copy: typeof Ember.copy; + var create: typeof Ember.create; + var debug: typeof Ember.debug; + var defineProperty: typeof defineProperty; + var deprecate: typeof deprecate; + var deprecateFunc: typeof deprecateFunc; + var destroy: typeof Ember.destroy; + var empty: typeof deprecateFunc; + var endPropertyChanges: typeof Ember.endPropertyChanges; + var exports: typeof Ember.exports; + var finishChains: typeof Ember.finishChains; + var flushPendingChains: typeof Ember.flushPendingChains; + var generateController: typeof Ember.generateController; + var generateGuid: typeof Ember.generateGuid; + var get: typeof Ember.get; + var getMeta: typeof Ember.getMeta; + var getPath: typeof Ember.getPath; + var getWithDefault: typeof Ember.getWithDefault; + var guidFor: typeof Ember.guidFor; + var handleErrors: typeof Ember.handleErrors; + var hasListeners: typeof Ember.hasListeners; + var hasOwnProperty: typeof Ember.hasOwnProperty; + var immediateObserver: typeof immediateObserver; + var imports: typeof Ember.imports; + var inspect: typeof Ember.inspect; + var instrument: typeof Ember.instrument; + var isArray: typeof Ember.isArray; + var isEmpty: typeof Ember.isEmpty; + var isEqual: typeof Ember.isEqual; + var isGlobalPath: typeof Ember.isGlobalPath; + var isNamespace: typeof Ember.isNamespace; + var isNone: typeof Ember.isNone; + var isPrototypeOf: typeof Ember.isPrototypeOf; + var isWatching: typeof Ember.isWatching; + var keys: typeof Ember.keys; + var listenersDiff: typeof Ember.listenersDiff; + var listenersFor: typeof Ember.listenersFor; + var listenersUnion: typeof Ember.listenersUnion; + var lookup: typeof Ember.lookup; + var makeArray: typeof Ember.makeArray; + var merge: typeof Ember.merge; + var meta: typeof Ember.meta; + var metaPath: typeof Ember.metaPath; + var mixin: typeof Ember.mixin; + var none: typeof Ember.none; + var normalizeTuple: typeof Ember.normalizeTuple; + var observer: typeof Ember.observer; + var observersFor: typeof Ember.observersFor; + var onLoad: typeof Ember.onLoad; + var oneWay: typeof Ember.oneWay; + var onError: typeof Ember.onError; + var overrideChains: typeof Ember.overrideChains; + var platform: typeof Ember.platform; + var propertyDidChange: typeof Ember.propertyDidChange; + var propertyIsEnumerable: typeof Ember.propertyIsEnumerable; + var propertyWillChange: typeof Ember.propertyWillChange; + var removeBeforeObserver: typeof Ember.removeBeforeObserver; + var removeChainWatcher: typeof Ember.removeChainWatcher; + var removeListener: typeof Ember.removeListener; + var removeObserver: typeof Ember.removeObserver; + var required: typeof Ember.required; + var rewatch: typeof Ember.rewatch; + var run: typeof Ember.run; + var runLoadHooks: typeof Ember.runLoadHooks; + var sendEvent: typeof Ember.sendEvent; + var set: typeof Ember.set; + var setMeta: typeof Ember.setMeta; + var setPath: typeof Ember.setPath; + var setProperties: typeof Ember.setProperties; + var subscribe: typeof Ember.subscribe; + var toLocaleString: typeof Ember.toLocaleString; + var toString: typeof Ember.toString; + var tryCatchFinally: typeof Ember.tryCatchFinally; + var tryFinally: typeof Ember.tryFinally; + var tryInvoke: typeof Ember.tryInvoke; + var trySet: typeof Ember.trySet; + var trySetPath: typeof Ember.trySetPath; + var typeOf: typeof Ember.typeOf; + var unwatch: typeof Ember.unwatch; + var unwatchKey: typeof Ember.unwatchKey; + var unwatchPath: typeof Ember.unwatchPath; + var uuid: typeof Ember.uuid; + var valueOf: typeof Ember.valueOf; + var warn: typeof Ember.warn; + var watch: typeof Ember.watch; + var watchKey: typeof Ember.watchKey; + var watchPath: typeof Ember.watchPath; + var watchedEvents: typeof Ember.watchedEvents; + var wrap: typeof Ember.wrap; +} From c2cfd165ef7a36d1347485d8680426762eaaedba Mon Sep 17 00:00:00 2001 From: David Gardiner Date: Wed, 25 Feb 2015 15:52:38 +1030 Subject: [PATCH 6/7] Fix errors from compiling with with --noImplicitAny Set Error as type 'any' because we can't currently refer to the global Error type --- ember/ember-tests.ts | 16 ++++++++-------- ember/ember.d.ts | 43 ++++++++++++++++++++++--------------------- 2 files changed, 30 insertions(+), 29 deletions(-) diff --git a/ember/ember-tests.ts b/ember/ember-tests.ts index 39e960e00..ef9b7e6d1 100644 --- a/ember/ember-tests.ts +++ b/ember/ember-tests.ts @@ -2,9 +2,9 @@ /// -var App; +var App : any; -App = Em.Application.create(); +App = Em.Application.create(); App.president = Em.Object.create({ name: 'Barack Obama' @@ -27,7 +27,7 @@ declare class MyPerson extends Em.Object { } var Person1 = Em.Object.extend({ - say: (thing) => { + say: (thing: string) => { alert(thing); } }); @@ -119,7 +119,7 @@ App.AlertView = Em.View.extend({ App.ListingView = Em.View.extend({ templateName: 'listing', - edit: (event) => { + edit: (event: any) => { event.view.set('isEditing', true); } }); @@ -133,7 +133,7 @@ App.userController = Em.Object.create({ }) }); -Handlebars.registerHelper('highlight', function(property, options) { +Handlebars.registerHelper('highlight', function(property: string, options: any) { var value = Em.Handlebars.get(this, property, options); return new Handlebars.SafeString('' + value + ''); }); @@ -195,7 +195,7 @@ people2.everyProperty('isHappy', true); people2.someProperty('isHappy', true); // Examples taken from http://emberjs.com/api/classes/Ember.RSVP.Promise.html -var promise = new Ember.RSVP.Promise(function(resolve, reject) { +var promise = new Ember.RSVP.Promise(function(resolve: Function, reject: Function) { // on success resolve('ok!'); @@ -203,8 +203,8 @@ var promise = new Ember.RSVP.Promise(function(resolve, reject) { reject('no-k!'); }); -promise.then(function(value) { +promise.then(function(value: any) { // on fulfillment -}, function(reason) { +}, function(reason: any) { // on rejection }); diff --git a/ember/ember.d.ts b/ember/ember.d.ts index 2ba1a1aab..b444cec1d 100644 --- a/ember/ember.d.ts +++ b/ember/ember.d.ts @@ -129,7 +129,7 @@ declare module EmberStates { @arg {Boolean} [ignoreFailure=false] a boolean specifying whether unhandled events throw an error @arg {String} name the name of the event to fire */ - trigger(ignoreFailure:boolean, eventName: string); + trigger(ignoreFailure:boolean, eventName: string): void; /** Fires an event on the current list of resolved/resolving handlers within this transition. Useful for firing events @@ -139,7 +139,7 @@ declare module EmberStates { @arg {String} name the name of the event to fire */ - trigger(eventName: string); + trigger(eventName: string): void; /** Transitions are aborted and their promises rejected @@ -193,7 +193,7 @@ interface String { } interface Array { - constructor(arr: any[]); + constructor(arr: any[]): void; activate(): void; addArrayObserver(target: any, opts?: EnumerableConfigurationOptions): any[]; addEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): any[]; @@ -267,7 +267,7 @@ interface Array { removeArrayObserver(target: any, opts: EnumerableConfigurationOptions): any[]; removeAt(start: number, len: number): any; removeEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): any[]; - replace(idx: number, amt: number, objects: any[]); + replace(idx: number, amt: number, objects: any[]): void; reverseObjects(): any[]; setEach(key: string, value?: any): any; setObjects(objects: any[]): any[]; @@ -334,7 +334,7 @@ interface ApplicationInitializerArguments { } interface ApplicationInitializerFunction { - (container: Ember.Container, application: Ember.Application); + (container: Ember.Container, application: Ember.Application): void; } interface CoreObjectArguments { @@ -361,11 +361,11 @@ interface ItemIndexEnumerableCallbackTarget { } interface ItemIndexEnumerableCallback { - (item: any, index: number, enumerable: Ember.Enumerable); + (item: any, index: number, enumerable: Ember.Enumerable): void; } interface ReduceCallback { - (previousValue: any, item: any, index: number, enumerable: Ember.Enumerable); + (previousValue: any, item: any, index: number, enumerable: Ember.Enumerable): void; } interface TransitionsHash { @@ -392,10 +392,10 @@ interface RenderOptions { } interface ModifyObserver { - (obj: any, path: string, target: any, method?: Function); - (obj: any, path: string, target: any, method?: string); - (obj: any, path: string, func: Function, method?: Function); - (obj: any, path: string, func: Function, method?: string); + (obj: any, path: string, target: any, method?: Function): void; + (obj: any, path: string, target: any, method?: string): void; + (obj: any, path: string, func: Function, method?: Function): void; + (obj: any, path: string, func: Function, method?: string): void; } declare module Ember { @@ -1117,8 +1117,9 @@ declare module Ember { /** A subclass of the JavaScript Error object for use in Ember. **/ + // Restore this to 'typeof Error' when https://github.com/Microsoft/TypeScript/issues/983 is resolved // ReSharper disable once DuplicatingLocalDeclaration - var Error: typeof Error; + var Error: any; // typeof Error; /** Handles delegating browser events to their corresponding Ember.Views. For example, when you click on a view, Ember.EventDispatcher ensures that that view's mouseDown method gets called. @@ -2526,9 +2527,9 @@ declare module Em { var copy: typeof Ember.copy; var create: typeof Ember.create; var debug: typeof Ember.debug; - var defineProperty: typeof defineProperty; - var deprecate: typeof deprecate; - var deprecateFunc: typeof deprecateFunc; + var defineProperty: typeof Ember.defineProperty; + var deprecate: typeof Ember.deprecate; + var deprecateFunc: typeof Ember.deprecateFunc; var destroy: typeof Ember.destroy; var empty: typeof deprecateFunc; var endPropertyChanges: typeof Ember.endPropertyChanges; @@ -2545,7 +2546,7 @@ declare module Em { var handleErrors: typeof Ember.handleErrors; var hasListeners: typeof Ember.hasListeners; var hasOwnProperty: typeof Ember.hasOwnProperty; - var immediateObserver: typeof immediateObserver; + var immediateObserver: typeof Ember.immediateObserver; var imports: typeof Ember.imports; var inspect: typeof Ember.inspect; var instrument: typeof Ember.instrument; @@ -2767,11 +2768,11 @@ declare module "Ember" { var copy: typeof Ember.copy; var create: typeof Ember.create; var debug: typeof Ember.debug; - var defineProperty: typeof defineProperty; - var deprecate: typeof deprecate; - var deprecateFunc: typeof deprecateFunc; + var defineProperty: typeof Ember.defineProperty; + var deprecate: typeof Ember.deprecate; + var deprecateFunc: typeof Ember.deprecateFunc; var destroy: typeof Ember.destroy; - var empty: typeof deprecateFunc; + var empty: typeof Ember.deprecateFunc; var endPropertyChanges: typeof Ember.endPropertyChanges; var exports: typeof Ember.exports; var finishChains: typeof Ember.finishChains; @@ -2786,7 +2787,7 @@ declare module "Ember" { var handleErrors: typeof Ember.handleErrors; var hasListeners: typeof Ember.hasListeners; var hasOwnProperty: typeof Ember.hasOwnProperty; - var immediateObserver: typeof immediateObserver; + var immediateObserver: typeof Ember.immediateObserver; var imports: typeof Ember.imports; var inspect: typeof Ember.inspect; var instrument: typeof Ember.instrument; From 19a680e67d7b5dc4c69fa690f8fe62ec1df7cc61 Mon Sep 17 00:00:00 2001 From: David Gardiner Date: Wed, 25 Feb 2015 16:02:56 +1030 Subject: [PATCH 7/7] any or {} --- ember/ember.d.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ember/ember.d.ts b/ember/ember.d.ts index b444cec1d..22cbb8ab5 100644 --- a/ember/ember.d.ts +++ b/ember/ember.d.ts @@ -14,14 +14,14 @@ declare module EmberStates { targetName: string; urlMethod: string; intent: any; - params: any; + params: {}|any; pivotHandler: any; resolveIndex: number; handlerInfos: any; - resolvedModels: any; + resolvedModels: {}|any; isActive: boolean; state: any; - queryParams: any; + queryParams: {}|any; queryParamsOnly: boolean; isTransition: boolean;