From b63b8d9c826b3eebfb5ffc169cf0e171458fb8b1 Mon Sep 17 00:00:00 2001 From: Boris Yankov Date: Wed, 24 Oct 2012 03:05:49 +0300 Subject: [PATCH] Improvements to and merge of John Vrbanac's definitions for Ember.js --- Definitions/ember-1.0.d.ts | 317 ++++++++++++++++++++++++++++++++----- Tests/ember-tests.ts | 205 +++++++++++++++++++----- 2 files changed, 440 insertions(+), 82 deletions(-) diff --git a/Definitions/ember-1.0.d.ts b/Definitions/ember-1.0.d.ts index 1ede154b1b..254c19b8d1 100644 --- a/Definitions/ember-1.0.d.ts +++ b/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; \ No newline at end of file +declare var Em: Ember; +//declare var Ember: EmberStatic; \ No newline at end of file diff --git a/Tests/ember-tests.ts b/Tests/ember-tests.ts index 2289a1d449..8fea25eaa6 100644 --- a/Tests/ember-tests.ts +++ b/Tests/ember-tests.ts @@ -1,68 +1,185 @@ /// +/// 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('' + value + ''); +}); + +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); \ No newline at end of file