Improvements to and merge of John Vrbanac's definitions for Ember.js

Definitions/ember-1.0.d.ts

@@ -1,50 +1,291 @@
-// Type definitions for Ember.js 1.0
+// Type definitions for Ember.js 1.0.pre
 // Project: http://emberjs.com/
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
+declare module Ember {
 
-interface EmberApplication {
-    create(): EmberApplication;
-    MyView: EmberView;
+    export class CoreObject {
+        isDestroyed: bool;
+        isDestroying: bool;
+
+        destroy(): Object;
+        eachComputedProperty(callback: Function, binding: Object): void;
+        metaForProperty(key: string): any;
+    }
+
+    export class Object extends CoreObject {
+
+        static create(...arguments: any[]): Object;
+
+        addObserver(key: string, target: Object, method: any): Object;
+        apply(obj: Object): Object;
+        beginPropertyChanges(): Observable;
+        cacheFor(keyName: string): Object;
+        decrementProperty(keyName: string, increment: Object): Object;
+        detect(obj: Object): bool;
+        endPropertyChanges(): Observable;
+        get(key: string): Object;
+        getProperties(...list: string[]): any;
+        getProperties(list: string[]): any;
+        getWithDefault(keyName: string, defaultValue: Object): Object;
+        hasObserverFor(key: string): bool;
+        incrementProperty(keyName: string, increment: Object): Object;
+        notifyPropertyChange(keyName: string): Observable;
+        propertyDidChange(keyName: string): Observable;
+        propertyWillChange(key: string): Observable;
+        removeObserver(key: string, target: Object, method: string): Observable;
+        removeObserver(key: string, target: Object, method: Function): Observable;
+        reopen(...arguments: any[]);
+        set(key: string, value: Object): Observable;
+        setProperties(hash: any): Observable;
+        setUnknownProperty(key: string, value: Object): void;
+        toggleProperty(keyName: string): Object;
+        unknownProperty(key: string): Object;
+    }
+
+    export interface Mixin {
+        create(obj: Object): Object;
+        extend(first: Object, second: Object): Object;
+    }
+
+    export class View extends Object {
+        append(): View;
+        static create(...arguments: any[]): Application;
+    }
+
+    export interface Enumerable extends Mixin {
+        // Fields
+        firstObject: Object;
+        hasEnumerableObservers: bool;
+        lastObject: Object;
+        nextObject: Object;
+
+        // Methods
+        addEnumerableObserver(target, opts);
+        compact(): any[];
+        contains(obj: Object): bool;
+        enumerableContentDidChange(removing: number, adding: number): Object;
+        enumerableContentDidChange(removing: Ember.Enumerable, adding: Ember.Enumerable): Object;
+        enumerableContentDidChange(start: Number, removing: number, adding: number): Object;
+        enumerableContentDidChange(start: Number, removing: Ember.Enumerable, adding: Ember.Enumerable): Object;
+
+        enumerableContentWillChange(removing: number, adding: number): Ember.Enumerable;
+        enumerableContentWillChange(removing: Ember.Enumerable, adding: Ember.Enumerable): Ember.Enumerable;
+        enumerableContentWillChange(start: Number, removing: number, adding: number): Ember.Enumerable;
+        enumerableContentWillChange(start: Number, removing: Ember.Enumerable, adding: Ember.Enumerable): Ember.Enumerable;
+
+        every(callback: Function, target?: Object): bool;
+        everyProperty(key: string, value?: string): any[];
+        filter(callback: Function, target?: Object): any[];
+        filterProperty(key: string, value?: string): any[];
+        find(callback: Function, target?: Object): Object;
+        findProperty(key: string, value?: string): Object;
+        /*forEach
+		getEach
+		invoke
+		map
+		mapProperty
+		reduce
+		removeEnumerableObserver
+		setEach
+		some
+		someProperty
+		toArray
+		uniq
+		without*/
+    }
+
+    export interface NativeArray extends Array {
+        activate();
+    }
+
+
+
+    export class Application extends Object {
+        customEvents: Object;
+        eventDispatcher: EventDispatcher;
+        // rootElement: DOMElement;
+        ready;
+        static create(...arguments: any[]): Application;
+        initialize(router: Router);
+    }
+
+    export class Router {
+
+    }
+
+    export class EventDispatcher {
+    }
+
+    export class Binding {
+        static from();
+        static oneWay(path: string, flag?: bool);
+        static to();
+
+        connect(obj: Object): Binding;
+        copy(): Binding;
+        disconnect(obj: Object): Binding;
+        from(path: string): Binding;
+        oneWay(): Binding;
+        to(propertyPath: string): Binding;
+    }
+
+    export interface ComputedProperty {
+        cacheable(aFlag?: bool): ComputedProperty;
+        meta(hash: any): ComputedProperty;
+        property(path: string): ComputedProperty;
+        volatile(): ComputedProperty;
+    }
+
+    export interface Map {
+
+    }
+
+    export interface Observable extends Mixin {
+        addBeforeObserver(key, target, method);
+        addObject(obj: Object);
+        addObserver(key: string, target: Object, method: Function): Ember.Object;
+        addObserver(key: string, target: Object, method: string): Ember.Object;
+        beginPropertyChanges(): Ember.Observable;
+        cacheFor(keyName: string): Object;
+        contentArrayDidChange(array, idx, removedCount, addedCount);
+        contentArrayWillChange(array, idx, removedCount, addedCount);
+        contentItemSortPropertyDidChange(item);
+        decrementProperty(keyName: string, increment: Object): Object;
+        destroy();
+        endPropertyChanges(): Ember.Observable;
+        get(key: string): Object;
+        getPath(path: string): Object;
+        getProperties(...list: string[]): any;
+        getProperties(list: any[]): any;
+        getWithDefault(keyName: string, defaultValue: Object): Object;
+        hasObserverFor(key: string): bool;
+        incrementProperty(keyName: string, increment: Object): Object;
+        insertItemSorted(item);
+        notifyPropertyChange(keyName: string): Ember.Observable;
+        orderBy(item1, item2);
+        propertyDidChange(keyName: string): Ember.Observable;
+        propertyWillChange(key: string): Ember.Observable;
+        removeObject(obj: Object);
+        removeObserver(key: string, target: Object, method: string): Ember.Observable;
+        removeObserver(key: string, target: Object, method: Function): Ember.Observable;
+        set(key: string, value: Object): Ember.Observable;
+        setPath(path: string, value: Object): Ember.Observable;
+        setProperties(hash): Ember.Observable;
+        setUnknownProperty(key: string, value: Object);
+        toggleProperty(keyName: string): Object;
+        unknownProperty(key: string): Object;
+    }
 }
 
-interface EmberAlias {
-}
-
-interface EmberArrayController {
-}
-
-interface EmberBinding {
-}
-
-interface EmberDescriptor {
-}
-
-interface EmberNativeArray {
-    activate(): void;
-}
-
-interface EmberObject {
-}
-
-interface EmberView {
-}
 
 interface EmberStatic {
 
-    $; // jQuery
-    A(arr?: any[]): EmberNativeArray;
-    addListener(obj: any, eventName: string, targetOrMethod: any, method: any): void;
-    alias(methodName: EmberDescriptor): EmberAlias;
-    assert(desc: string, test: bool): void;
-    beforeObserver(func: Function, propertyNames: string): Function;
-    bind(obj: any, to: string, from: string): EmberBinding;
-    cacheFor(obj: any, key: string): void;
+    // Statics
+    CP_DEFAULT_CACHEABLE: bool;
+    ENV: Object;
+    EXTEND_PROTOTYPES: bool;
+    LOG_BINDINGS: bool;
+    LOG_STACKTRACE_ON_DEPRECATION: bool;
+    META_KEY: string;
+    SHIM_ES5: bool;
+    StringS: Object;
+    VERSION: string;
+    VIEW_PRESERVES_CONTEXT: bool;
 
-    Application: EmberApplication;
-    Object: EmberObject;
-    View: EmberView;
+    Application: Ember.Application;
+    View: Ember.View;
+
+    $; // jQuery
+
+    // API Doc Members
+    A(arr: any[]): Ember.NativeArray;
+    addBeforeObserver(obj: Object, path: string, target: Object, method: Function);
+    addListener(obj: Object, eventName: string, target: Object, method: Function);
+    addObserver(obj: Object, path: string, target: Object, method: Function);
+    alias(methodName: string);
+    assert(desc: string, test: bool);
+    beforeObserver(func: Function);
+    beginPropertyChanges();
+    bind(obj: Object, to: string, from: string): Ember.Binding;
+    cacheFor(obj: Object, key: string);
+    canInvoke(obj: Object, methodName: string);
+    changeProperties(cb: Function, binding?: Ember.Binding);
+    compare(first: Object, second: Object): number;
+    computed(func: Function): Ember.ComputedProperty;
+    copy(obj: Object, deep: bool): Object;
+    create(obj: Object, props: any);
+    deferEvent(obj: Object, eventName: string, param: any);
+    deprecate(message: string, test?: bool);
+    deprecateFunc(message: string, func: Function);
+    destroy(obj: Object): void;
+    empty(obj: Object): bool;
+    endPropertyChanges();
+    finishChains(obj: Object);
+    get(obj: Object, keyName: string): Object;
+    getMeta(obj: Object, property: any);
+    getWithDefault(root, key, defaultValue);
+    hasListeners(obj: Object, eventName: string): bool;
+    immediateObserver();
+    inspect(obj: Object): string;
+    isArray(obj?: any): bool;
+    isEqual(a: Object, b: Object): bool;
+    isGlobalPath(path: string): bool;
+    isWatching(obj: Object, key): bool;
+    keys(obj: Object): any[];
+    listenersFor(obj: Object, eventName: string): any[];
+    makeArray(obj: Object): any[];
+
+    Map();
+    MapWithDefault(options);
+    mixin(obj: Object);
+    none(obj: Object): bool;
+    observer(func: Function);
+    oneWay(obj: Object, to, from);
+    onLoad(name: string, callback: Function);
+
+    OrderedSet();
+    overrideChains(obj: Object, keyName: string, m: any);
+    propertyDidChange(obj: Object, keyName: string): void;
+    propertyWillChange(obj: Object, keyName: string, value: any): void;
+    removeBeforeObserver(obj, path, target, method);
+    removeListener(obj, eventName, target, method);
+    removeObserver(obj, path, target, method);
+
+    required();
+    runLoadHooks(name: string, object: Object);
+    sendEvent(obj: Object, eventName: string, params);
+    set(obj: Object, keyName: string, value, tolerant);
+    setMeta(obj: Object, property, value);
+    setProperties(self, hash);
+    toString(): string;
+    tryInvoke(obj: Object, methodName: string, args: any[]): bool;
+    trySet(root, path, value);
+    typeOf(item): string;
+    warn(message: string, test: bool);
+    watchedEvents(obj: Object);
+
+    // Other public members not listed in API Doc
+    meta(obj, writable);
+    metaPath(obj, path, writable);
+    normalizeTuple(target, path);
+    notifyBeforeObservers(obj: Object, keyName: string);
+    notifyObservers(obj: Object, keyName: string);
+    observersFor(obj: Object, path: string);
+    rewatch(obj: Object);
+    run(target, method);
+    defineProperty(obj: Object, keyName: string, desc, data, meta);
+    beforeObserversFor(obj: Object, path: string);
+    generateGuid(obj: Object, prefix);
+    getPath();
+    guidFor(obj: Object);
+    identifyNamespaces();
+    setPath();
+    trySetPath();
+    unwatch(obj: Object, keyName: string);
+    watch(obj: Object, keyName: string);
+    wrap(func: Function, superFunc: Function);
 }
 
-declare var Em: EmberStatic;
-declare var Ember: EmberStatic;
+declare var Em: Ember;
+//declare var Ember: EmberStatic;

Tests/ember-tests.ts

@@ -1,68 +1,185 @@
 /// <reference path="../Definitions/ember-1.0.d.ts" />
+/// <reference path="../Definitions/handlebars-1.0.d.ts" />
 
 var App;
 
 App = Em.Application.create();
 
-App.MyView = Em.View.extend({
-  mouseDown: function() {
-    window.alert("hello world!");
-});
-
-class MyView extends Em.View {
-    mouseDown() {
-        window.alert("hello world!");
-    }
-}
-
-App.Person = DS.Model.extend({
-    firstName: DS.attr('string'),
-    lastName: DS.attr('string'),
-    fullName: function() {
-        return this.get('firstName') +
-               " " + this.get('lastName');
-    }.property('firstName', 'lastName')
-});
-App.peopleController = Em.ArrayController.create({
-    content: App.Person.findAll()
-});
-
 App.president = Ember.Object.create({
     name: "Barack Obama"
 });
 App.country = Ember.Object.create({
-    presidentNameBinding: 'App.president.name'
+    presidentNameBinding: 'MyApp.president.name'
 });
 App.country.get('presidentName');
 
 App.president = Ember.Object.create({
     firstName: "Barack",
     lastName: "Obama",
-    fullName: function() {
+    fullName: () => {
         return this.get('firstName') + ' ' + this.get('lastName');
     }.property()
 });
 App.president.get('fullName');
 
-App.president = Ember.Object.create({
-    firstName: "Barack",
-    lastName: "Obama",
-    fullName: function() {
-        return this.get('firstName') + ' ' + this.get('lastName');
-    }.property('firstName', 'lastName')
+var Person = Ember.Object.extend({
+    say: (thing) => {
+        alert(thing);
+    }
+});
+var tom = Person.create({
+    name: "Tom Dale",
+    helloWorld: () => {
+        this.say("Hi my name is " + this.get('name'));
+    }
+});
+tom.helloWorld();
+
+Person.reopen({ isPerson: true });
+Person.create().get('isPerson');
+
+Person.reopenClass({
+    createMan: () => {
+        return Person.create({ isMan: true })
+    }
+});
+Person.createMan().get('isMan');
+
+var person = Person.create({
+    firstName: "Yehuda",
+    lastName: "Katz"
+});
+person.addObserver('fullName', () => { });
+person.set('firstName', "Brohuda");
+
+App.todosController = Ember.Object.create({
+    todos: [
+        Ember.Object.create({ isDone: false })
+    ],
+    remaining: () => {
+        var todos = this.get('todos');
+        return todos.filterProperty('isDone', false).get('length');
+    }.property('todos.@each.isDone')
 });
 
-App.PaintSample = Ember.Object.extend({
-    color: 'red',
-    colour: Ember.alias('color'),
-    name: function () {
-        return "Zed";
-    },
-    moniker: Ember.alias("name")
-});
-var paintSample = App.PaintSample.create();
-paintSample.get('colour');
-paintSample.moniker();
+var todos = App.todosController.get('todos');
+var todo = todos.objectAt(0);
+todo.set('isDone', true);
+App.todosController.get('remaining');
+todo = Ember.Object.create({ isDone: false });
+todos.pushObject(todo);
+App.todosController.get('remaining');
 
-Ember.assert('Must pass a valid object', obj);
-Ember.assert('This code path should never be run');
+App.wife = Ember.Object.create({
+    householdIncome: 80000
+});
+App.husband = Ember.Object.create({
+    householdIncomeBinding: 'App.wife.householdIncome'
+});
+App.husband.get('householdIncome');
+App.husband.set('householdIncome', 90000);
+App.wife.get('householdIncome');
+
+App.user = Ember.Object.create({
+    fullName: "Kara Gates"
+});
+App.userView = Ember.View.create({
+    userNameBinding: Ember.Binding.oneWay('App.user.fullName')
+});
+App.user.set('fullName', "Krang Gates");
+App.userView.set('userName', "Truckasaurus Gates");
+App.user.get('fullName');
+
+App = Ember.Application.create({
+    rootElement: '#sidebar'
+});
+
+var view = Ember.View.create({
+    templateName: 'say-hello',
+    name: "Bob"
+});
+view.appendTo('#container');
+view.append();
+view.remove();
+
+App.AlertView = Ember.View.extend({
+    priority: "p4",
+    isUrgent: true
+});
+
+App.ListingView = Ember.View.extend({
+    templateName: 'listing',
+    edit: (event) => {
+        event.view.set('isEditing', true);
+    }
+});
+
+App.userController = Ember.Object.create({
+    content: Ember.Object.create({
+        firstName: "Albert",
+        lastName: "Hofmann",
+        posts: 25,
+        hobbies: "Riding bicycles"
+    })
+});
+
+Handlebars.registerHelper('highlight', (property, options) => {
+    var value = Ember.Handlebars.getPath(this, property, options);
+    return new Handlebars.SafeString('<span class="highlight">' + value + '</span>');
+});
+
+App.MyText = Ember.TextField.extend({
+    formBlurredBinding: 'App.adminController.formBlurred',
+    change: (evt) => {
+        this.set('formBlurred', true);
+    }
+});
+
+var textArea = Ember.TextArea.create({
+    valueBinding: 'TestObject.value'
+});
+
+App.ClickableView = Ember.View.extend({
+    click: (evt) => {
+        alert("ClickableView was clicked!");
+    }
+});
+
+var container = Ember.ContainerView.create();
+container.append();
+var coolView = App.CoolView.create(),
+    childViews = container.get('childViews');
+childViews.pushObject(coolView);
+
+Person = Ember.Object.extend({
+    sayHello: () => {
+        console.log("Hello from " + this.get('name'));
+    }
+});
+var people = [
+  Person.create({ name: "Juan" }),
+  Person.create({ name: "Charles" }),
+  Person.create({ name: "Majd" })
+]
+people.invoke('sayHello');
+
+var arr = [Ember.Object.create(), Ember.Object.create()];
+arr.setEach('name', 'unknown');
+arr.getEach('name');
+
+Person = Ember.Object.extend({
+    name: null,
+    isHappy: false
+});
+var people = [
+    Person.create({ name: 'Yehuda', isHappy: true }),
+    Person.create({ name: 'Majd', isHappy: false })
+];
+people.every((person, index, self) => {
+    if (person.get('isHappy')) { return true; }
+});
+people.some((person, index, self) => {
+    if (person.get('isHappy')) { return true; }
+});
+people.everyProperty('isHappy', true);
+people.someProperty('isHappy', true);