Initial commit

Author: mchapman

.gitignore

@@ -0,0 +1,4 @@
+*.js
+.idea
+node_modules
+client/bower_components

angular2/angular2.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Define public API for Angular here.
+ */
+
+export * from './change_detection';
+export * from './core';
+export * from './directives';

angular2/change_detection.d.ts

@@ -0,0 +1,20 @@
+export { AST } from './src/change_detection/parser/ast';
+export { Lexer } from './src/change_detection/parser/lexer';
+export { Parser } from './src/change_detection/parser/parser';
+export { ContextWithVariableBindings } from './src/change_detection/parser/context_with_variable_bindings';
+export { ExpressionChangedAfterItHasBeenChecked, ChangeDetectionError } from './src/change_detection/exceptions';
+export { ChangeRecord, ChangeDispatcher, ChangeDetector, CHECK_ONCE, CHECK_ALWAYS, DETACHED, CHECKED } from './src/change_detection/interfaces';
+export { ProtoChangeDetector, DynamicProtoChangeDetector, JitProtoChangeDetector } from './src/change_detection/proto_change_detector';
+export { DynamicChangeDetector } from './src/change_detection/dynamic_change_detector';
+import { ProtoChangeDetector } from './src/change_detection/proto_change_detector';
+export declare class ChangeDetection {
+    createProtoChangeDetector(name: string): ProtoChangeDetector;
+}
+export declare class DynamicChangeDetection extends ChangeDetection {
+    createProtoChangeDetector(name: string): ProtoChangeDetector;
+}
+export declare class JitChangeDetection extends ChangeDetection {
+    createProtoChangeDetector(name: string): ProtoChangeDetector;
+}
+export declare var dynamicChangeDetection: DynamicChangeDetection;
+export declare var jitChangeDetection: JitChangeDetection;

angular2/core.d.ts

@@ -0,0 +1,13 @@
+/// <reference path='globals.d.ts'/>
+
+export * from './src/core/annotations/annotations';
+export * from './src/core/annotations/visibility';
+export * from './src/core/compiler/interfaces';
+export * from './src/core/annotations/template';
+export * from './src/core/application';
+export * from './src/core/compiler/compiler';
+export * from './src/core/compiler/template_loader';
+export * from './src/core/compiler/view';
+export * from './src/core/compiler/view_container';
+export * from './src/core/compiler/binding_propagation_config';
+export * from './src/core/dom/element';

angular2/di.d.ts

@@ -0,0 +1,6 @@
+export { Inject, InjectPromise, InjectLazy, DependencyAnnotation } from './src/di/annotations';
+export { Injector } from './src/di/injector';
+export { Binding, Dependency, bind } from './src/di/binding';
+export { Key, KeyRegistry } from './src/di/key';
+export { KeyMetadataError, NoProviderError, ProviderError, AsyncBindingError, CyclicDependencyError, InstantiationError, InvalidBindingError, NoAnnotationError } from './src/di/exceptions';
+export { OpaqueToken } from './src/di/opaque_token';

angular2/directives.d.ts

@@ -0,0 +1,4 @@
+export * from './src/directives/foreach';
+export * from './src/directives/if';
+export * from './src/directives/non_bindable';
+export * from './src/directives/switch';

angular2/e2e_test/perf_util.d.ts

@@ -0,0 +1,6 @@
+declare var testUtil: any;
+declare var benchpress: any;
+declare function runClickBenchmark(config: any): any;
+declare function runBenchmark(config: any): any;
+declare function getScaleFactor(possibleScalings: any): any;
+declare function applyScaleFactor(value: any, scaleFactor: any, method: any): any;

angular2/e2e_test/test_util.d.ts

@@ -0,0 +1,4 @@
+/// <reference path="../../../../../forks/angular2/typings/selenium-webdriver/selenium-webdriver.d.ts" />
+declare var webdriver: any;
+declare function clickAll(buttonSelectors: any): void;
+declare function verifyNoBrowserErrors(): void;

angular2/forms.d.ts

@@ -0,0 +1,2 @@
+export * from './src/forms/model';
+export * from './src/forms/directives';

angular2/globals.d.ts

@@ -0,0 +1,172 @@
+/// <reference path="../jasmine/jasmine.d.ts" />
+/// <reference path="../zone/zone.d.ts" />
+/// <reference path="../hammerjs/hammerjs.d.ts" />
+declare var assert: any;
+declare var module: any;
+declare var $traceurRuntime: any;
+declare var global: Window;
+declare var $: any;
+declare var angular: any;
+declare var _resolve: any;
+declare var require: any;
+declare var browser: any;
+declare var benchpressRunner: any;
+declare type int = number;
+declare type Type = {
+    new (...args: any[]): any;
+};
+interface List<T> extends Array<T> {
+}
+declare type TemplateElement = HTMLTemplateElement;
+declare type StyleElement = HTMLStyleElement;
+declare type SetterFn = Function;
+declare type GetterFn = Function;
+declare type MethodFn = Function;
+declare type _globalRegExp = RegExp;
+interface HTMLElement {
+    createShadowRoot(): HTMLElement;
+}
+interface HTMLTemplateElement extends HTMLElement {
+    content: DocumentFragment;
+}
+interface Window {
+    Array: typeof Array;
+    List: typeof Array;
+    Map: typeof Map;
+    Set: typeof Set;
+    RegExp: typeof RegExp;
+    JSON: typeof JSON;
+    Math: typeof Math;
+    assert: typeof assert;
+    NaN: typeof NaN;
+    setTimeout: typeof setTimeout;
+    Promise: typeof Promise;
+    zone: Zone;
+    Hammer: HammerStatic;
+    DocumentFragment: DocumentFragment;
+    Node: Node;
+    NodeList: NodeList;
+    Text: Text;
+    HTMLElement: HTMLElement;
+    HTMLTemplateElement: TemplateElement;
+    HTMLStyleElement: StyleElement;
+    gc(): void;
+}
+interface Window extends jasmine.GlobalPolluter {
+    print(msg: string): void;
+    dump(msg: string): void;
+    describe(description: string, specDefinitions: () => void): jasmine.Suite;
+    ddescribe(description: string, specDefinitions: () => void): jasmine.Suite;
+    beforeEach(beforeEachFunction: () => void): void;
+    beforeAll(beforeAllFunction: () => void): void;
+    afterEach(afterEachFunction: () => void): void;
+    afterAll(afterAllFunction: () => void): void;
+    xdescribe(desc: string, specDefinitions: () => void): jasmine.XSuite;
+    it(description: string, func: (done?: () => void) => void): jasmine.Spec;
+    iit(description: string, func: () => void): jasmine.Spec;
+    xit(desc: string, func: () => void): jasmine.XSpec;
+}
+declare module jasmine {
+    interface Matchers {
+        toHaveText(text: string): void;
+        toBeAnInstanceOf(obj: any): void;
+        toBePromise(): void;
+        toBe(value: any): void;
+    }
+}
+interface Map<K, V> {
+    jasmineToString?(): void;
+}
+interface Console {
+    profileEnd(str: string): any;
+}
+
+/**
+ * Represents the completion of an asynchronous operation
+ */
+interface Promise<T> {
+    /**
+    * Attaches callbacks for the resolution and/or rejection of the Promise.
+    * @param onfulfilled The callback to execute when the Promise is resolved.
+    * @param onrejected The callback to execute when the Promise is rejected.
+    * @returns A Promise for the completion of which ever callback is executed.
+    */
+    then<TResult>(onfulfilled?: (value: T) => TResult | Promise<TResult>, onrejected?: (reason: any) => TResult | Promise<TResult>): Promise<TResult>;
+
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch(onrejected?: (reason: any) => T | Promise<T>): Promise<T>;
+}
+
+interface PromiseConstructor {
+    /** 
+      * A reference to the prototype. 
+      */
+    prototype: Promise<any>;
+
+    /**
+     * Creates a new Promise.
+     * @param init A callback used to initialize the promise. This callback is passed two arguments: 
+     * a resolve callback used resolve the promise with a value or the result of another promise, 
+     * and a reject callback used to reject the promise with a provided reason or error.
+     */
+    new <T>(init: (resolve: (value?: T | Promise<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
+
+    <T>(init: (resolve: (value?: T | Promise<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
+
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises 
+     * resolve, or rejected when any Promise is rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    all<T>(values: (T | Promise<T>)[]): Promise<T[]>;
+
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     * @param values An array of values.
+     * @returns A new Promise.
+     */
+    all(values: Promise<void>[]): Promise<void>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved 
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T>(values: (T | Promise<T>)[]): Promise<T>;
+
+    /**
+     * Creates a new rejected promise for the provided reason.
+     * @param reason The reason the promise was rejected.
+     * @returns A new rejected Promise.
+     */
+    reject(reason: any): Promise<void>;
+
+    /**
+     * Creates a new rejected promise for the provided reason.
+     * @param reason The reason the promise was rejected.
+     * @returns A new rejected Promise.
+     */
+    reject<T>(reason: any): Promise<T>;
+
+    /**
+      * Creates a new resolved promise for the provided value.
+      * @param value A promise.
+      * @returns A promise whose internal state matches the provided promise.
+      */
+    resolve<T>(value: T | Promise<T>): Promise<T>;
+
+    /**
+     * Creates a new resolved promise .
+     * @returns A resolved promise.
+     */
+    resolve(): Promise<void>;
+}
+
+declare var Promise: PromiseConstructor;

angular2/src/change_detection/abstract_change_detector.d.ts

@@ -0,0 +1,16 @@
+import { ChangeDetector } from './interfaces';
+export declare class AbstractChangeDetector extends ChangeDetector {
+    children: List<any>;
+    parent: ChangeDetector;
+    mode: string;
+    constructor();
+    addChild(cd: ChangeDetector): void;
+    removeChild(cd: ChangeDetector): void;
+    remove(): void;
+    detectChanges(): void;
+    checkNoChanges(): void;
+    _detectChanges(throwOnChange: boolean): void;
+    detectChangesInRecords(throwOnChange: boolean): void;
+    _detectChangesInChildren(throwOnChange: boolean): void;
+    markPathToRootAsCheckOnce(): void;
+}

angular2/src/change_detection/array_changes.d.ts

@@ -0,0 +1,122 @@
+export declare class ArrayChanges {
+    _collection: any;
+    _length: int;
+    _linkedRecords: _DuplicateMap;
+    _unlinkedRecords: _DuplicateMap;
+    _previousItHead: CollectionChangeRecord;
+    _itHead: CollectionChangeRecord;
+    _itTail: CollectionChangeRecord;
+    _additionsHead: CollectionChangeRecord;
+    _additionsTail: CollectionChangeRecord;
+    _movesHead: CollectionChangeRecord;
+    _movesTail: CollectionChangeRecord;
+    _removalsHead: CollectionChangeRecord;
+    _removalsTail: CollectionChangeRecord;
+    constructor();
+    static supports(obj: any): boolean;
+    supportsObj(obj: any): boolean;
+    collection: any;
+    length: int;
+    forEachItem(fn: Function): void;
+    forEachPreviousItem(fn: Function): void;
+    forEachAddedItem(fn: Function): void;
+    forEachMovedItem(fn: Function): void;
+    forEachRemovedItem(fn: Function): void;
+    check(collection: any): boolean;
+    isDirty: boolean;
+    /**
+     * Reset the state of the change objects to show no changes. This means set previousKey to
+     * currentKey, and clear all of the queues (additions, moves, removals).
+     * Set the previousIndexes of moved and added items to their currentIndexes
+     * Reset the list of additions, moves and removals
+     */
+    _reset(): void;
+    /**
+     * This is the core function which handles differences between collections.
+     *
+     * - [record] is the record which we saw at this position last time. If null then it is a new
+     *   item.
+     * - [item] is the current item in the collection
+     * - [index] is the position of the item in the collection
+     */
+    _mismatch(record: CollectionChangeRecord, item: any, index: int): CollectionChangeRecord;
+    /**
+     * This check is only needed if an array contains duplicates. (Short circuit of nothing dirty)
+     *
+     * Use case: `[a, a]` => `[b, a, a]`
+     *
+     * If we did not have this check then the insertion of `b` would:
+     *   1) evict first `a`
+     *   2) insert `b` at `0` index.
+     *   3) leave `a` at index `1` as is. <-- this is wrong!
+     *   3) reinsert `a` at index 2. <-- this is wrong!
+     *
+     * The correct behavior is:
+     *   1) evict first `a`
+     *   2) insert `b` at `0` index.
+     *   3) reinsert `a` at index 1.
+     *   3) move `a` at from `1` to `2`.
+     *
+     *
+     * Double check that we have not evicted a duplicate item. We need to check if the item type may
+     * have already been removed:
+     * The insertion of b will evict the first 'a'. If we don't reinsert it now it will be reinserted
+     * at the end. Which will show up as the two 'a's switching position. This is incorrect, since a
+     * better way to think of it is as insert of 'b' rather then switch 'a' with 'b' and then add 'a'
+     * at the end.
+     */
+    _verifyReinsertion(record: CollectionChangeRecord, item: any, index: int): CollectionChangeRecord;
+    /**
+     * Get rid of any excess [CollectionChangeRecord]s from the previous collection
+     *
+     * - [record] The first excess [CollectionChangeRecord].
+     */
+    _truncate(record: CollectionChangeRecord): void;
+    _reinsertAfter(record: CollectionChangeRecord, prevRecord: CollectionChangeRecord, index: int): CollectionChangeRecord;
+    _moveAfter(record: CollectionChangeRecord, prevRecord: CollectionChangeRecord, index: int): CollectionChangeRecord;
+    _addAfter(record: CollectionChangeRecord, prevRecord: CollectionChangeRecord, index: int): CollectionChangeRecord;
+    _insertAfter(record: CollectionChangeRecord, prevRecord: CollectionChangeRecord, index: int): CollectionChangeRecord;
+    _remove(record: CollectionChangeRecord): CollectionChangeRecord;
+    _unlink(record: CollectionChangeRecord): CollectionChangeRecord;
+    _addToMoves(record: CollectionChangeRecord, toIndex: int): CollectionChangeRecord;
+    _addToRemovals(record: CollectionChangeRecord): CollectionChangeRecord;
+    toString(): string;
+}
+export declare class CollectionChangeRecord {
+    currentIndex: int;
+    previousIndex: int;
+    item: any;
+    _nextPrevious: CollectionChangeRecord;
+    _prev: CollectionChangeRecord;
+    _next: CollectionChangeRecord;
+    _prevDup: CollectionChangeRecord;
+    _nextDup: CollectionChangeRecord;
+    _prevRemoved: CollectionChangeRecord;
+    _nextRemoved: CollectionChangeRecord;
+    _nextAdded: CollectionChangeRecord;
+    _nextMoved: CollectionChangeRecord;
+    constructor(item: any);
+    toString(): string;
+}
+export declare class _DuplicateMap {
+    map: Map<any, any>;
+    constructor();
+    put(record: CollectionChangeRecord): void;
+    /**
+     * Retrieve the `value` using key. Because the CollectionChangeRecord value maybe one which we
+     * have already iterated over, we use the afterIndex to pretend it is not there.
+     *
+     * Use case: `[a, b, c, a, a]` if we are at index `3` which is the second `a` then asking if we
+     * have any more `a`s needs to return the last `a` not the first or second.
+     */
+    get(value: any, afterIndex?: any): CollectionChangeRecord;
+    /**
+     * Removes an [CollectionChangeRecord] from the list of duplicates.
+     *
+     * The list of duplicates also is removed from the map if it gets empty.
+     */
+    remove(record: CollectionChangeRecord): CollectionChangeRecord;
+    isEmpty: boolean;
+    clear(): void;
+    toString(): string;
+}