[API] Ascending/descending order

...to come after telemetry usage example

API.md

@@ -0,0 +1,285 @@
+# Open MCT API
+
+The Open MCT framework public api can be utilized by building the application
+(`gulp install`) and then copying the file from `dist/main.js` to your
+directory of choice.
+
+Open MCT supports AMD, CommonJS, and loading via a script tag; it's easy to use
+in your project. The [`openmct`]{@link module:openmct} module is exported
+via AMD and CommonJS, and is also exposed as `openmct` in the global scope
+if loaded via a script tag.
+
+## Overview
+
+Open MCT's goal is to allow you to browse, create, edit, and visualize all of
+the domain knowledge you need on a daily basis.
+
+To do this, the main building block provided by Open MCT is the _domain object_.
+The temperature sensor on the starboard solar panel,
+an overlay plot comparing the results of all temperature sensor,
+the command dictionary for a spacecraft,
+the individual commands in that dictionary, your "my documents" folder:
+All of these things are domain objects.
+
+Domain objects have Types, so a specific instrument temperature sensor is a
+"Telemetry Point," and turning on a drill for a certain duration of time is
+an "Activity".  Types allow you to form an ontology of knowledge and provide
+an abstraction for grouping, visualizing, and interpreting data.
+
+And then we have Views. Views allow you to visualize domain objects. Views can
+apply to specific domain objects; they may also apply to certain types of
+domain objects, or they may apply to everything.  Views are simply a method
+of visualizing domain objects.
+
+Regions allow you to specify what views are displayed for specific types of
+domain objects in response to different user actions. For instance, you may
+want to display a different view while editing, or you may want to update the
+toolbar display when objects are selected.  Regions allow you to map views to
+specific user actions.
+
+Domain objects can be mutated and persisted, developers can create custom
+actions and apply them to domain objects, and many more things can be done.
+For more information, read on!
+
+## Running Open MCT
+
+Once the [`openmct`](@link module:openmct) module has been loaded, you can
+simply invoke [`start`]{@link module:openmct.MCT#start} to run Open MCT:
+
+
+```
+openmct.start();
+```
+
+Generally, however, you will want to configure Open MCT by adding plugins
+before starting it. It is important to install plugins and configure Open MCT
+_before_ calling [`start`]{@link module:openmct.MCT#start}; Open MCT is not
+designed to be reconfigured once started.
+
+## Configuring Open MCT
+
+The [`openmct`]{@link module:openmct} module (more specifically, the
+[`MCT`]{@link module:openmct.MCT} class, of which `openmct` is an instance)
+exposes a variety of methods to allow the application to be configured,
+extended, and customized before running.
+
+Short examples follow; see the linked documentation for further details.
+
+### Adding Domain Object Types
+
+Custom types may be registered via
+[`openmct.types`]{@link module:openmct.MCT#types}:
+
+```
+openmct.types.addType('my-type', new openmct.Type({
+    label: "My Type",
+    description: "This is a type that I added!"
+});
+```
+
+### Adding Views
+
+Custom views may be registered based on the region in the application
+where they should appear:
+
+* [`openmct.mainViews`]{@link module:openmct.MCT#mainViews} is a registry
+  of views of domain objects which should appear in the main viewing area.
+* [`openmct.inspectors`]{@link module:openmct.MCT#inspectors} is a registry
+  of views of domain objects and/or active selections, which should appear in
+  the Inspector.
+* [`openmct.toolbars`]{@link module:openmct.MCT#toolbars} is a registry
+  of views of domain objects and/or active selections, which should appear in
+  the toolbar area while editing.
+* [`openmct.indicators`]{@link module:openmct.MCT#inspectors} is a registry
+  of views which should appear in the status area of the application.
+
+Example:
+
+```
+openmct.mainViews.addProvider({
+    canView: function (domainObject) {
+        return domainObject.type === 'my-type';
+    },
+    view: function (domainObject) {
+        return new MyView(domainObject);
+    }
+});
+```
+
+### Adding a Root-level Object
+
+In many cases, you'd like a certain object (or a certain hierarchy of
+objects) to be accessible from the top level of the application (the
+tree on the left-hand side of Open MCT.) It is typical to expose a telemetry
+dictionary as a hierarchy of telemetry-providing domain objects in this
+fashion.
+
+To do so, use the [`addRoot`]{@link module:openmct.ObjectAPI#addRoot} method
+of the [object API]{@link module:openmct.ObjectAPI}:
+
+```
+openmct.objects.addRoot({
+    identifier: { key: "my-key", namespace: "my-namespace" }
+    name: "My Root-level Object",
+    type: "my-type"
+});
+```
+
+You can also remove this root-level object via its identifier:
+
+```
+openmct.objects.removeRoot({ key: "my-key", namespace: "my-namespace" });
+```
+
+### Adding Composition Providers
+
+The "composition" of a domain object is the list of objects it contains,
+as shown (for example) in the tree for browsing. Open MCT provides a
+default solution for composition, but there may be cases where you want
+to provide the composition of a certain object (or type of object) dynamically.
+For instance, you may want to populate a hierarchy under a custom root-level
+object based on the contents of a telemetry dictionary.
+To do this, you can add a new CompositionProvider:
+
+```
+openmct.composition.addProvider({
+    appliesTo: function (domainObject) {
+        return domainObject.type === 'my-type';
+    },
+    load: function (domainObject) {
+        return Promise.resolve(myDomainObjects);
+    }
+});
+```
+
+### Adding Telemetry Providers
+
+When connecting to a new telemetry source, you will want to register a new
+[telemetry provider]{@link module:openmct.TelemetryAPI~TelemetryProvider}
+with the [telemetry API]{@link module:openmct.TelemetryAPI#addProvider}:
+
+```
+openmct.telemetry.addProvider({
+    canProvideTelemetry: function (domainObject) {
+        return domainObject.type === 'my-type';
+    },
+    properties: function (domainObject) {
+        return [
+            { key: 'value', name: "Temperature", units: "degC" },
+            { key: 'time', name: "UTC" }
+        ];
+    },
+    request: function (domainObject, options) {
+        var telemetryId = domainObject.myTelemetryId;
+        return myAdapter.request(telemetryId, options.start, options.end);
+    },
+    subscribe: function (domainObject, callback) {
+        var telemetryId = domainObject.myTelemetryId;
+        myAdapter.subscribe(telemetryId, callback);
+        return myAdapter.unsubscribe.bind(myAdapter, telemetryId, callback);
+    }
+});
+```
+
+The implementations for `request` and `subscribe` can vary depending on the
+nature of the endpoint which will provide telemetry. In the example above,
+it is assumed that `myAdapter` contains the specific implementations
+(HTTP requests, WebSocket connections, etc.) associated with some telemetry
+source.
+
+## Using Open MCT
+
+When implementing new features, it is useful and sometimes necessary to
+utilize functionality exposed by Open MCT.
+
+### Retrieving Composition
+
+To limit which objects are loaded at any given time, the composition of
+a domain object must be requested asynchronously:
+
+```
+openmct.composition(myObject).load().then(function (childObjects) {
+    childObjects.forEach(doSomething);
+});
+```
+
+### Support Common Gestures
+
+Custom views may also want to support common gestures using the
+[gesture API]{@link module:openmct.GestureAPI}. For instance, to make
+a view (or part of a view) selectable:
+
+```
+openmct.gestures.selectable(myHtmlElement, myDomainObject);
+```
+
+### Working with Domain Objects
+
+The [object API]{@link module:openmct.ObjectAPI} provides useful methods
+for working with domain objects.
+
+To make changes to a domain object, use the
+[`mutate`]{@link module:openmct.ObjectAPI#mutate} method:
+
+```
+openmct.objects.mutate(myDomainObject, "name", "New name!");
+```
+
+Making modifications in this fashion allows other usages of the domain
+object to remain up to date using the
+[`observe`]{@link module:openmct.ObjectAPI#observe} method:
+
+```
+openmct.objects.observe(myDomainObject, "name", function (newName) {
+    myLabel.textContent = newName;
+});
+```
+
+### Using Telemetry
+
+Very often in Open MCT, you wish to work with telemetry data (for instance,
+to display it in a custom visualization.)
+
+
+### Synchronizing with the Time Conductor
+
+Views which wish to remain synchronized with the state of Open MCT's
+time conductor should utilize
+[`openmct.conductor`]{@link module:openmct.TimeConductor}:
+
+```
+openmct.conductor.on('bounds', function (newBounds) {
+    requestTelemetry(newBounds.start, newBounds.end).then(displayTelemetry);
+});
+```
+
+## Plugins
+
+While you can register new features with Open MCT directly, it is generally
+more useful to package these as a plugin. A plugin is a function that takes
+[`openmct`]{@link module:openmct} as an argument, and performs configuration
+upon `openmct` when invoked.
+
+### Installing Plugins
+
+To install plugins, use the [`install`]{@link module:openmct.MCT#install}
+method:
+
+```
+openmct.install(myPlugin);
+```
+
+The plugin will be invoked to configure Open MCT before it is started.
+
+### Writing Plugins
+
+Plugins configure Open MCT, and should utilize the
+[`openmct`]{@link module:openmct} module to do so, as summarized above in
+"Configuring Open MCT" and "Using Open MCT" above.
+
+### Distributing Plugins
+
+Hosting or downloading plugins is outside of the scope of this documentation.
+We recommend distributing plugins as UMD modules which export a single
+function.
+

bower.json

@@ -18,6 +18,9 @@
     "node-uuid": "^1.4.7",
     "comma-separated-values": "^3.6.4",
     "FileSaver.js": "^0.0.2",
-    "zepto": "^1.1.6"
+    "zepto": "^1.1.6",
+    "eventemitter3": "^1.2.0",
+    "lodash": "3.10.1",
+    "almond": "~0.3.2"
   }
 }

build/jsdoc/plugins/mct-only.js

@@ -0,0 +1,13 @@
+module.exports = {
+    handlers: {
+        processingComplete: function (e) {
+            e.doclets.forEach(function (doclet) {
+                var memberof = doclet.memberof || "";
+                var longname = doclet.longname || "";
+
+                doclet.ignore = longname !== 'module:openmct' &&
+                    memberof.indexOf('module:openmct') !== 0;
+            });
+        }
+    }
+};

composition-test.html

@@ -0,0 +1,65 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>Implementing a composition provider</title>
+  <script src="dist/main.js"></script>
+</head>
+<body>
+<script>
+
+    var widgetParts = ['foo', 'bar', 'baz', 'bing', 'frobnak']
+
+    function fabricateName() {
+        return [
+            widgetParts[Math.floor(Math.random() * widgetParts.length)],
+            widgetParts[Math.floor(Math.random() * widgetParts.length)],
+            Math.floor(Math.random() * 1000)
+        ].join('_');
+    }
+
+    MCT.type('example.widget-factory', new MCT.Type({
+        metadata: {
+            label: "Widget Factory",
+            glyph: "s",
+            description: "A factory for making widgets"
+        },
+        initialize: function (object) {
+            object.widgetCount = 5;
+            object.composition = [];
+        },
+        creatable: true,
+        form: [
+            {
+                name: "Widget Count",
+                control: "textfield",
+                key: "widgetCount",
+                property: "widgetCount",
+                required: true
+            }
+        ]
+    }));
+
+    MCT.Composition.addProvider({
+        appliesTo: function (domainObject) {
+            return domainObject.type === 'example.widget-factory';
+        },
+        load: function (domainObject) {
+            var widgets = [];
+            while (widgets.length < domainObject.widgetCount) {
+                widgets.push({
+                    name: fabricateName(),
+                    key: {
+                        namespace: 'widget-factory',
+                        identifier: '' + widgets.length
+                    }
+                });
+            }
+            return Promise.resolve(widgets);
+        }
+    });
+
+    MCT.run();
+</script>
+</body>
+</html>

custom-view-react.html

@@ -0,0 +1,144 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>Implementing a Custom Type and View </title>
+  <script src="dist/main.js"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.2.1/react.js"></script>
+      <script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.2.1/react-dom.js"></script>
+      <script src="https://cdnjs.cloudflare.com/ajax/libs/babel-core/5.8.34/browser.min.js"></script>
+</head>
+<body>
+<script type="text/babel">
+
+    // First, we're going to create the Todo List type, so that users can create
+    // todo lists.
+
+    MCT.type('example.todo', new MCT.Type({
+        metadata: {
+            label: "To-Do List",
+            glyph: "2",
+            description: "A list of things that need to be done."
+        },
+        initialize: function (object) {
+            object.tasks = [
+                { description: "This is a task." }
+            ];
+        },
+        creatable: true
+    }));
+
+    /*
+    Refresh the page, and you should be able to create new Todo Lists.
+    unfortunately, when you navigate to a Todo list, you see a blank page. let's
+    fix that by adding a main view for that todo list.
+
+    If you're wondering why this is commented out, well, it's because we'll
+    write a new version later.
+    */
+
+    var Task = React.createClass({
+      render: function() {
+        return (
+            <li>
+                <input type="checkbox"
+                       checked={this.props.checked}/>
+                <span>{this.props.description}</span>
+            </li>
+        );
+      }
+    });
+
+    var TaskList = React.createClass({
+        render: function () {
+            var taskNodes = this.props.tasks.map(function(task) {
+                return (
+                    <Task checked={task.checked}
+                          description={task.description}/>
+                );
+            });
+            return (
+              <ul>
+                {taskNodes}
+              </ul>
+            );
+        }
+    });
+
+    MCT.view(MCT.regions.main, {
+        canView: function (domainObject) {
+            return domainObject.type === 'example.todo';
+        },
+        view: function (domainObject) {
+            var mutableObject = MCT.Objects.getMutable(domainObject);
+
+            return {
+                show: function (container) {
+                    ReactDOM.render(
+                        <TaskList tasks={domainObject.tasks}/>,
+                        container
+                    );
+                    mutableObject.on('tasks', function (tasks) {
+                        ReactDOM.render(
+                            <TaskList tasks={tasks}/>,
+                            container
+                        );
+                    });
+                }
+            };
+        }
+    });
+
+    /*
+     Refresh the page and you should see a todo list with checkboxes!  Now let's
+     Allow you to add tasks by mutating the object.  We'll add a toolbar view to
+     do this.
+    */
+
+    var TaskToolbar = React.createClass({
+        render: function () {
+            return (
+                <button onClick={this.props.addTask}>Add Task</button>
+            );
+        }
+    });
+
+    MCT.view(MCT.regions.toolbar, {
+        canView: function (domainObject) {
+            return domainObject.type === 'example.todo';
+        },
+        view: function (domainObject) {
+            var mutableObject = MCT.Objects.getMutable(domainObject);
+
+            function addTask(event) {
+                var description = prompt('Task description');
+                var tasks = mutableObject.get('tasks');
+                tasks.push({
+                    description: description,
+                    complete: false
+                });
+                mutableObject.set('tasks', tasks);
+            }
+
+            return {
+                show: function (container) {
+                    ReactDOM.render(
+                        <TaskToolbar addTask={addTask}/>,
+                        container
+                    );
+                },
+            }
+        }
+    });
+
+    /*
+     Refresh the page, edit the todo list, and you'll have a button that allows
+     you to add tasks!  Unfortunately, new tasks don't show in the list.  Why?
+     Well, if your view should update on mutation, you need to set up the correct
+     listeners.  Let's update the TodoView we made earlier:
+    */
+
+    MCT.run();
+</script>
+</body>
+</html>

custom-view.html

@@ -0,0 +1,160 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>Implementing a Custom Type and View </title>
+  <script src="dist/main.js"></script>
+</head>
+<body>
+<script>
+
+    // First, we're going to create the Todo List type, so that users can create
+    // todo lists.
+
+    MCT.type('example.todo', new MCT.Type({
+        metadata: {
+            label: "To-Do List",
+            glyph: "2",
+            description: "A list of things that need to be done."
+        },
+        initialize: function (object) {
+            object.tasks = [
+                { description: "This is a task." }
+            ];
+        },
+        creatable: true
+    }));
+
+    /*
+    Refresh the page, and you should be able to create new Todo Lists.
+    unfortunately, when you navigate to a Todo list, you see a blank page. let's
+    fix that by adding a main view for that todo list.
+
+    If you're wondering why this is commented out, well, it's because we'll
+    write a new version later.
+    */
+
+    // MCT.view(MCT.regions.main, {
+    //     canView: function (domainObject) {
+    //         return domainObject.type === 'example.todo';
+    //     },
+    //     view: function (domainObject) {
+    //         function renderTask(task) {
+    //             return [
+    //                 '<li>',
+    //                 '<input type="checkbox"' + (task.complete ? ' checked="true"' : '') + '>',
+    //                 '<span>' + task.description + '</span>',
+    //                 '</li>'
+    //             ].join('');
+    //         };
+    //
+    //         function renderTaskList() {
+    //             return [
+    //                 '<ul>',
+    //                 domainObject.tasks.map(renderTask).join(''),
+    //                 '</ul>'
+    //             ].join('');
+    //         };
+    //
+    //         return {
+    //             show: function (container) {
+    //                 container.innerHTML = renderTaskList();
+    //             }
+    //         };
+    //     }
+    // });
+
+    /*
+     Refresh the page and you should see a todo list with checkboxes!  Now let's
+     Allow you to add tasks by mutating the object.  We'll add a toolbar view to
+     do this.
+    */
+
+    MCT.view(MCT.regions.toolbar, {
+        canView: function (domainObject) {
+            return domainObject.type === 'example.todo';
+        },
+        view: function (domainObject) {
+            var mutableObject = MCT.Objects.getMutable(domainObject);
+
+            function addTask(event) {
+                var description = prompt('Task description');
+                var tasks = mutableObject.get('tasks');
+                tasks.push({
+                    description: description,
+                    complete: false
+                });
+                mutableObject.set('tasks', tasks);
+            }
+
+            return {
+                show: function (container) {
+                    container.addEventListener('click', addTask);
+                    container.innerHTML = '<button>Add Task</button>';
+                },
+                destroy: function (container) {
+                    container.removeEventListener('click', addTask);
+                }
+            }
+        }
+    });
+
+    /*
+     Refresh the page, edit the todo list, and you'll have a button that allows
+     you to add tasks!  Unfortunately, new tasks don't show in the list.  Why?
+     Well, if your view should update on mutation, you need to set up the correct
+     listeners.  Let's update the TodoView we made earlier:
+    */
+
+    MCT.view(MCT.regions.main, {
+        canView: function(domainObject) {
+            return domainObject.type === 'example.todo'
+        },
+        view: function (domainObject) {
+
+            var mutableObject = MCT.Objects.getMutable(domainObject);
+
+            function renderTask(task) {
+                return [
+                    '<li>',
+                    '<input type="checkbox"' + (task.complete ? ' checked="true"' : '') + '>',
+                    '<span>' + task.description + '</span>',
+                    '</li>'
+                ].join('');
+            }
+
+            function renderTaskList(tasks) {
+                return [
+                    '<ul>',
+                    tasks.map(renderTask).join(''),
+                    '</ul>'
+                ].join('');
+            }
+
+            function onCheckboxChange(event) {
+                var checkbox = event.target;
+                var taskEl = checkbox.parentNode;
+                var taskList = taskEl.parentNode;
+                var taskIndex = [].slice.apply(taskList.children).indexOf(taskEl);
+                mutableObject.set('tasks[' + taskIndex + '].complete', checkbox.checked);
+            }
+
+            return {
+                show: function (container) {
+                    container.innerHTML = renderTaskList(domainObject.tasks);
+                    mutableObject.on('tasks', function (tasks) {
+                        container.innerHTML = renderTaskList(tasks);
+                    });
+                    container.addEventListener('change', onCheckboxChange);
+                },
+                destroy: function () {
+                    mutableObject.stopListening();
+                }
+            };
+        }
+    });
+
+    MCT.run();
+</script>
+</body>
+</html>

example/msl/bundle.js

@@ -36,7 +36,7 @@ define([
     legacyRegistry
 ) {
     "use strict";
-    legacyRegistry.register("example/notifications", {
+    legacyRegistry.register("example/msl-adapter", {
         "name" : "Mars Science Laboratory Data Adapter",
         "extensions" : {
         "types": [

gulpfile.js

@@ -21,40 +21,33 @@
  *****************************************************************************/
 
 /*global require,__dirname*/
+
 var gulp = require('gulp'),
-    requirejsOptimize = require('gulp-requirejs-optimize'),
     sourcemaps = require('gulp-sourcemaps'),
-    rename = require('gulp-rename'),
-    sass = require('gulp-sass'),
-    bourbon = require('node-bourbon'),
-    jshint = require('gulp-jshint'),
-    jscs = require('gulp-jscs'),
-    replace = require('gulp-replace-task'),
-    karma = require('karma'),
     path = require('path'),
     fs = require('fs'),
     git = require('git-rev-sync'),
     moment = require('moment'),
-    merge = require('merge-stream'),
     project = require('./package.json'),
     _ = require('lodash'),
     paths = {
         main: 'main.js',
         dist: 'dist',
-        assets: 'dist/assets',
         scss: ['./platform/**/*.scss', './example/**/*.scss'],
+        assets: [
+            './{example,platform}/**/*.{css,css.map,png,svg,ico,woff,eot,ttf}'
+        ],
         scripts: [ 'main.js', 'platform/**/*.js', 'src/**/*.js' ],
         specs: [ 'platform/**/*Spec.js', 'src/**/*Spec.js' ],
-        static: [
-            'index.html',
-            'platform/**/*',
-            'example/**/*',
-            'bower_components/**/*'
-        ]
     },
     options = {
         requirejsOptimize: {
-            name: paths.main.replace(/\.js$/, ''),
+            name: 'bower_components/almond/almond.js',
+            include: paths.main.replace('.js', ''),
+            wrap: {
+                startFile: "src/start.frag",
+                endFile: "src/end.frag"
+            },
             mainConfigFile: paths.main,
             wrapShim: true
         },
@@ -63,7 +56,6 @@ var gulp = require('gulp'),
             singleRun: true
         },
         sass: {
-            includePaths: bourbon.includePaths,
             sourceComments: true
         },
         replace: {
@@ -77,6 +69,8 @@ var gulp = require('gulp'),
     };
 
 gulp.task('scripts', function () {
+    var requirejsOptimize = require('gulp-requirejs-optimize');
+    var replace = require('gulp-replace-task');
     return gulp.src(paths.main)
         .pipe(sourcemaps.init())
         .pipe(requirejsOptimize(options.requirejsOptimize))
@@ -86,10 +80,16 @@ gulp.task('scripts', function () {
 });
 
 gulp.task('test', function (done) {
+    var karma = require('karma');
     new karma.Server(options.karma, done).start();
 });
 
 gulp.task('stylesheets', function () {
+    var sass = require('gulp-sass');
+    var rename = require('gulp-rename');
+    var bourbon = require('node-bourbon');
+    options.sass.includePaths = bourbon.includePaths;
+
     return gulp.src(paths.scss, {base: '.'})
         .pipe(sourcemaps.init())
         .pipe(sass(options.sass).on('error', sass.logError))
@@ -103,6 +103,9 @@ gulp.task('stylesheets', function () {
 });
 
 gulp.task('lint', function () {
+    var jshint = require('gulp-jshint');
+    var merge = require('merge-stream');
+
     var nonspecs = paths.specs.map(function (glob) {
             return "!" + glob;
         }),
@@ -117,6 +120,8 @@ gulp.task('lint', function () {
 });
 
 gulp.task('checkstyle', function () {
+    var jscs = require('gulp-jscs');
+
     return gulp.src(paths.scripts)
         .pipe(jscs())
         .pipe(jscs.reporter())
@@ -124,18 +129,35 @@ gulp.task('checkstyle', function () {
 });
 
 gulp.task('fixstyle', function () {
+    var jscs = require('gulp-jscs');
+
     return gulp.src(paths.scripts, { base: '.' })
         .pipe(jscs({ fix: true }))
         .pipe(gulp.dest('.'));
 });
 
-gulp.task('static', ['stylesheets'], function () {
-    return gulp.src(paths.static, { base: '.' })
+gulp.task('assets', ['stylesheets'], function () {
+    return gulp.src(paths.assets)
         .pipe(gulp.dest(paths.dist));
 });
 
 gulp.task('watch', function () {
-    gulp.watch(paths.scss, ['stylesheets']);
+    return gulp.watch(paths.scss, ['stylesheets', 'assets']);
+});
+
+gulp.task('api', function () {
+    var jsdoc2md = require('gulp-jsdoc-to-markdown');
+    var concat = require('gulp-concat');
+    var markdown = require('gulp-markdown');
+    return gulp.src('src/**/*.js')
+        .pipe(concat('api.md'))
+        .pipe(jsdoc2md(require('./jsdoc.json')))
+        .pipe(markdown())
+        .pipe(gulp.dest(paths.dist));
+});
+
+gulp.task('api-watch', function () {
+    return gulp.watch('src/**/*.js', ['api']);
 });
 
 gulp.task('serve', function () {
@@ -143,9 +165,9 @@ gulp.task('serve', function () {
     var app = require('./app.js');
 });
 
-gulp.task('develop', ['serve', 'stylesheets', 'watch']);
+gulp.task('develop', ['serve', 'install', 'watch']);
 
-gulp.task('install', [ 'static', 'scripts' ]);
+gulp.task('install', [ 'assets', 'scripts' ]);
 
 gulp.task('verify', [ 'lint', 'test', 'checkstyle' ]);
 

index.html

@@ -31,10 +31,14 @@
     <script type="text/javascript">
         require(['main'], function (mct) {
             require([
+                './tutorials/todo/todo',
                 './example/imagery/bundle',
                 './example/eventGenerator/bundle',
                 './example/generator/bundle'
-            ], mct.run.bind(mct));
+            ], function (todoPlugin) {
+                mct.install(todoPlugin);
+                mct.run();
+            })
         });
     </script>
     <link rel="stylesheet" href="platform/commonUI/general/res/css/startup-base.css">
@@ -48,7 +52,5 @@
     <div class="l-splash-holder s-splash-holder">
         <div class="l-splash s-splash"></div>
     </div>
-
-    <div ng-view></div>
 </body>
 </html>

jsdoc.json

@@ -1,12 +1,13 @@
 {
     "source": {
         "include": [
-            "platform/"
+            "src/"
         ],
-        "includePattern": "platform/.+\\.js$",
+        "includePattern": "src/.+\\.js$",
         "excludePattern": ".+\\Spec\\.js$|lib/.+"
     },
     "plugins": [
-        "plugins/markdown"
+        "plugins/markdown",
+        "build/jsdoc/plugins/mct-only"
     ]
 }

main.js

@@ -28,13 +28,15 @@ requirejs.config({
         "angular-route": "bower_components/angular-route/angular-route.min",
         "csv": "bower_components/comma-separated-values/csv.min",
         "es6-promise": "bower_components/es6-promise/promise.min",
+        "EventEmitter": "bower_components/eventemitter3/index",
         "moment": "bower_components/moment/moment",
         "moment-duration-format": "bower_components/moment-duration-format/lib/moment-duration-format",
         "saveAs": "bower_components/FileSaver.js/FileSaver.min",
         "screenfull": "bower_components/screenfull/dist/screenfull.min",
         "text": "bower_components/text/text",
         "uuid": "bower_components/node-uuid/uuid",
-        "zepto": "bower_components/zepto/zepto.min"
+        "zepto": "bower_components/zepto/zepto.min",
+        "lodash": "bower_components/lodash/lodash"
     },
     "shim": {
         "angular": {
@@ -43,6 +45,9 @@ requirejs.config({
         "angular-route": {
             "deps": ["angular"]
         },
+        "EventEmitter": {
+            "exports": "EventEmitter"
+        },
         "moment-duration-format": {
             "deps": ["moment"]
         },
@@ -51,53 +56,32 @@ requirejs.config({
         },
         "zepto": {
             "exports": "Zepto"
+        },
+        "lodash": {
+            "exports": "lodash"
         }
     }
 });
 
 define([
     './platform/framework/src/Main',
-    'legacyRegistry',
+    './src/defaultRegistry',
+    './src/MCT'
+], function (Main, defaultRegistry, MCT) {
+    var mct = new MCT();
 
-    './platform/framework/bundle',
-    './platform/core/bundle',
-    './platform/representation/bundle',
-    './platform/commonUI/about/bundle',
-    './platform/commonUI/browse/bundle',
-    './platform/commonUI/edit/bundle',
-    './platform/commonUI/dialog/bundle',
-    './platform/commonUI/formats/bundle',
-    './platform/commonUI/general/bundle',
-    './platform/commonUI/inspect/bundle',
-    './platform/commonUI/mobile/bundle',
-    './platform/commonUI/themes/espresso/bundle',
-    './platform/commonUI/notification/bundle',
-    './platform/containment/bundle',
-    './platform/execution/bundle',
-    './platform/exporters/bundle',
-    './platform/telemetry/bundle',
-    './platform/features/clock/bundle',
-    './platform/features/imagery/bundle',
-    './platform/features/layout/bundle',
-    './platform/features/pages/bundle',
-    './platform/features/plot/bundle',
-    './platform/features/timeline/bundle',
-    './platform/features/table/bundle',
-    './platform/forms/bundle',
-    './platform/identity/bundle',
-    './platform/persistence/aggregator/bundle',
-    './platform/persistence/local/bundle',
-    './platform/persistence/queue/bundle',
-    './platform/policy/bundle',
-    './platform/entanglement/bundle',
-    './platform/search/bundle',
-    './platform/status/bundle',
-    './platform/commonUI/regions/bundle'
-], function (Main, legacyRegistry) {
-    return {
-        legacyRegistry: legacyRegistry,
-        run: function () {
-            return new Main().run(legacyRegistry);
-        }
+    mct.legacyRegistry = defaultRegistry;
+    mct.run = function (domElement) {
+        if (!domElement) { domElement = document.body; }
+        var appDiv = document.createElement('div');
+        appDiv.setAttribute('ng-view', '');
+        appDiv.className = 'user-environ';
+        domElement.appendChild(appDiv);
+        mct.start();
     };
+    mct.on('start', function () {
+        return new Main().run(defaultRegistry);
+    });
+
+    return mct;
 });

object-provider.html

@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>Groot Tutorial</title>
+  <script src="dist/main.js"></script>
+</head>
+<body>
+<script>
+
+    // First, we need a source of objects, so we're going to define a few
+    // objects that we wish to expose.  The first object is a folder which
+    // contains the other objects.
+
+
+    var GROOT_ROOT = {
+        name: 'I am groot',
+        type: 'folder',
+        composition: [
+            {
+                namespace: 'groot',
+                identifier: 'arms'
+            },
+            {
+                namespace: 'groot',
+                identifier: 'legs'
+            },
+            {
+                namespace: 'groot',
+                identifier: 'torso'
+            }
+        ]
+    };
+
+    // Now, we will define an object provider.  This will allow us to fetch the
+    // GROOT_ROOT object, plus any other objects in the `groot` namespace.
+    // For more info, see the Object API documentation.
+
+    MCT.Objects.addProvider('groot', {
+        // we'll only define a get function, objects from this provider will
+        // not be mutable.
+        get: function (key) {
+            if (key.identifier === 'groot') {
+                return Promise.resolve(GROOT_ROOT);
+            }
+            return Promise.resolve({
+                name: 'Groot\'s ' + key.identifier
+            });
+        }
+    });
+
+    // Finally, we need to add a "ROOT."  This is an identifier for an object
+    // that Open MCT will load at run time and show at the top-level of the
+    // navigation tree.
+
+    MCT.Objects.addRoot({
+        namespace: 'groot',
+        identifier: 'groot'
+    });
+
+    MCT.run();
+</script>
+</body>
+</html>

package.json

@@ -12,8 +12,11 @@
     "git-rev-sync": "^1.4.0",
     "glob": ">= 3.0.0",
     "gulp": "^3.9.0",
+    "gulp-concat": "^2.6.0",
     "gulp-jscs": "^3.0.2",
+    "gulp-jsdoc-to-markdown": "^1.2.2",
     "gulp-jshint": "^2.0.0",
+    "gulp-markdown": "^1.2.0",
     "gulp-rename": "^1.2.2",
     "gulp-replace-task": "^0.11.0",
     "gulp-requirejs-optimize": "^0.3.1",
@@ -47,7 +50,7 @@
     "test": "karma start --single-run",
     "jshint": "jshint platform example",
     "watch": "karma start",
-    "jsdoc": "jsdoc -c jsdoc.json -r -d target/docs/api",
+    "jsdoc": "jsdoc -c jsdoc.json -R API.md -r -d target/docs/api",
     "otherdoc": "node docs/gendocs.js --in docs/src --out target/docs --suppress-toc 'docs/src/index.md|docs/src/process/index.md'",
     "docs": "npm run jsdoc ; npm run otherdoc",
     "prepublish": "node ./node_modules/bower/bin/bower install && node ./node_modules/gulp/bin/gulp.js install"

platform/commonUI/browse/bundle.js

@@ -39,6 +39,7 @@ define([
     "text!./res/templates/items/items.html",
     "text!./res/templates/browse/object-properties.html",
     "text!./res/templates/browse/inspector-region.html",
+    "text!./res/templates/view-object.html",
     'legacyRegistry'
 ], function (
     BrowseController,
@@ -59,6 +60,7 @@ define([
     itemsTemplate,
     objectPropertiesTemplate,
     inspectorRegionTemplate,
+    viewObjectTemplate,
     legacyRegistry
 ) {
 
@@ -129,7 +131,7 @@ define([
             "representations": [
                 {
                     "key": "view-object",
-                    "templateUrl": "templates/view-object.html"
+                    "template": viewObjectTemplate
                 },
                 {
                     "key": "browse-object",

platform/commonUI/general/bundle.js

@@ -48,6 +48,7 @@ define([
     "./src/directives/MCTSplitPane",
     "./src/directives/MCTSplitter",
     "./src/directives/MCTTree",
+    "./src/filters/ReverseFilter.js",
     "text!./res/templates/bottombar.html",
     "text!./res/templates/controls/action-button.html",
     "text!./res/templates/controls/input-filter.html",
@@ -96,6 +97,7 @@ define([
     MCTSplitPane,
     MCTSplitter,
     MCTTree,
+    ReverseFilter,
     bottombarTemplate,
     actionButtonTemplate,
     inputFilterTemplate,
@@ -146,7 +148,8 @@ define([
                     "depends": [
                         "stylesheets[]",
                         "$document",
-                        "THEME"
+                        "THEME",
+                        "ASSETS_PATH"
                     ]
                 },
                 {
@@ -158,7 +161,7 @@ define([
             ],
             "filters": [
                 {
-                    "implementation": "filters/ReverseFilter.js",
+                    "implementation": ReverseFilter,
                     "key": "reverse"
                 }
             ],
@@ -404,6 +407,11 @@ define([
                     "key": "THEME",
                     "value": "unspecified",
                     "priority": "fallback"
+                },
+                {
+                    "key": "ASSETS_PATH",
+                    "value": ".",
+                    "priority": "fallback"
                 }
             ],
             "containers": [

platform/commonUI/general/src/StyleSheetLoader.js

@@ -38,7 +38,7 @@ define(
          * @param $document Angular's jqLite-wrapped document element
          * @param {string} activeTheme the theme in use
          */
-        function StyleSheetLoader(stylesheets, $document, activeTheme) {
+        function StyleSheetLoader(stylesheets, $document, activeTheme, assetPath) {
             var head = $document.find('head'),
                 document = $document[0];
 
@@ -47,6 +47,7 @@ define(
                 // Create a link element, and construct full path
                 var link = document.createElement('link'),
                     path = [
+                        assetPath,
                         stylesheet.bundle.path,
                         stylesheet.bundle.resources,
                         stylesheet.stylesheetUrl

platform/execution/src/WorkerService.js

@@ -42,11 +42,19 @@ define(
             function addWorker(worker) {
                 var key = worker.key;
                 if (!workerUrls[key]) {
-                    workerUrls[key] = [
-                        worker.bundle.path,
-                        worker.bundle.sources,
-                        worker.scriptUrl
-                    ].join("/");
+                    if (worker.scriptUrl) {
+                        workerUrls[key] = [
+                            worker.bundle.path,
+                            worker.bundle.sources,
+                            worker.scriptUrl
+                        ].join("/");
+                    } else if (worker.scriptText) {
+                        var blob = new Blob(
+                            [worker.scriptText],
+                            {type: 'application/javascript'}
+                        );
+                        workerUrls[key] = URL.createObjectURL(blob);
+                    }
                     sharedWorkers[key] = worker.shared;
                 }
             }

platform/features/table/bundle.js

@@ -27,6 +27,9 @@ define([
     "./src/controllers/TableOptionsController",
     '../../commonUI/regions/src/Region',
     '../../commonUI/browse/src/InspectorRegion',
+    "text!./res/templates/table-options-edit.html",
+    "text!./res/templates/rt-table.html",
+    "text!./res/templates/historical-table.html",
     "legacyRegistry"
 ], function (
     MCTTable,
@@ -35,6 +38,9 @@ define([
     TableOptionsController,
     Region,
     InspectorRegion,
+    tableOptionsEditTemplate,
+    rtTableTemplate,
+    historicalTableTemplate,
     legacyRegistry
 ) {
     /**
@@ -128,7 +134,7 @@ define([
                     "name": "Historical Table",
                     "key": "table",
                     "glyph": "\ue604",
-                    "templateUrl": "templates/historical-table.html",
+                    "template": historicalTableTemplate,
                     "needs": [
                         "telemetry"
                     ],
@@ -139,7 +145,7 @@ define([
                     "name": "Real-time Table",
                     "key": "rt-table",
                     "glyph": "\ue620",
-                    "templateUrl": "templates/rt-table.html",
+                    "template": rtTableTemplate,
                     "needs": [
                         "telemetry"
                     ],
@@ -157,7 +163,7 @@ define([
             "representations": [
                 {
                     "key": "table-options-edit",
-                    "templateUrl": "templates/table-options-edit.html"
+                    "template": tableOptionsEditTemplate
                 }
             ],
             "stylesheets": [

platform/search/bundle.js

@@ -28,6 +28,7 @@ define([
     "text!./res/templates/search-item.html",
     "text!./res/templates/search.html",
     "text!./res/templates/search-menu.html",
+    "text!./src/services/GenericSearchWorker.js",
     'legacyRegistry'
 ], function (
     SearchController,
@@ -37,6 +38,7 @@ define([
     searchItemTemplate,
     searchTemplate,
     searchMenuTemplate,
+    searchWorkerText,
     legacyRegistry
 ) {
 
@@ -114,7 +116,7 @@ define([
             "workers": [
                 {
                     "key": "genericSearchWorker",
-                    "scriptUrl": "services/GenericSearchWorker.js"
+                    "scriptText": searchWorkerText
                 }
             ]
         }

plugin-example.html

@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>Implementing a basic plugin</title>
+  <script src="dist/main.js"></script>
+</head>
+<body>
+<script>
+
+    function WebPlugin(websites) {
+        this.websites = websites;
+
+        var ROOTS = websites.reduce(function (rootMap, website) {
+            rootMap[website] = {
+                namespace: website,
+                identifier: 'page'
+            };
+            return rootMap;
+        }, {});
+
+        function installPlugin(MCT) {
+            Object.keys(ROOTS).forEach(function (rootUrl) {
+                MCT.Objects.addRoot(ROOTS[rootUrl]);
+                MCT.Objects.addProvider(rootUrl, {
+                    get: function () {
+                        return Promise.resolve({
+                            type: 'example.page',
+                            url: rootUrl,
+                            name: rootUrl
+                        });
+                    }
+                });
+            });
+        }
+
+        return installPlugin;
+    }
+
+    var myWebPlugin = WebPlugin([
+        'http://www.wikipedia.org/',
+        'http://nasa.github.io/openmct'
+    ]);
+
+    MCT.install(myWebPlugin);
+
+    MCT.run();
+</script>
+</body>
+</html>

src/BundleRegistry.js

@@ -24,10 +24,27 @@ define(function () {
 
     function BundleRegistry() {
         this.bundles = {};
+        this.knownBundles = {};
     }
 
     BundleRegistry.prototype.register = function (path, definition) {
-        this.bundles[path] = definition;
+        if (this.knownBundles.hasOwnProperty(path)) {
+            throw new Error('Cannot register bundle with duplicate path', path);
+        }
+        this.knownBundles[path] = definition;
+    };
+
+    BundleRegistry.prototype.enable = function (path) {
+        if (!this.knownBundles[path]) {
+            throw new Error('Unknown bundle ' + path);
+        }
+        this.bundles[path] = this.knownBundles[path];
+    };
+
+    BundleRegistry.prototype.disable = function (path) {
+        if (!this.bundles[path]) {
+            throw new Error('Tried to disable inactive bundle ' + path);
+        }
     };
 
     BundleRegistry.prototype.contains = function (path) {
@@ -42,8 +59,14 @@ define(function () {
         return Object.keys(this.bundles);
     };
 
-    BundleRegistry.prototype.remove = function (path) {
+    BundleRegistry.prototype.remove = BundleRegistry.prototype.disable;
+
+    BundleRegistry.prototype.delete = function (path) {
+        if (!this.knownBundles[path]) {
+            throw new Error('Cannot remove Unknown Bundle ' + path);
+        }
         delete this.bundles[path];
+        delete this.knownBundles[path];
     };
 
     return BundleRegistry;

src/MCT.js

@@ -0,0 +1,274 @@
+define([
+    'EventEmitter',
+    'legacyRegistry',
+    'uuid',
+    './api/api',
+    'text!./adapter/templates/edit-object-replacement.html',
+    './Selection',
+    './api/objects/object-utils',
+    './api/TimeConductor'
+], function (
+    EventEmitter,
+    legacyRegistry,
+    uuid,
+    api,
+    editObjectTemplate,
+    Selection,
+    objectUtils,
+    TimeConductor
+) {
+
+    /**
+     * The Open MCT application. This may be configured by installing plugins
+     * or registering extensions before the application is started.
+     * @class MCT
+     * @memberof module:openmct
+     * @augments {EventEmitter}
+     */
+    function MCT() {
+        EventEmitter.call(this);
+        this.legacyBundle = { extensions: {
+            services: [
+                {
+                    key: "mct",
+                    implementation: function () {
+                        return this;
+                    }.bind(this)
+                }
+            ]
+        } };
+
+        this.selection = new Selection();
+
+        /**
+         * MCT's time conductor, which may be used to synchronize view contents
+         * for telemetry- or time-based views.
+         * @type {module:openmct.TimeConductor}
+         * @memberof module:openmct.MCT#
+         * @name conductor
+         */
+        this.conductor = new TimeConductor();
+
+        /**
+         * An interface for interacting with the composition of domain objects.
+         * The composition of a domain object is the list of other domain
+         * objects it "contains" (for instance, that should be displayed
+         * beneath it in the tree.)
+         *
+         * `composition` may be called as a function, in which case it acts
+         * as [`composition.get`]{@link module:openmct.CompositionAPI#get}.
+         *
+         * @type {module:openmct.CompositionAPI}
+         * @memberof module:openmct.MCT#
+         * @name composition
+         */
+        this.composition = api.Composition;
+
+        /**
+         * Registry for views of domain objects which should appear in the
+         * main viewing area.
+         *
+         * @type {module:openmct.ViewRegistry}
+         * @memberof module:openmct.MCT#
+         * @name mainViews
+         */
+
+        /**
+         * Registry for views which should appear in the Inspector area.
+         * These views will be chosen based on selection state, so
+         * providers should be prepared to test arbitrary objects for
+         * viewability.
+         *
+         * @type {module:openmct.ViewRegistry}
+         * @memberof module:openmct.MCT#
+         * @name inspectors
+         */
+
+        /**
+         * Registry for views which should appear in the status indicator area.
+         * @type {module:openmct.ViewRegistry}
+         * @memberof module:openmct.MCT#
+         * @name indicators
+         */
+
+        /**
+         * Registry for views which should appear in the toolbar area while
+         * editing.
+         *
+         * These views will be chosen based on selection state, so
+         * providers should be prepared to test arbitrary objects for
+         * viewability.
+         *
+         * @type {module:openmct.ViewRegistry}
+         * @memberof module:openmct.MCT#
+         * @name toolbars
+         */
+
+        /**
+         * Registry for domain object types which may exist within this
+         * instance of Open MCT.
+         *
+         * @type {module:openmct.TypeRegistry}
+         * @memberof module:openmct.MCT#
+         * @name types
+         */
+
+        /**
+         * Utilities for attaching common behaviors to views.
+         *
+         * @type {module:openmct.GestureAPI}
+         * @memberof module:openmct.MCT#
+         * @name gestures
+         */
+
+        this.TimeConductor = this.conductor; // compatibility for prototype
+        this.on('navigation', this.selection.clear.bind(this.selection));
+    }
+
+    MCT.prototype = Object.create(EventEmitter.prototype);
+
+    Object.keys(api).forEach(function (k) {
+        MCT.prototype[k] = api[k];
+    });
+    MCT.prototype.MCT = MCT;
+
+    /**
+     * An interface for interacting with domain objects and the domain
+     * object hierarchy.
+     *
+     * @type {module:openmct.ObjectAPI}
+     * @memberof module:openmct.MCT#
+     * @name objects
+     */
+    MCT.Objects = api.Objects;
+
+    /**
+     * An interface for retrieving and interpreting telemetry data associated
+     * with a domain object.
+     *
+     * @type {module:openmct.TelemetryAPI}
+     * @memberof module:openmct.MCT#
+     * @name telemetry
+     */
+
+    MCT.prototype.legacyExtension = function (category, extension) {
+        this.legacyBundle.extensions[category] =
+            this.legacyBundle.extensions[category] || [];
+        this.legacyBundle.extensions[category].push(extension);
+    };
+
+    /**
+     * Set path to where assets are hosted.  This should be the path to main.js.
+     * @memberof module:openmct.MCT#
+     * @method setAssetPath
+     */
+    MCT.prototype.setAssetPath = function (path) {
+        this.legacyExtension('constants', {
+            key: "ASSETS_PATH",
+            value: path
+        });
+    };
+
+    MCT.prototype.view = function (region, definition) {
+        var viewKey = region + uuid();
+        var adaptedViewKey = "adapted-view-" + region;
+
+        this.legacyExtension(
+            region === this.regions.main ? 'views' : 'representations',
+            {
+                name: "A view",
+                key: adaptedViewKey,
+                editable: true,
+                template: '<mct-view region="\'' +
+                    region +
+                    '\'" ' +
+                    'key="\'' +
+                    viewKey +
+                    '\'" ' +
+                    'mct-object="domainObject">' +
+                    '</mct-view>'
+            }
+        );
+
+        this.legacyExtension('policies', {
+            category: "view",
+            implementation: function Policy() {
+                this.allow = function (view, domainObject) {
+                    if (view.key === adaptedViewKey) {
+                        var model = domainObject.getModel();
+                        var newDO = objectUtils.toNewFormat(model);
+                        return definition.canView(newDO);
+                    }
+                    return true;
+                };
+            }
+        });
+
+        this.legacyExtension('newViews', {
+            factory: definition,
+            region: region,
+            key: viewKey
+        });
+    };
+
+    MCT.prototype.type = function (key, type) {
+        var legacyDef = type.toLegacyDefinition();
+        legacyDef.key = key;
+        type.key = key;
+
+        this.legacyExtension('types', legacyDef);
+        this.legacyExtension('representations', {
+            key: "edit-object",
+            priority: "preferred",
+            template: editObjectTemplate,
+            type: key
+        });
+    };
+
+    /**
+     * Start running Open MCT. This should be called only after any plugins
+     * have been installed.
+     * @fires module:openmct.MCT~start
+     * @memberof module:openmct.MCT#
+     * @method start
+     */
+    MCT.prototype.start = function () {
+        this.legacyExtension('runs', {
+            depends: ['navigationService'],
+            implementation: function (navigationService) {
+                navigationService
+                    .addListener(this.emit.bind(this, 'navigation'));
+            }.bind(this)
+        });
+
+        legacyRegistry.register('adapter', this.legacyBundle);
+        legacyRegistry.enable('adapter');
+        /**
+         * Fired by [MCT]{@link module:openmct.MCT} when the application
+         * is started.
+         * @event start
+         * @memberof module:openmct.MCT~
+         */
+        this.emit('start');
+    };
+
+
+    /**
+     * Install a plugin in MCT.
+     *
+     * @param {Function} plugin a plugin install function which will be
+     *     invoked with the mct instance.
+     * @memberof module:openmct.MCT#
+     */
+    MCT.prototype.install = function (plugin) {
+        plugin(this);
+    };
+
+    MCT.prototype.regions = {
+        main: "MAIN",
+        properties: "PROPERTIES",
+        toolbar: "TOOLBAR"
+    };
+
+    return MCT;
+});

src/Selection.js

@@ -0,0 +1,72 @@
+define(['EventEmitter'], function (EventEmitter) {
+    /**
+     * Maintains selection state for the application.
+     * @interface
+     * @memberof module:openmct
+     * @extends {EventEmitter}
+     */
+    function Selection() {
+        EventEmitter.call(this);
+        this.selectedValues = [];
+    }
+
+    /**
+     * Fired whenever the current selection state changes.
+     * @event change
+     * @memberof module:openmct.Selection~
+     */
+
+    Selection.prototype = Object.create(EventEmitter.prototype);
+
+    /**
+     * Add a new value to the current selection state.
+     * @param {*} value the newly selected value
+     * @returns {Function} a function to deselect this value
+     * @method select
+     * @memberof module:openmct.Selection#
+     * @fires module:openmct.Selection~change
+     */
+    Selection.prototype.select = function (value) {
+        this.selectedValues.push(value);
+        this.emit('change', this.selectedValues);
+        return this.deselect.bind(this, value);
+    };
+
+    /**
+     * Remove a value from the current selection state.
+     * @param {*} value the value to deselect
+     * @method deselect
+     * @memberof module:openmct.Selection#
+     * @fires module:openmct.Selection~change
+     */
+    Selection.prototype.deselect = function (value) {
+        this.selectedValues = this.selectedValues.filter(function (v) {
+            return v !== value;
+        });
+        this.emit('change', this.selectedValues);
+    };
+
+    /**
+     * Get the current selection state.
+     * @param {*} value the newly selected value
+     * @returns {Array} all currently-selected objects
+     * @method selected
+     * @memberof module:openmct.Selection#
+     */
+    Selection.prototype.selected = function () {
+        return this.selectedValues;
+    };
+
+    /**
+     * Deselect all currently-selected objects.
+     * @method clear
+     * @memberof module:openmct.Selection#
+     * @fires module:openmct.Selection~change
+     */
+    Selection.prototype.clear = function () {
+        this.selectedValues = [];
+        this.emit('change', this.selectedValues);
+    };
+
+    return Selection;
+});

src/adapter/actions/ActionDialogDecorator.js

@@ -0,0 +1,44 @@
+define([
+    '../../api/objects/object-utils'
+], function (objectUtils) {
+    function ActionDialogDecorator(mct, newViews, actionService) {
+        this.actionService = actionService;
+        this.mct = mct;
+        this.definitions = newViews.filter(function (newView) {
+            return newView.region === mct.regions.properties;
+        }).map(function (newView) {
+            return newView.factory;
+        });
+    }
+
+    ActionDialogDecorator.prototype.getActions = function (context) {
+        var mct = this.mct;
+        var definitions = this.definitions;
+
+        return this.actionService.getActions(context).map(function (action) {
+            if (action.dialogService) {
+                var domainObject = objectUtils.toNewFormat(
+                    context.domainObject.getModel(),
+                    objectUtils.parseKeyString(context.domainObject.getId())
+                );
+
+                definitions = definitions.filter(function (definition) {
+                    return definition.canView(domainObject);
+                });
+
+                if (definitions.length > 0) {
+                    action.dialogService = Object.create(action.dialogService);
+                    action.dialogService.getUserInput = function (form, value) {
+                        return new mct.Dialog(
+                            definitions[0].view(context.domainObject),
+                            form.title
+                        ).show();
+                    };
+                }
+            }
+            return action;
+        });
+    };
+
+    return ActionDialogDecorator;
+});

src/adapter/bundle.js

@@ -0,0 +1,65 @@
+define([
+    'legacyRegistry',
+    './actions/ActionDialogDecorator',
+    './directives/MCTView',
+    './services/Instantiate',
+    './capabilities/APICapabilityDecorator',
+    './policies/AdapterCompositionPolicy'
+], function (
+    legacyRegistry,
+    ActionDialogDecorator,
+    MCTView,
+    Instantiate,
+    APICapabilityDecorator,
+    AdapterCompositionPolicy
+) {
+    legacyRegistry.register('src/adapter', {
+        "extensions": {
+            "directives": [
+                {
+                    key: "mctView",
+                    implementation: MCTView,
+                    depends: [
+                        "newViews[]",
+                        "mct"
+                    ]
+                }
+            ],
+            services: [
+                {
+                    key: "instantiate",
+                    priority: "mandatory",
+                    implementation: Instantiate,
+                    depends: [
+                        "capabilityService",
+                        "identifierService",
+                        "cacheService"
+                    ]
+                }
+            ],
+            components: [
+                {
+                    type: "decorator",
+                    provides: "capabilityService",
+                    implementation: APICapabilityDecorator,
+                    depends: [
+                        "$injector"
+                    ]
+                },
+                {
+                    type: "decorator",
+                    provides: "actionService",
+                    implementation: ActionDialogDecorator,
+                    depends: [ "mct", "newViews[]" ]
+                }
+            ],
+            policies: [
+                {
+                    category: "composition",
+                    implementation: AdapterCompositionPolicy,
+                    depends: [ "mct" ]
+                }
+            ]
+        }
+    });
+});

src/adapter/capabilities/APICapabilityDecorator.js

@@ -0,0 +1,37 @@
+define([
+    './synchronizeMutationCapability',
+    './AlternateCompositionCapability'
+], function (
+    synchronizeMutationCapability,
+    AlternateCompositionCapability
+) {
+
+    /**
+     * Overrides certain capabilities to keep consistency between old API
+     * and new API.
+     */
+    function APICapabilityDecorator($injector, capabilityService) {
+        this.$injector = $injector;
+        this.capabilityService = capabilityService;
+    }
+
+    APICapabilityDecorator.prototype.getCapabilities = function (
+        model
+    ) {
+        var capabilities = this.capabilityService.getCapabilities(model);
+        if (capabilities.mutation) {
+            capabilities.mutation =
+                synchronizeMutationCapability(capabilities.mutation);
+        }
+        if (AlternateCompositionCapability.appliesTo(model)) {
+            capabilities.composition = function (domainObject) {
+                return new AlternateCompositionCapability(this.$injector, domainObject)
+            }.bind(this);
+        }
+
+        return capabilities;
+    };
+
+    return APICapabilityDecorator;
+
+});

src/adapter/capabilities/AlternateCompositionCapability.js

@@ -0,0 +1,102 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+/**
+ * Module defining AlternateCompositionCapability. Created by vwoeltje on 11/7/14.
+ */
+define([
+    '../../api/objects/object-utils',
+    '../../api/composition/CompositionAPI'
+], function (objectUtils, CompositionAPI) {
+
+        function AlternateCompositionCapability($injector, domainObject) {
+            this.domainObject = domainObject;
+
+            this.getDependencies = function () {
+                this.instantiate = $injector.get("instantiate");
+                this.contextualize = $injector.get("contextualize");
+                this.getDependencies = undefined;
+            }.bind(this);
+        }
+
+        AlternateCompositionCapability.prototype.add = function (child, index) {
+            if (typeof index !== 'undefined') {
+                // At first glance I don't see a location in the existing
+                // codebase where add is called with an index.  Won't support.
+                throw new Error(
+                    'Composition Capability does not support adding at index'
+                );
+            }
+
+            function addChildToComposition(model) {
+                var existingIndex = model.composition.indexOf(child.getId());
+                if (existingIndex === -1) {
+                    model.composition.push(child.getId())
+                }
+            }
+
+            return this.domainObject.useCapability(
+                    'mutation',
+                    addChildToComposition
+                )
+                .then(this.invoke.bind(this))
+                .then(function (children) {
+                    return children.filter(function (c) {
+                        return c.getId() === child.getId();
+                    })[0];
+                });
+        };
+
+        AlternateCompositionCapability.prototype.contextualizeChild = function (
+            child
+        ) {
+            if (this.getDependencies) {
+                this.getDependencies();
+            }
+
+            var keyString = objectUtils.makeKeyString(child.key);
+            var oldModel = objectUtils.toOldFormat(child);
+            var newDO = this.instantiate(oldModel, keyString);
+            return this.contextualize(newDO, this.domainObject);
+
+        };
+
+        AlternateCompositionCapability.prototype.invoke = function () {
+            var newFormatDO = objectUtils.toNewFormat(
+                this.domainObject.getModel(),
+                this.domainObject.getId()
+            );
+            var collection = CompositionAPI(newFormatDO);
+            return collection.load()
+                .then(function (children) {
+                    collection.destroy();
+                    return children.map(this.contextualizeChild, this);
+                }.bind(this));
+        };
+
+        AlternateCompositionCapability.appliesTo = function (model) {
+            return !!CompositionAPI(objectUtils.toNewFormat(model, model.id));
+        };
+
+        return AlternateCompositionCapability;
+    }
+);

src/adapter/capabilities/synchronizeMutationCapability.js

@@ -0,0 +1,27 @@
+define([
+
+], function (
+
+) {
+
+    /**
+     * Wraps the mutation capability and synchronizes the mutation
+     */
+    function synchronizeMutationCapability(mutationConstructor) {
+
+        return function makeCapability(domainObject) {
+            var capability = mutationConstructor(domainObject);
+            var oldListen = capability.listen.bind(capability);
+            capability.listen = function (listener) {
+                return oldListen(function (newModel) {
+                    capability.domainObject.model =
+                        JSON.parse(JSON.stringify(newModel));
+                    listener(newModel);
+                });
+            };
+            return capability;
+        }
+    };
+
+    return synchronizeMutationCapability;
+});

src/adapter/directives/MCTView.js

@@ -0,0 +1,65 @@
+define([
+    'angular',
+    './Region',
+    '../../api/objects/object-utils'
+], function (
+    angular,
+    Region,
+    objectUtils
+) {
+    function MCTView(newViews, PublicAPI) {
+        var definitions = {};
+
+        newViews.forEach(function (newView) {
+            definitions[newView.region] = definitions[newView.region] || {};
+            definitions[newView.region][newView.key] = newView.factory;
+        });
+
+        return {
+            restrict: 'E',
+            link: function (scope, element, attrs) {
+                var key, mctObject, regionId, region;
+
+                function maybeShow() {
+                    if (!definitions[regionId] || !definitions[regionId][key] || !mctObject) {
+                        return;
+                    }
+
+                    region.show(definitions[regionId][key].view(mctObject));
+                }
+
+                function setKey(k) {
+                    key = k;
+                    maybeShow();
+                }
+
+                function setObject(obj) {
+                    mctObject = undefined;
+                    PublicAPI.Objects.get(objectUtils.parseKeyString(obj.getId()))
+                        .then(function (mobj) {
+                            mctObject = mobj;
+                            maybeShow();
+                        });
+                }
+
+                function setRegionId(r) {
+                    regionId = r;
+                    maybeShow();
+                }
+
+                region = new Region(element[0]);
+
+                scope.$watch('key', setKey);
+                scope.$watch('region', setRegionId);
+                scope.$watch('mctObject', setObject);
+            },
+            scope: {
+                key: "=",
+                region: "=",
+                mctObject: "="
+            }
+        };
+    }
+
+    return MCTView;
+});

src/adapter/directives/Region.js

@@ -0,0 +1,23 @@
+define([], function () {
+    function Region(element) {
+        this.activeView = undefined;
+        this.element = element;
+    }
+
+    Region.prototype.clear = function () {
+        if (this.activeView) {
+            this.activeView.destroy();
+            this.activeView = undefined;
+        }
+    };
+
+    Region.prototype.show = function (view) {
+        this.clear();
+        this.activeView = view;
+        if (this.activeView) {
+            this.activeView.show(this.element);
+        }
+    };
+
+    return Region;
+});

src/adapter/policies/AdapterCompositionPolicy.js

@@ -0,0 +1,26 @@
+define([], function () {
+    function AdapterCompositionPolicy(mct) {
+        this.mct = mct;
+    }
+
+    AdapterCompositionPolicy.prototype.allow = function (
+        containerType,
+        childType
+    ) {
+        var containerObject = containerType.getInitialModel();
+        var childObject = childType.getInitialModel();
+
+        containerObject.type = containerType.getKey();
+        childObject.type = childType.getKey();
+
+        var composition = this.mct.Composition(containerObject);
+
+        if (composition) {
+            return composition.canContain(childObject);
+        }
+
+        return true;
+    };
+
+    return AdapterCompositionPolicy;
+});

src/adapter/services/Instantiate.js

@@ -0,0 +1,49 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+define(
+    ['../../../platform/core/src/objects/DomainObjectImpl'],
+    function (DomainObjectImpl) {
+
+        /**
+         * Overrides platform version of instantiate, passes Id with model such
+         * that capability detection can utilize new format domain objects.
+         */
+        function Instantiate(
+            capabilityService,
+            identifierService,
+            cacheService
+        ) {
+            return function (model, id) {
+                id = id || identifierService.generate();
+                var old_id = model.id;
+                model.id = id;
+                var capabilities = capabilityService.getCapabilities(model);
+                model.id = old_id;
+                cacheService.put(id, model);
+                return new DomainObjectImpl(id, model, capabilities);
+            };
+        }
+
+        return Instantiate;
+    }
+);

src/adapter/templates/edit-object-replacement.html

@@ -0,0 +1,46 @@
+<div class="abs l-flex-col" ng-controller="EditObjectController as EditObjectController">
+    <div mct-before-unload="EditObjectController.getUnloadWarning()"
+         class="holder flex-elem l-flex-row object-browse-bar ">
+        <div class="items-select left flex-elem l-flex-row grows">
+            <mct-representation key="'back-arrow'"
+                                mct-object="domainObject"
+                                class="flex-elem l-back"></mct-representation>
+            <mct-representation key="'object-header'"
+                                mct-object="domainObject"
+                                class="l-flex-row flex-elem grows object-header">
+            </mct-representation>
+        </div>
+        <div class="btn-bar right l-flex-row flex-elem flex-justify-end flex-fixed">
+            <mct-representation key="'switcher'"
+                                mct-object="domainObject"
+                                ng-model="representation">
+            </mct-representation>
+            <!-- Temporarily, on mobile, the action buttons are hidden-->
+            <mct-representation key="'action-group'"
+                                mct-object="domainObject"
+                                parameters="{ category: 'view-control' }"
+                                class="mobile-hide">
+            </mct-representation>
+        </div>
+    </div>
+    <div class="holder l-flex-col flex-elem grows l-object-wrapper">
+        <div class="holder l-flex-col flex-elem grows l-object-wrapper-inner">
+            <!-- Toolbar and Save/Cancel buttons -->
+            <div class="l-edit-controls flex-elem l-flex-row flex-align-end">
+                <mct-representation key="'adapted-view-TOOLBAR'"
+                                    mct-object="domainObject"
+                                    class="flex-elem grows">
+                </mct-representation>
+                <mct-representation key="'edit-action-buttons'"
+                                    mct-object="domainObject"
+                                    class='flex-elem conclude-editing'>
+                </mct-representation>
+            </div>
+            <mct-representation key="representation.selected.key"
+                                mct-object="representation.selected.key && domainObject"
+                                class="abs flex-elem grows object-holder-main scroll"
+                                toolbar="toolbar">
+            </mct-representation>
+        </div><!--/ l-object-wrapper-inner -->
+    </div>
+</div>

src/api/TimeConductor.js

@@ -0,0 +1,202 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+define(['EventEmitter'], function (EventEmitter) {
+
+    /**
+     * The public API for setting and querying time conductor state. The
+     * time conductor is the means by which the temporal bounds of a view
+     * are controlled. Time-sensitive views will typically respond to
+     * changes to bounds or other properties of the time conductor and
+     * update the data displayed based on the time conductor state.
+     *
+     * The TimeConductor extends the EventEmitter class. A number of events are
+     * fired when properties of the time conductor change, which are
+     * documented below.
+     * @interface
+     * @memberof module:openmct
+     */
+    function TimeConductor() {
+        EventEmitter.call(this);
+
+        //The Time System
+        this.system = undefined;
+        //The Time Of Interest
+        this.toi = undefined;
+
+        this.boundsVal = {
+            start: undefined,
+            end: undefined
+        };
+
+        //Default to fixed mode
+        this.followMode = false;
+    }
+
+    TimeConductor.prototype = Object.create(EventEmitter.prototype);
+
+    /**
+     * Validate the given bounds. This can be used for pre-validation of
+     * bounds, for example by views validating user inputs.
+     * @param bounds The start and end time of the conductor.
+     * @returns {string | true} A validation error, or true if valid
+     * @memberof module:openmct.TimeConductor#
+     * @method validateBounds
+     */
+    TimeConductor.prototype.validateBounds = function (bounds) {
+        if ((bounds.start === undefined) ||
+            (bounds.end === undefined) ||
+            isNaN(bounds.start) ||
+            isNaN(bounds.end)
+        ) {
+            return "Start and end must be specified as integer values";
+        } else if (bounds.start > bounds.end) {
+            return "Specified start date exceeds end bound";
+        }
+        return true;
+    };
+
+    function throwOnError(validationResult) {
+        if (validationResult !== true) {
+            throw new Error(validationResult);
+        }
+    }
+
+    /**
+     * Get or set the follow mode of the time conductor. In follow mode the
+     * time conductor ticks, regularly updating the bounds from a timing
+     * source appropriate to the selected time system and mode of the time
+     * conductor.
+     * @fires module:openmct.TimeConductor~follow
+     * @param {boolean} followMode
+     * @returns {boolean}
+     * @memberof module:openmct.TimeConductor#
+     * @method follow
+     */
+    TimeConductor.prototype.follow = function (followMode) {
+        if (arguments.length > 0) {
+            this.followMode = followMode;
+            /**
+             * The TimeConductor has toggled into or out of follow mode.
+             * @event follow
+             * @memberof module:openmct.TimeConductor~
+             * @property {boolean} followMode true if follow mode is
+             *           enabled, otherwise false.
+             */
+            this.emit('follow', this.followMode);
+        }
+        return this.followMode;
+    };
+
+    /**
+     * @typedef {Object} TimeConductorBounds
+     * @property {number} start The start time displayed by the time conductor in ms since epoch. Epoch determined by current time system
+     * @property {number} end The end time displayed by the time conductor in ms since epoch.
+     * @memberof module:openmct.TimeConductor~
+     */
+
+    /**
+     * Get or set the start and end time of the time conductor. Basic validation
+     * of bounds is performed.
+     *
+     * @param {module:openmct.TimeConductorBounds~TimeConductorBounds} newBounds
+     * @throws {Error} Validation error
+     * @fires module:openmct.TimeConductor~bounds
+     * @returns {module:openmct.TimeConductorBounds~TimeConductorBounds}
+     * @memberof module:openmct.TimeConductor#
+     * @method bounds
+     */
+    TimeConductor.prototype.bounds = function (newBounds) {
+        if (arguments.length > 0) {
+            throwOnError(this.validateBounds(newBounds));
+            this.boundsVal = newBounds;
+            /**
+             * The start time, end time, or both have been updated.
+             * @event bounds
+             * @memberof module:openmct.TimeConductor~
+             * @property {TimeConductorBounds} bounds
+             */
+            this.emit('bounds', this.boundsVal);
+        }
+        return this.boundsVal;
+    };
+
+    /**
+     * Get or set the time system of the TimeConductor. Time systems determine
+     * units, epoch, and other aspects of time representation. When changing
+     * the time system in use, new valid bounds must also be provided.
+     * @param {TimeSystem} newTimeSystem
+     * @param {module:openmct.TimeConductor~TimeConductorBounds} bounds
+     * @fires module:openmct.TimeConductor~timeSystem
+     * @returns {TimeSystem} The currently applied time system
+     * @memberof module:openmct.TimeConductor#
+     * @method timeSystem
+     */
+    TimeConductor.prototype.timeSystem = function (newTimeSystem, bounds) {
+        if (arguments.length >= 2) {
+            this.system = newTimeSystem;
+            /**
+             * The time system used by the time
+             * conductor has changed. A change in Time System will always be
+             * followed by a bounds event specifying new query bounds.
+             *
+             * @event module:openmct.TimeConductor~timeSystem
+             * @property {TimeSystem} The value of the currently applied
+             * Time System
+             * */
+            this.emit('timeSystem', this.system);
+            // Do something with bounds here. Try and convert between
+            // time systems? Or just set defaults when time system changes?
+            // eg.
+            this.bounds(bounds);
+        } else if (arguments.length === 1) {
+            throw new Error('Must set bounds when changing time system');
+        }
+        return this.system;
+    };
+
+    /**
+     * Get or set the Time of Interest. The Time of Interest is the temporal
+     * focus of the current view. It can be manipulated by the user from the
+     * time conductor or from other views.
+     * @fires module:openmct.TimeConductor~timeOfInterest
+     * @param newTOI
+     * @returns {number} the current time of interest
+     * @memberof module:openmct.TimeConductor#
+     * @method timeOfInterest
+     */
+    TimeConductor.prototype.timeOfInterest = function (newTOI) {
+        if (arguments.length > 0) {
+            this.toi = newTOI;
+            /**
+             * The Time of Interest has moved.
+             * @event timeOfInterest
+             * @memberof module:openmct.TimeConductor~
+             * @property {number} Current time of interest
+             */
+            this.emit('timeOfInterest', this.toi);
+        }
+        return this.toi;
+    };
+
+    return TimeConductor;
+});

src/api/TimeConductorSpec.js

@@ -0,0 +1,110 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+define(['./TimeConductor'], function (TimeConductor) {
+    describe("The Time Conductor", function () {
+        var tc,
+            timeSystem,
+            bounds,
+            eventListener,
+            toi,
+            follow;
+
+        beforeEach(function () {
+            tc = new TimeConductor();
+            timeSystem = {};
+            bounds = {start: 0, end: 0};
+            eventListener = jasmine.createSpy("eventListener");
+            toi = 111;
+            follow = true;
+        });
+
+        it("Supports setting and querying of time of interest and and follow mode", function () {
+            expect(tc.timeOfInterest()).not.toBe(toi);
+            tc.timeOfInterest(toi);
+            expect(tc.timeOfInterest()).toBe(toi);
+
+            expect(tc.follow()).not.toBe(follow);
+            tc.follow(follow);
+            expect(tc.follow()).toBe(follow);
+        });
+
+        it("Allows setting of valid bounds", function () {
+            bounds = {start: 0, end: 1};
+            expect(tc.bounds()).not.toBe(bounds);
+            expect(tc.bounds.bind(tc, bounds)).not.toThrow();
+            expect(tc.bounds()).toBe(bounds);
+        });
+
+        it("Disallows setting of invalid bounds", function () {
+            bounds = {start: 1, end: 0};
+            expect(tc.bounds()).not.toBe(bounds);
+            expect(tc.bounds.bind(tc, bounds)).toThrow();
+            expect(tc.bounds()).not.toBe(bounds);
+
+            bounds = {start: 1};
+            expect(tc.bounds()).not.toBe(bounds);
+            expect(tc.bounds.bind(tc, bounds)).toThrow();
+            expect(tc.bounds()).not.toBe(bounds);
+        });
+
+        it("Allows setting of time system with bounds", function () {
+            expect(tc.timeSystem()).not.toBe(timeSystem);
+            expect(tc.timeSystem.bind(tc, timeSystem, bounds)).not.toThrow();
+            expect(tc.timeSystem()).toBe(timeSystem);
+        });
+
+        it("Disallows setting of time system without bounds", function () {
+            expect(tc.timeSystem()).not.toBe(timeSystem);
+            expect(tc.timeSystem.bind(tc, timeSystem)).toThrow();
+            expect(tc.timeSystem()).not.toBe(timeSystem);
+        });
+
+        it("Emits an event when time system changes", function () {
+            expect(eventListener).not.toHaveBeenCalled();
+            tc.on("timeSystem", eventListener);
+            tc.timeSystem(timeSystem, bounds);
+            expect(eventListener).toHaveBeenCalledWith(timeSystem);
+        });
+
+        it("Emits an event when time of interest changes", function () {
+            expect(eventListener).not.toHaveBeenCalled();
+            tc.on("timeOfInterest", eventListener);
+            tc.timeOfInterest(toi);
+            expect(eventListener).toHaveBeenCalledWith(toi);
+        });
+
+        it("Emits an event when bounds change", function () {
+            expect(eventListener).not.toHaveBeenCalled();
+            tc.on("bounds", eventListener);
+            tc.bounds(bounds);
+            expect(eventListener).toHaveBeenCalledWith(bounds);
+        });
+
+        it("Emits an event when follow mode changes", function () {
+            expect(eventListener).not.toHaveBeenCalled();
+            tc.on("follow", eventListener);
+            tc.follow(follow);
+            expect(eventListener).toHaveBeenCalledWith(follow);
+        });
+    });
+});

src/api/Type.js

@@ -0,0 +1,60 @@
+define(function () {
+    /**
+     * @typedef TypeDefinition
+     * @memberof module:openmct.Type~
+     * @property {Metadata} metadata displayable metadata about this type
+     * @property {function (object)} [initialize] a function which initializes
+     *           the model for new domain objects of this type
+     * @property {boolean} [creatable] true if users should be allowed to
+     *           create this type (default: false)
+     */
+
+    /**
+     * A Type describes a kind of domain object that may appear or be
+     * created within Open MCT.
+     *
+     * @param {module:opemct.Type~TypeDefinition} definition
+     * @class Type
+     * @memberof module:openmct
+     */
+    function Type(definition) {
+        this.definition = definition;
+    }
+
+    /**
+     * Check if a domain object is an instance of this type.
+     * @param domainObject
+     * @returns {boolean} true if the domain object is of this type
+     * @memberof module:openmct.Type#
+     * @method check
+     */
+    Type.prototype.check = function (domainObject) {
+        // Depends on assignment from MCT.
+        return domainObject.type === this.key;
+    };
+
+    /**
+     * Get a definition for this type that can be registered using the
+     * legacy bundle format.
+     * @private
+     */
+    Type.prototype.toLegacyDefinition = function () {
+        var def = {};
+        def.name = this.definition.metadata.label;
+        def.glyph = this.definition.metadata.glyph;
+        def.description = this.definition.metadata.description;
+        def.properties = this.definition.form;
+
+        if (this.definition.initialize) {
+            def.model = {};
+            this.definition.initialize(def.model);
+        }
+
+        if (this.definition.creatable) {
+            def.features = ['creation'];
+        }
+        return def;
+    };
+
+    return Type;
+});

src/api/View.js

@@ -0,0 +1,104 @@
+define([], function () {
+
+    /**
+     * A View is used to provide displayable content, and to react to
+     * associated life cycle events.
+     *
+     * @interface
+     * @memberof module:openmct
+     */
+    function View() {
+
+    }
+
+    /**
+     * Populate the supplied DOM element with the contents of this view.
+     *
+     * View implementations should use this method to attach any
+     * listeners or acquire other resources that are necessary to keep
+     * the contents of this view up-to-date.
+     *
+     * @param {HTMLElement} container the DOM element to populate
+     * @method show
+     * @memberof module:openmct.View#
+     */
+    View.prototype.show = function (container) {
+
+    };
+
+    /**
+     * Release any resources associated with this view.
+     *
+     * View implementations should use this method to detach any
+     * listeners or release other resources that are no longer necessary
+     * once a view is no longer used.
+     *
+     * @method destroy
+     * @memberof module:openmct.View#
+     */
+    View.prototype.destroy = function () {
+
+    };
+
+    /**
+     * Exposes types of views in Open MCT.
+     *
+     * @interface ViewProvider
+     * @memberof module:openmct
+     */
+
+    /**
+     * Check if this provider can supply views for a domain object.
+     *
+     * When called by Open MCT, this may include additional arguments
+     * which are on the path to the object to be viewed; for instance,
+     * when viewing "A Folder" within "My Items", this method will be
+     * invoked with "A Folder" (as a domain object) as the first argument,
+     * and "My Items" as the second argument.
+     *
+     * @method canView
+     * @memberof module:openmct.ViewProvider#
+     * @param {module:openmct.DomainObject} domainObject the domain object
+     *        to be viewed
+     * @returns {boolean} true if this domain object can be viewed using
+     *          this provider
+     */
+
+    /**
+     * Provide a view of this object.
+     *
+     * When called by Open MCT, this may include additional arguments
+     * which are on the path to the object to be viewed; for instance,
+     * when viewing "A Folder" within "My Items", this method will be
+     * invoked with "A Folder" (as a domain object) as the first argument,
+     * and "My Items" as the second argument.
+     *
+     * @method view
+     * @memberof module:openmct.ViewProvider#
+     * @param {*} object the object to be viewed
+     * @returns {module:openmct.View} a view of this domain object
+     */
+
+    /**
+     * Get metadata associated with this view provider. This may be used
+     * to populate the user interface with options associated with this
+     * view provider.
+     *
+     * @method metadata
+     * @memberof module:openmct.ViewProvider#
+     * @returns {module:openmct.ViewProvider~ViewMetadata} view metadata
+     */
+
+    /**
+     * @typedef ViewMetadata
+     * @memberof module:openmct.ViewProvider~
+     * @property {string} name the human-readable name of this view
+     * @property {string} key a machine-readable name for this view
+     * @property {string} [description] a longer-form description (typically
+     *           a single sentence or short paragraph) of this kind of view
+     * @property {string} cssclass the CSS class to apply to labels for this
+     *           view (to add icons, for instance)
+     */
+
+    return View;
+});

src/api/ViewDefinition.js

@@ -0,0 +1,44 @@
+define(function () {
+
+    /**
+     * Defines a kind of view.
+     * @interface
+     */
+    function ViewDefinition() {
+    }
+
+    /**
+     * Get metadata about this view, as may be used in the user interface
+     * to present options for this view.
+     * @param {*} object the object to be shown in this view
+     * @returns {mct.ViewMetadata} metadata about this view
+     */
+    ViewDefinition.prototype.metadata = function (object) {
+    };
+
+    /**
+     * Instantiate a new view of this object. Callers of this method are
+     * responsible for calling `canView` before instantiating views in this
+     * manner.
+     *
+     * @param {*} object the object to be shown in this view
+     * @returns {mct.View} a view of this object
+     */
+    ViewDefinition.prototype.view = function (object) {
+    };
+
+    /**
+     * Check if this view is capable of showing this object. Users of
+     * views should use this method before calling `show`.
+     *
+     * Subclasses should override this method to control the applicability
+     * of this view to other objects.
+     *
+     * @param {*} object the object to be shown in this view
+     * @returns {boolean} true if this view is applicable to this object
+     */
+    ViewDefinition.prototype.canView = function (object) {
+    };
+
+    return ViewDefinition;
+});

src/api/api.js

@@ -0,0 +1,23 @@
+define([
+    './Type',
+    './TimeConductor',
+    './View',
+    './objects/ObjectAPI',
+    './composition/CompositionAPI',
+    './ui/Dialog'
+], function (
+    Type,
+    TimeConductor,
+    View,
+    ObjectAPI,
+    CompositionAPI,
+    Dialog
+) {
+    return {
+        Type: Type,
+        View: View,
+        Objects: ObjectAPI,
+        Composition: CompositionAPI,
+        Dialog: Dialog
+    };
+});

src/api/composition/CompositionAPI.js

@@ -0,0 +1,95 @@
+define([
+    'lodash',
+    'EventEmitter',
+    './DefaultCompositionProvider',
+    './CompositionCollection'
+], function (
+    _,
+    EventEmitter,
+    DefaultCompositionProvider,
+    CompositionCollection
+) {
+
+    var PROVIDER_REGISTRY = [];
+
+    function getProvider (object) {
+        return _.find(PROVIDER_REGISTRY, function (p) {
+            return p.appliesTo(object);
+        });
+    };
+
+    /**
+     * An interface for interacting with the composition of domain objects.
+     * The composition of a domain object is the list of other domain objects
+     * it "contains" (for instance, that should be displayed beneath it
+     * in the tree.)
+     *
+     * @interface CompositionAPI
+     * @returns {module:openmct.CompositionCollection}
+     * @memberof module:openmct
+     */
+    function composition(object) {
+        var provider = getProvider(object);
+
+        if (!provider) {
+            return;
+        }
+
+        return new CompositionCollection(object, provider);
+    }
+
+    /**
+     * Retrieve the composition (if any) of this domain object.
+     *
+     * @method get
+     * @returns {module:openmct.CompositionCollection}
+     * @memberof module:openmct.CompositionAPI#
+     */
+    composition.get = composition;
+
+    /**
+     * Add a composition provider.
+     *
+     * Plugins can add new composition providers to change the loading
+     * behavior for certain domain objects.
+     *
+     * @method addProvider
+     * @param {module:openmct.CompositionProvider} provider the provider to add
+     * @memberof module:openmct.CompositionAPI#
+     */
+    composition.addProvider = function (provider) {
+        PROVIDER_REGISTRY.unshift(provider);
+    };
+
+    /**
+     * Add a composition policy. Composition policies may disallow domain
+     * objects from containing other domain objects.
+     *
+     * @method addPolicy
+     * @param {module:openmct.CompositionAPI~CompositionPolicy} policy
+     *        the policy to add
+     * @memberof module:openmct.CompositionAPI#
+     */
+
+    /**
+     * A composition policy is a function which either allows or disallows
+     * placing one object in another's composition.
+     *
+     * Open MCT's policy model requires consensus, so any one policy may
+     * reject composition by returning false. As such, policies should
+     * generally be written to return true in the default case.
+     *
+     * @callback CompositionPolicy
+     * @memberof module:openmct.CompositionAPI~
+     * @param {module:openmct.DomainObject} containingObject the object which
+     *        would act as a container
+     * @param {module:openmct.DomainObject} containedObject the object which
+     *        would be contained
+     * @returns {boolean} false if this composition should be disallowed
+     */
+
+    composition.addProvider(new DefaultCompositionProvider());
+
+    return composition;
+
+});

src/api/composition/CompositionCollection.js

@@ -0,0 +1,199 @@
+define([
+    'EventEmitter',
+    'lodash',
+    '../objects/object-utils'
+], function (
+    EventEmitter,
+    _,
+    objectUtils
+) {
+
+
+    /**
+     * A CompositionCollection represents the list of domain objects contained
+     * by another domain object. It provides methods for loading this
+     * list asynchronously, and for modifying this list.
+     *
+     * @interface CompositionCollection
+     * @param {module:openmct.DomainObject} domainObject the domain object
+     *        whose composition will be contained
+     * @param {module:openmct.CompositionProvider} provider the provider
+     *        to use to retrieve other domain objects
+     * @memberof module:openmct
+     * @augments EventEmitter
+     */
+    function CompositionCollection(domainObject, provider) {
+        EventEmitter.call(this);
+        this.domainObject = domainObject;
+        this.provider = provider;
+        if (this.provider.on) {
+            this.provider.on(
+                this.domainObject,
+                'add',
+                this.onProviderAdd,
+                this
+            );
+            this.provider.on(
+                this.domainObject,
+                'remove',
+                this.onProviderRemove,
+                this
+            );
+        }
+    };
+
+    CompositionCollection.prototype = Object.create(EventEmitter.prototype);
+
+    CompositionCollection.prototype.onProviderAdd = function (child) {
+        this.add(child, true);
+    };
+
+    CompositionCollection.prototype.onProviderRemove = function (child) {
+        this.remove(child, true);
+    };
+
+    /**
+     * Get the index of a domain object within this composition. If the
+     * domain object is not contained here, -1 will be returned.
+     *
+     * A call to [load]{@link module:openmct.CompositionCollection#load}
+     * must have resolved before using this method.
+     *
+     * @param {module:openmct.DomainObject} child the domain object for which
+     *        an index should be retrieved
+     * @returns {number} the index of that domain object
+     * @memberof module:openmct.CompositionCollection#
+     * @name indexOf
+     */
+    CompositionCollection.prototype.indexOf = function (child) {
+        return _.findIndex(this._children, function (other) {
+            return objectUtils.equals(child, other);
+        });
+    };
+
+    /**
+     * Get the index of a domain object within this composition.
+     *
+     * A call to [load]{@link module:openmct.CompositionCollection#load}
+     * must have resolved before using this method.
+     *
+     * @param {module:openmct.DomainObject} child the domain object for which
+     *        containment should be checked
+     * @returns {boolean} true if the domain object is contained here
+     * @memberof module:openmct.CompositionCollection#
+     * @name contains
+     */
+    CompositionCollection.prototype.contains = function (child) {
+        return this.indexOf(child) !== -1;
+    };
+
+    /**
+     * Add a domain object to this composition.
+     *
+     * A call to [load]{@link module:openmct.CompositionCollection#load}
+     * must have resolved before using this method.
+     *
+     * @param {module:openmct.DomainObject} child the domain object to add
+     * @param {boolean} skipMutate true if the underlying provider should
+     *        not be updated
+     * @memberof module:openmct.CompositionCollection#
+     * @name add
+     */
+    CompositionCollection.prototype.add = function (child, skipMutate) {
+        if (!this._children) {
+            throw new Error("Must load composition before you can add!");
+        }
+        if (!this.canContain(child)) {
+            throw new Error("This object cannot contain that object.");
+        }
+        if (this.contains(child)) {
+            if (skipMutate) {
+                return; // don't add twice, don't error.
+            }
+            throw new Error("Unable to add child: already in composition");
+        }
+        this._children.push(child);
+        this.emit('add', child);
+        if (!skipMutate) {
+            // add after we have added.
+            this.provider.add(this.domainObject, child);
+        }
+    };
+
+    /**
+     * Load the domain objects in this composition.
+     *
+     * @returns {Promise.<Array.<module:openmct.DomainObject>>} a promise for
+     *          the domain objects in this composition
+     * @memberof {module:openmct.CompositionCollection#}
+     * @name load
+     */
+    CompositionCollection.prototype.load = function () {
+        return this.provider.load(this.domainObject)
+            .then(function (children) {
+                this._children = [];
+                children.map(function (c) {
+                    this.add(c, true);
+                }, this);
+                this.emit('load');
+                return this._children.slice();
+            }.bind(this));
+    };
+
+    /**
+     * Remove a domain object from this composition.
+     *
+     * A call to [load]{@link module:openmct.CompositionCollection#load}
+     * must have resolved before using this method.
+     *
+     * @param {module:openmct.DomainObject} child the domain object to remove
+     * @param {boolean} skipMutate true if the underlying provider should
+     *        not be updated
+     * @memberof module:openmct.CompositionCollection#
+     * @name remove
+     */
+    CompositionCollection.prototype.remove = function (child, skipMutate) {
+        if (!this.contains(child)) {
+            if (skipMutate) {
+                return;
+            }
+            throw new Error("Unable to remove child: not found in composition");
+        }
+        var index = this.indexOf(child);
+        var removed = this._children.splice(index, 1)[0];
+        this.emit('remove', index, child);
+        if (!skipMutate) {
+            // trigger removal after we have internally removed it.
+            this.provider.remove(this.domainObject, removed);
+        }
+    };
+
+    CompositionCollection.prototype.canContain = function (domainObject) {
+        return this.provider.canContain(this.domainObject, domainObject);
+    };
+
+    /**
+     * Stop using this composition collection. This will release any resources
+     * associated with this collection.
+     * @name destroy
+     * @memberof module:openmct.CompositionCollection
+     */
+    CompositionCollection.prototype.destroy = function () {
+        if (this.provider.off) {
+            this.provider.off(
+                this.domainObject,
+                'add',
+                this.onProviderAdd,
+                this
+            );
+            this.provider.off(
+                this.domainObject,
+                'remove',
+                this.onProviderRemove,
+                this
+            );
+        }
+    };
+
+    return CompositionCollection
+});

src/api/composition/DefaultCompositionProvider.js

@@ -0,0 +1,133 @@
+define([
+    'lodash',
+    'EventEmitter',
+    '../objects/ObjectAPI',
+    '../objects/object-utils'
+], function (
+    _,
+    EventEmitter,
+    ObjectAPI,
+    objectUtils
+) {
+    /**
+     * A CompositionProvider provides the underlying implementation of
+     * composition-related behavior for certain types of domain object.
+     *
+     * @interface CompositionProvider
+     * @memberof module:openmct
+     * @augments EventEmitter
+     */
+
+    function makeEventName(domainObject, event) {
+        return event + ':' + objectUtils.makeKeyString(domainObject.key);
+    }
+
+    function DefaultCompositionProvider() {
+        EventEmitter.call(this);
+    }
+
+    DefaultCompositionProvider.prototype =
+        Object.create(EventEmitter.prototype);
+
+    /**
+     * Check if this provider should be used to load composition for a
+     * particular domain object.
+     * @param {module:openmct.DomainObject} domainObject the domain object
+     *        to check
+     * @returns {boolean} true if this provider can provide
+     *          composition for a given domain object
+     * @memberof module:openmct.CompositionProvider#
+     * @method appliesTo
+     */
+    DefaultCompositionProvider.prototype.appliesTo = function (domainObject) {
+        return !!domainObject.composition;
+    };
+
+    /**
+     * Load any domain objects contained in the composition of this domain
+     * object.
+     * @param {module:openmct.DomainObjcet} domainObject the domain object
+     *        for which to load composition
+     * @returns {Promise.<Array.<module:openmct.DomainObject>>} a promise for
+     *          the domain objects in this composition
+     * @memberof module:openmct.CompositionProvider#
+     * @method load
+     */
+    DefaultCompositionProvider.prototype.load = function (domainObject) {
+        return Promise.all(domainObject.composition.map(ObjectAPI.get));
+    };
+
+    DefaultCompositionProvider.prototype.on = function (
+        domainObject,
+        event,
+        listener,
+        context
+    ) {
+        // these can likely be passed through to the mutation service instead
+        // of using an eventemitter.
+        this.addListener(
+            makeEventName(domainObject, event),
+            listener,
+            context
+        );
+    };
+
+    DefaultCompositionProvider.prototype.off = function (
+        domainObject,
+        event,
+        listener,
+        context
+    ) {
+        // these can likely be passed through to the mutation service instead
+        // of using an eventemitter.
+        this.removeListener(
+            makeEventName(domainObject, event),
+            listener,
+            context
+        );
+    };
+
+
+    DefaultCompositionProvider.prototype.canContain = function (domainObject, child) {
+        return true;
+    };
+
+    /**
+     * Remove a domain object from another domain object's composition.
+     *
+     * This method is optional; if not present, adding to a domain object's
+     * composition using this provider will be disallowed.
+     *
+     * @param {module:openmct.DomainObject} domainObject the domain object
+     *        which should have its composition modified
+     * @param {module:openmct.DomainObject} child the domain object to remove
+     * @memberof module:openmct.CompositionProvider#
+     * @method remove
+     */
+    DefaultCompositionProvider.prototype.remove = function (domainObject, child) {
+        // TODO: this needs to be synchronized via mutation
+        var index = domainObject.composition.indexOf(child);
+        domainObject.composition.splice(index, 1);
+        this.emit(makeEventName(domainObject, 'remove'), child);
+    };
+
+    /**
+     * Add a domain object to another domain object's composition.
+     *
+     * This method is optional; if not present, adding to a domain object's
+     * composition using this provider will be disallowed.
+     *
+     * @param {module:openmct.DomainObject} domainObject the domain object
+     *        which should have its composition modified
+     * @param {module:openmct.DomainObject} child the domain object to add
+     * @memberof module:openmct.CompositionProvider#
+     * @method add
+     */
+    DefaultCompositionProvider.prototype.add = function (domainObject, child) {
+        // TODO: this needs to be synchronized via mutation
+        domainObject.composition.push(child.key);
+        this.emit(makeEventName(domainObject, 'add'), child);
+    };
+
+    return DefaultCompositionProvider;
+});

src/api/composition/README.md

@@ -0,0 +1,37 @@
+# Composition API - Overview
+
+The composition API is straightforward:
+
+MCT.composition(object) -- returns a `CompositionCollection` if the object has 
+composition, returns undefined if it doesn't.
+
+## CompositionCollection
+
+Has three events:
+* `load`: when the collection has completed loading.
+* `add`: when a new object has been added to the collection.
+* `remove` when an object has been removed from the collection.
+
+Has three methods:
+
+`Collection.load()` -- returns a promise that is fulfilled when the composition 
+    has loaded.
+`Collection.add(object)` -- add a domain object to the composition.
+`Collection.remove(object)` -- remove the object from the composition.
+
+## Composition providers
+composition providers are anything that meets the following interface:
+
+* `provider.appliesTo(domainObject)` -> return true if this provider can provide 
+    composition for a given domain object.
+* `provider.add(domainObject, childObject)` -> adds object 
+* `provider.remove(domainObject, childObject)` -> immediately removes objects
+* `provider.load(domainObject)` -> returns promise for array of children
+
+TODO: need to figure out how to make the provider event listeners invisible to the provider.
+
+There is a default composition provider which handles loading composition for 
+any object with a `composition` property.  If you want specialized composition 
+loading behavior, implement your own composition provider and register it with
+
+`MCT.composition.addProvider(myProvider)`

src/api/objects/LegacyObjectAPIInterceptor.js

@@ -0,0 +1,109 @@
+define([
+    './object-utils',
+    './ObjectAPI',
+    './objectEventEmitter'
+], function (
+    utils,
+    ObjectAPI,
+    objectEventEmitter
+) {
+    function ObjectServiceProvider(objectService, instantiate, topic) {
+        this.objectService = objectService;
+        this.instantiate = instantiate;
+
+        this.generalTopic = topic('mutation');
+        this.bridgeEventBuses();
+    }
+
+    /**
+     * Bridges old and new style mutation events to provide compatibility between the two APIs
+     * @private
+     */
+    ObjectServiceProvider.prototype.bridgeEventBuses = function () {
+        var removeGeneralTopicListener;
+
+        var handleMutation = function (newStyleObject) {
+            var keyString = utils.makeKeyString(newStyleObject.key);
+            var oldStyleObject = this.instantiate(utils.toOldFormat(newStyleObject), keyString);
+
+            // Don't trigger self
+            removeGeneralTopicListener();
+
+            oldStyleObject.getCapability('mutation').mutate(function () {
+                return utils.toOldFormat(newStyleObject);
+            });
+
+            removeGeneralTopicListener = this.generalTopic.listen(handleLegacyMutation);
+        }.bind(this);
+
+        var handleLegacyMutation = function (legacyObject){
+            var newStyleObject = utils.toNewFormat(legacyObject.getModel(), legacyObject.getId());
+
+            //Don't trigger self
+            objectEventEmitter.off('mutation', handleMutation);
+            objectEventEmitter.emit(newStyleObject.key.identifier + ":*", newStyleObject);
+            objectEventEmitter.on('mutation', handleMutation);
+        }.bind(this);
+
+        objectEventEmitter.on('mutation', handleMutation);
+        removeGeneralTopicListener = this.generalTopic.listen(handleLegacyMutation);
+    };
+
+    ObjectServiceProvider.prototype.save = function (object) {
+        var key = object.key,
+            keyString = utils.makeKeyString(key),
+            newObject = this.instantiate(utils.toOldFormat(object), keyString);
+
+        return object.getCapability('persistence')
+                .persist()
+                .then(function () {
+                    return utils.toNewFormat(object, key);
+                });
+    };
+
+    ObjectServiceProvider.prototype.delete = function (object) {
+        // TODO!
+    };
+
+    ObjectServiceProvider.prototype.get = function (key) {
+        var keyString = utils.makeKeyString(key);
+        return this.objectService.getObjects([keyString])
+            .then(function (results) {
+                var model = results[keyString].getModel();
+                return utils.toNewFormat(model, key);
+            });
+    };
+
+    // Injects new object API as a decorator so that it hijacks all requests.
+    // Object providers implemented on new API should just work, old API should just work, many things may break.
+    function LegacyObjectAPIInterceptor(ROOTS, instantiate, topic, objectService) {
+        this.getObjects = function (keys) {
+            var results = {},
+                promises = keys.map(function (keyString) {
+                    var key = utils.parseKeyString(keyString);
+                    return ObjectAPI.get(key)
+                        .then(function (object) {
+                            object = utils.toOldFormat(object)
+                            results[keyString] = instantiate(object, keyString);
+                        });
+                });
+
+            return Promise.all(promises)
+                .then(function () {
+                    return results;
+                });
+        };
+
+        ObjectAPI._supersecretSetFallbackProvider(
+            new ObjectServiceProvider(objectService, instantiate, topic)
+        );
+
+        ROOTS.forEach(function (r) {
+            ObjectAPI.addRoot(utils.parseKeyString(r.id));
+        });
+
+        return this;
+    }
+
+    return LegacyObjectAPIInterceptor;
+});

src/api/objects/MutableObject.js

@@ -0,0 +1,68 @@
+define([
+    'lodash',
+    './objectEventEmitter'
+], function (
+    _,
+    objectEventEmitter
+) {
+    var ANY_OBJECT_EVENT = "mutation";
+
+    /**
+     * The MutableObject wraps a DomainObject and provides getters and
+     * setters for
+     * @param eventEmitter
+     * @param object
+     * @interface MutableObject
+     */
+    function MutableObject(object) {
+        this.object = object;
+        this.unlisteners = [];
+    }
+
+    function qualifiedEventName(object, eventName) {
+        return [object.key.identifier, eventName].join(':');
+    }
+
+    MutableObject.prototype.stopListening = function () {
+        this.unlisteners.forEach(function (unlisten) {
+            unlisten();
+        })
+    };
+
+    /**
+     * Observe changes to this domain object.
+     * @param {string} path the property to observe
+     * @param {Function} callback a callback to invoke when new values for
+     *        this property are observed
+     * @method on
+     * @memberof module:openmct.MutableObject#
+     */
+    MutableObject.prototype.on = function(path, callback) {
+        var fullPath = qualifiedEventName(this.object, path);
+        objectEventEmitter.on(fullPath, callback);
+        this.unlisteners.push(objectEventEmitter.off.bind(objectEventEmitter, fullPath, callback));
+    };
+
+    /**
+     * Modify this domain object.
+     * @param {string} path the property to modify
+     * @param {*} value the new value for this property
+     * @method set
+     * @memberof module:openmct.MutableObject#
+     */
+    MutableObject.prototype.set = function (path, value) {
+
+        _.set(this.object, path, value);
+        _.set(this.object, 'modified', Date.now());
+
+        //Emit event specific to property
+        objectEventEmitter.emit(qualifiedEventName(this.object, path), value);
+        //Emit wildcare event
+        objectEventEmitter.emit(qualifiedEventName(this.object, '*'), this.object);
+
+        //Emit a general "any object" event
+        objectEventEmitter.emit(ANY_OBJECT_EVENT, this.object);
+    };
+
+    return MutableObject;
+});

src/api/objects/MutableObjectSpec.js

@@ -0,0 +1,110 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+define(['./MutableObject'], function (MutableObject) {
+    describe('Mutable Domain Objects', function () {
+        var domainObject,
+            mutableObject,
+            eventEmitter,
+            arrayProperty,
+            objectProperty,
+            identifier;
+
+        beforeEach(function () {
+            identifier = 'objectId';
+            arrayProperty = [
+                'First array element',
+                'Second array element',
+                'Third array element'
+            ];
+            objectProperty = {
+                prop1: 'val1',
+                prop2: 'val2',
+                prop3: {
+                    propA: 'valA',
+                    propB: 'valB',
+                    propC: []
+                }
+            };
+            domainObject = {
+                    key: {
+                        identifier: identifier
+                    },
+                    stringProperty: 'stringValue',
+                    objectProperty: objectProperty,
+                    arrayProperty: arrayProperty
+                };
+            eventEmitter = jasmine.createSpyObj('eventEmitter', [
+                'emit'
+            ]);
+            mutableObject = new MutableObject(eventEmitter, domainObject);
+        });
+
+        it('Supports getting and setting of object properties', function () {
+            expect(domainObject.stringProperty).toEqual('stringValue');
+            mutableObject.set('stringProperty', 'updated');
+            expect(domainObject.stringProperty).toEqual('updated');
+
+            var newArrayProperty = [];
+            expect(domainObject.arrayProperty).toEqual(arrayProperty);
+            mutableObject.set('arrayProperty', newArrayProperty);
+            expect(domainObject.arrayProperty).toEqual(newArrayProperty);
+
+            var newObjectProperty = [];
+            expect(domainObject.objectProperty).toEqual(objectProperty);
+            mutableObject.set('objectProperty', newObjectProperty);
+            expect(domainObject.objectProperty).toEqual(newObjectProperty);
+        });
+
+        it('Supports getting and setting of nested properties', function () {
+            expect(domainObject.objectProperty).toEqual(objectProperty);
+            expect(domainObject.objectProperty.prop1).toEqual(objectProperty.prop1);
+            expect(domainObject.objectProperty.prop3.propA).toEqual(objectProperty.prop3.propA);
+
+            mutableObject.set('objectProperty.prop1', 'new-prop-1');
+            expect(domainObject.objectProperty.prop1).toEqual('new-prop-1');
+
+            mutableObject.set('objectProperty.prop3.propA', 'new-prop-A');
+            expect(domainObject.objectProperty.prop3.propA).toEqual('new-prop-A');
+
+            mutableObject.set('arrayProperty.1', 'New Second Array Element');
+            expect(arrayProperty[1]).toEqual('New Second Array Element');
+        });
+
+        it('Fires events when properties change', function () {
+            var newString = 'updated'
+            mutableObject.set('stringProperty', newString);
+            expect(eventEmitter.emit).toHaveBeenCalledWith([identifier, 'stringProperty'].join(':'), newString);
+
+            var newArray = [];
+            mutableObject.set('arrayProperty', newArray);
+            expect(eventEmitter.emit).toHaveBeenCalledWith([identifier, 'arrayProperty'].join(':'), newArray);
+
+        });
+
+        it('Fires wildcard event when any property changes', function () {
+            var newString = 'updated'
+            mutableObject.set('objectProperty.prop3.propA', newString);
+            expect(eventEmitter.emit).toHaveBeenCalledWith([identifier, '*'].join(':'), domainObject);
+        });
+    });
+});

src/api/objects/ObjectAPI.js

@@ -0,0 +1,208 @@
+define([
+    'lodash',
+    './object-utils',
+    './MutableObject'
+], function (
+    _,
+    utils,
+    MutableObject
+) {
+
+    /**
+        Object API.  Intercepts the existing object API while also exposing
+        A new Object API.
+    */
+
+    /**
+     * Utilities for loading, saving, and manipulating domain objects.
+     * @interface ObjectAPI
+     * @memberof module:openmct
+     * @implements {module:openmct.ObjectProvider}
+     */
+    var Objects = {},
+        ROOT_REGISTRY = [],
+        PROVIDER_REGISTRY = {},
+        FALLBACK_PROVIDER;
+
+    Objects._supersecretSetFallbackProvider = function (p) {
+        FALLBACK_PROVIDER = p;
+    };
+
+    // Root provider is hardcoded in; can't be skipped.
+    var RootProvider = {
+        'get': function () {
+            return Promise.resolve({
+                name: 'The root object',
+                type: 'root',
+                composition: ROOT_REGISTRY
+            });
+        }
+    };
+
+    // Retrieve the provider for a given key.
+    function getProvider(key) {
+        if (key.identifier === 'ROOT') {
+            return RootProvider;
+        }
+        return PROVIDER_REGISTRY[key.namespace] || FALLBACK_PROVIDER;
+    }
+
+    /**
+     * Register a new object provider for a particular namespace.
+     *
+     * @param {string} namespace the namespace for which to provide objects
+     * @param {module:openmct.ObjectProvider} provider the provider which
+     *        will handle loading domain objects from this namespace
+     * @memberof {module:openmct.ObjectAPI#}
+     * @name addProvider
+     */
+    Objects.addProvider = function (namespace, provider) {
+        PROVIDER_REGISTRY[namespace] = provider;
+    };
+
+    /**
+     * Provides the ability to read, write, and delete domain objects.
+     *
+     * When registering a new object provider, all methods on this interface
+     * are optional.
+     *
+     * @interface ObjectProvider
+     * @memberof module:openmct
+     */
+
+    /**
+     * Save this domain object in its current state.
+     *
+     * @method save
+     * @memberof module:openmct.ObjectProvider#
+     * @param {module:openmct.DomainObject} domainObject the domain object to
+     *        save
+     * @returns {Promise} a promise which will resolve when the domain object
+     *          has been saved, or be rejected if it cannot be saved
+     */
+
+    /**
+     * Delete this domain object.
+     *
+     * @method delete
+     * @memberof module:openmct.ObjectProvider#
+     * @param {module:openmct.DomainObject} domainObject the domain object to
+     *        delete
+     * @returns {Promise} a promise which will resolve when the domain object
+     *          has been deleted, or be rejected if it cannot be deleted
+     */
+
+    /**
+     * Get a domain object.
+     *
+     * @method get
+     * @memberof module:openmct.ObjectProvider#
+     * @param {string} key the key for the domain object to load
+     * @returns {Promise} a promise which will resolve when the domain object
+     *          has been saved, or be rejected if it cannot be saved
+     */
+
+    [
+        'save',
+        'delete',
+        'get'
+    ].forEach(function (method) {
+        Objects[method] = function () {
+            var key = arguments[0],
+                provider = getProvider(key);
+
+            if (!provider) {
+                throw new Error('No Provider Matched');
+            }
+
+            if (!provider[method]) {
+                throw new Error('Provider does not support [' + method + '].');
+            }
+
+            return provider[method].apply(provider, arguments);
+        };
+    });
+
+    /**
+     * Add a root-level object.
+     * @param {module:openmct.DomainObject} domainObject the root-level object
+     *        to add.
+     * @method addRoot
+     * @memberof module:openmct.ObjectAPI#
+     */
+    Objects.addRoot = function (key) {
+        ROOT_REGISTRY.unshift(key);
+    };
+
+    /**
+     * Remove a root-level object.
+     * @param {module:openmct.ObjectAPI~Identifier} id the identifier of the
+     *        root-level object to remove.
+     * @method removeRoot
+     * @memberof module:openmct.ObjectAPI#
+     */
+    Objects.removeRoot = function (key) {
+        ROOT_REGISTRY = ROOT_REGISTRY.filter(function (k) {
+            return (
+                k.identifier !== key.identifier ||
+                k.namespace !== key.namespace
+            );
+        });
+    };
+
+    /**
+     * Modify a domain object.
+     * @param {module:openmct.DomainObject} object the object to mutate
+     * @param {string} path the property to modify
+     * @param {*} value the new value for this property
+     * @method mutate
+     * @memberof module:openmct.ObjectAPI#
+     */
+
+    /**
+     * Observe changes to a domain object.
+     * @param {module:openmct.DomainObject} object the object to observe
+     * @param {string} path the property to observe
+     * @param {Function} callback a callback to invoke when new values for
+     *        this property are observed
+     * @method observe
+     * @memberof module:openmct.ObjectAPI#
+     */
+
+    /**
+     * Uniquely identifies a domain object.
+     *
+     * @typedef Identifier
+     * @memberof module:openmct.ObjectAPI~
+     * @property {string} namespace the namespace to/from which this domain
+     *           object should be loaded/stored.
+     * @property {string} key a unique identifier for the domain object
+     *           within that namespace
+     */
+
+    /**
+     * A domain object is an entity of relevance to a user's workflow, that
+     * should appear as a distinct and meaningful object within the user
+     * interface. Examples of domain objects are folders, telemetry sensors,
+     * and so forth.
+     *
+     * A few common properties are defined for domain objects. Beyond these,
+     * individual types of domain objects may add more as they see fit.
+     *
+     * @property {module:openmct.ObjectAPI~Identifier} identifier a key/namespace pair which
+     *           uniquely identifies this domain object
+     * @property {string} type the type of domain object
+     * @property {string} name the human-readable name for this domain object
+     * @property {string} [creator] the user name of the creator of this domain
+     *           object
+     * @property {number} [modified] the time, in milliseconds since the UNIX
+     *           epoch, at which this domain object was last modified
+     * @property {module:openmct.ObjectAPI~Identifier[]} [composition] if
+     *           present, this will be used by the default composition provider
+     *           to load domain objects
+     * @typedef DomainObject
+     * @memberof module:openmct
+     */
+
+    return Objects;
+});

src/api/objects/README.md

@@ -0,0 +1,54 @@
+# Object API - Overview
+
+The object API provides methods for fetching domain objects.
+
+# Keys
+Keys are a composite identifier that is used to create and persist objects.  Ex:
+```javascript
+{
+    namespace: 'elastic',
+    identifier: 'myIdentifier'
+}
+```
+
+In old MCT days, we called this an "id", and we encoded it in a single string.  
+The above key would encode into the identifier, `elastic:myIdentifier`.
+
+When interacting with the API you will be dealing with key objects.
+
+## Roots
+
+"Roots" are objects that Open MCT will load at run time and form the basic entry point for users.  You can register new root objects by calling the 
+
+# Configuring the Object API
+
+The following methods should be used before calling run.  They allow you to 
+configure the persistence space of MCT.
+
+* `MCT.objects.addRoot(key)` -- add a "ROOT" to Open MCT by specifying it's key.
+* `MCT.objects.removeRoot(key)` -- Remove a "ROOT" from Open MCT by key.
+* `MCT.objects.addProvider(namespace, provider)` -- register an object provider for a specific namespace.  See below for documentation on the provider interface.
+
+# defining providers
+
+# Using the object API
+
+The object API provides methods for getting, saving, and deleting objects.  Plugin developers may not frequently need to interact with this API, as they should receive instances of the objects as needed.
+
+* MCT.objects.get(key) -> returns promise for an object
+* MCT.objects.save(object) -> returns promise that is resolved when object has been saved
+* MCT.objects.delete(object) -> returns promise that is resolved when object has been deleted
+
+## Configuration Example: Adding a groot
+
+See the tutorial in [object-provider.html](object-provider.html).
+
+### Making a custom provider:
+
+All methods on the provider interface are optional. 
+
+* `provider.get(key)` -> returns promise for a domain object.
+* `provider.save(domainObject)` -> returns promise that is fulfilled when object has been saved.
+* `provider.delete(domainObject)` -> returns promise that is fulfilled when object has been deleted.
+
+

src/api/objects/bundle.js

@@ -0,0 +1,50 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define*/
+
+define([
+    './LegacyObjectAPIInterceptor',
+    'legacyRegistry'
+], function (
+    LegacyObjectAPIInterceptor,
+    legacyRegistry
+) {
+    legacyRegistry.register('src/api/objects', {
+        name: 'Object API',
+        description: 'The public Objects API',
+        extensions: {
+            components: [
+                {
+                    provides: "objectService",
+                    type: "decorator",
+                    priority: "mandatory",
+                    implementation: LegacyObjectAPIInterceptor,
+                    depends: [
+                        "roots[]",
+                        "instantiate",
+                        "topic"
+                    ]
+                }
+            ]
+        }
+    });
+});

src/api/objects/object-utils.js

@@ -0,0 +1,88 @@
+define([
+
+], function (
+
+) {
+
+    // take a key string and turn it into a key object
+    // 'scratch:root' ==> {namespace: 'scratch', identifier: 'root'}
+    var parseKeyString = function (key) {
+        if (typeof key === 'object') {
+            return key;
+        }
+        var namespace = '',
+            identifier = key;
+        for (var i = 0, escaped = false, len=key.length; i < key.length; i++) {
+            if (escaped) {
+                escaped = false;
+            } else {
+                if (key[i] === "\\") {
+                    escaped = true;
+                    continue;
+                }
+                if (key[i] === ":") {
+                    // namespace = key.slice(0, i);
+                    identifier = key.slice(i + 1);
+                    break;
+                }
+            }
+            namespace += key[i];
+        }
+
+        if (key === namespace) {
+            namespace = '';
+        }
+
+        return {
+            namespace: namespace,
+            identifier: identifier
+        };
+    };
+
+    // take a key and turn it into a key string
+    // {namespace: 'scratch', identifier: 'root'} ==> 'scratch:root'
+    var makeKeyString = function (key) {
+        if (typeof key === 'string') {
+            return key;
+        }
+        if (!key.namespace) {
+            return key.identifier;
+        }
+        return [
+            key.namespace.replace(':', '\\:'),
+            key.identifier.replace(':', '\\:')
+        ].join(':');
+    };
+
+    // Converts composition to use key strings instead of keys
+    var toOldFormat = function (model) {
+        model = JSON.parse(JSON.stringify(model));
+        delete model.key;
+        if (model.composition) {
+            model.composition = model.composition.map(makeKeyString);
+        }
+        return model;
+    };
+
+    // converts composition to use keys instead of key strings
+    var toNewFormat = function (model, key) {
+        model = JSON.parse(JSON.stringify(model));
+        model.key = key;
+        if (model.composition) {
+            model.composition = model.composition.map(parseKeyString);
+        }
+        return model;
+    };
+
+    var equals = function (a, b) {
+        return makeKeyString(a.key) === makeKeyString(b.key);
+    };
+
+    return {
+        toOldFormat: toOldFormat,
+        toNewFormat: toNewFormat,
+        makeKeyString: makeKeyString,
+        parseKeyString: parseKeyString,
+        equals: equals
+    };
+});

src/api/objects/objectEventEmitter.js

@@ -0,0 +1,10 @@
+define([
+    "EventEmitter"
+], function (
+    EventEmitter
+) {
+    /**
+     * Provides a singleton event bus for sharing between objects.
+     */
+    return new EventEmitter();
+});

src/api/telemetry/README.md

@@ -0,0 +1,71 @@
+# Telemetry API - Overview
+
+The Telemetry API provides basic methods for retrieving historical and realtime telemetry data, retrieving telemetry metadata, and registering additional telemetry providers.   
+
+The Telemetry API also provides a set of helpers built upon these basics-- TelemetryFormatters help you format telemetry values for display purposes, LimitEvaluators help you display evaluate and display alarm states, while TelemetryCollections provide a method for seamlessly combining historical and realtime data, while supporting more advanced client side filtering and interactivity.
+
+
+## Getting Telemetry Data
+
+
+### `MCT.telemetry.request(domainObject, options)`
+
+Request historical telemetry for a domain object.  Options allows you to specify filters (start, end, etc.), sort order, and strategies for retrieving telemetry (aggregation, latest available, etc.).
+
+Returns a `Promise` for an array of telemetry values.
+
+### `MCT.telemetry.subscribe(domainObject, callback, options)`
+
+Subscribe to realtime telemetry for a specific domain object.  callback will be called whenever data is received from a realtime provider.  Options allows you to specify ???
+
+## Understanding Telemetry
+
+### `MCT.telemetry.getMetadata(domainObject)`
+
+Retrieve telemetry metadata for a domain object.  Telemetry metadata helps you understand the sort of telemetry data a domain object can provide-- for instances, the possible enumerations or states, the units, and more.
+
+### `MCT.telemetry.Formatter`
+
+Telemetry formatters help you format telemetry values for display.  Under the covers, they use telemetry metadata to interpret your telemetry data, and then they use the format API to format that data for display.
+
+
+### `MCT.telemetry.LimitEvaluator`
+
+Limit Evaluators help you evaluate limit and alarm status of individual telemetry datums for display purposes without having to interact directly with the Limit API.  
+
+## Adding new telemetry sources
+
+### `MCT.telemetry.registerProvider(telemetryProvider)`
+
+Register a telemetry provider with the telemetry service.  This allows you to connect alternative telemetry sources to   For more information, see the `MCT.telemetry.BaseProvider`
+
+### `MCT.telemetry.BaseProvider`
+
+The base provider is a great starting point for developers who would like to implement their own telemetry provider.  At the same time, you can implement your own telemetry provider as long as it meets the TelemetryProvider (see other docs).
+
+## Other tools
+
+### `MCT.telemetry.TelemetryCollection`
+
+The TelemetryCollection is a useful tool for building advanced displays.  It helps you seamlessly handle both historical and realtime telemetry data, while making it easier to deal with large data sets and interactive displays that need to frequently requery data.
+
+
+
+# API Reference (TODO)
+
+* Telemetry Metadata
+* Request Options
+    -- start
+    -- end
+    -- sort
+    -- ???
+    -- strategies -- specify which strategies you want.  an array provides for fallback strategies without needing decoration.  Design fallbacks into API.
+
+### `MCT.telemetry.request(domainObject, options)`
+### `MCT.telemetry.subscribe(domainObject, callback, options)`
+### `MCT.telemetry.getMetadata(domainObject)`
+### `MCT.telemetry.Formatter`
+### `MCT.telemetry.LimitEvaluator`
+### `MCT.telemetry.registerProvider(telemetryProvider)`
+### `MCT.telemetry.BaseProvider`
+### `MCT.telemetry.TelemetryCollection`

src/api/telemetry/TelemetryAPI.js

@@ -0,0 +1,422 @@
+/*global define,window,console,MCT*/
+
+/**
+
+var key = '114ced6c-deb7-4169-ae71-68c571665514';
+MCT.objects.getObject([key])
+    .then(function (results) {
+        console.log('got results');
+        return results[key];
+    })
+    .then(function (domainObject) {
+        console.log('got object');
+        MCT.telemetry.subscribe(domainObject, function (datum) {
+            console.log('gotData!', datum);
+        });
+    });
+});
+
+
+*/
+
+define([
+    'lodash',
+    'eventemitter2'
+], function (
+    _,
+    EventEmitter
+) {
+
+    // format map is a placeholder until we figure out format service.
+    var FORMAT_MAP = {
+        generic: function (range) {
+            return function (datum) {
+                return datum[range.key];
+            };
+        },
+        enum: function (range) {
+            var enumMap = _.indexBy(range.enumerations, 'value');
+            return function (datum) {
+                try {
+                    return enumMap[datum[range.valueKey]].text;
+                } catch (e) {
+                    return datum[range.valueKey];
+                }
+            };
+        }
+    };
+
+    FORMAT_MAP.number =
+        FORMAT_MAP.float =
+        FORMAT_MAP.integer =
+        FORMAT_MAP.ascii =
+        FORMAT_MAP.generic;
+
+    /**
+     * Describes a property which would be found in a datum of telemetry
+     * associated with a particular domain object.
+     *
+     * @typedef TelemetryProperty
+     * @memberof module:openmct.TelemetryAPI~
+     * @property {string} key the name of the property in the datum which
+     *           contains this telemetry value
+     * @property {string} name the human-readable name for this property
+     * @property {string} [units] the units associated with this property
+     * @property {boolean} [temporal] true if this property is a timestamp, or
+     *           may be otherwise used to order telemetry in a time-like
+     *           fashion; default is false
+     * @property {boolean} [numeric] true if the values for this property
+     *           can be interpreted plainly as numbers; default is true
+     * @property {boolean} [enumerated] true if this property may have only
+     *           certain specific values; default is false
+     * @property {string} [values] for enumerated states, an ordered list
+     *           of possible values
+     */
+
+    /**
+     * Describes and bounds requests for telemetry data.
+     *
+     * @typedef TelemetryRequest
+     * @memberof module:openmct.TelemetryAPI~
+     * @property {string} sort the key of the property to sort by. This may
+     *           be prefixed with a "+" or a "-" sign to sort in ascending
+     *           or descending order respectively. If no prefix is present,
+     *           ascending order will be used.
+     * @property {*} start the lower bound for values of the sorting property
+     * @property {*} end the upper bound for values of the sorting property
+     * @property {string[]} strategies symbolic identifiers for strategies
+     *           (such as `minmax`) which may be recognized by providers;
+     *           these will be tried in order until an appropriate provider
+     *           is found
+     */
+
+    /**
+     * An interface for retrieving telemetry data associated with a domain
+     * object.
+     *
+     * @interface TelemetryAPI
+     * @augments module:openmct.TelemetryAPI~TelemetryProvider
+     * @memberof module:openmct
+     */
+    function TelemetryAPI(
+        formatService
+    ) {
+
+        var FORMATTER_CACHE = new WeakMap(),
+            EVALUATOR_CACHE = new WeakMap();
+
+        function testAPI() {
+            var key = '114ced6c-deb7-4169-ae71-68c571665514';
+            window.MCT.objects.getObjects([key])
+                .then(function (results) {
+                    console.log('got results');
+                    return results[key];
+                })
+                .then(function (domainObject) {
+                    var formatter = new MCT.telemetry.Formatter(domainObject);
+                    console.log('got object');
+                    window.MCT.telemetry.subscribe(domainObject, function (datum) {
+                        var formattedValues = {};
+                        Object.keys(datum).forEach(function (key) {
+                            formattedValues[key] = formatter.format(datum, key);
+                        });
+                        console.log(
+                            'datum:',
+                            datum,
+                            'formatted:',
+                            formattedValues
+                        );
+                    });
+                });
+        }
+
+        function getFormatter(range) {
+            if (FORMAT_MAP[range.type]) {
+                return FORMAT_MAP[range.type](range);
+            }
+            try {
+                var format = formatService.getFormat(range.type).format.bind(
+                        formatService.getFormat(range.type)
+                    ),
+                    formatter = function (datum) {
+                        return format(datum[range.key]);
+                    };
+                return formatter;
+            } catch (e) {
+                console.log('could not retrieve format', range, e, e.message);
+                return FORMAT_MAP.generic(range);
+            }
+        }
+
+        /**
+         * A TelemetryFormatter converts telemetry values for purposes of
+         * display as text.
+         *
+         * @interface TelemetryFormatter
+         * @memberof module:openmct.TelemetryAPI~
+         */
+        function TelemetryFormatter(domainObject) {
+            this.metadata = domainObject.getCapability('telemetry').getMetadata();
+            this.formats = {};
+            var ranges = this.metadata.ranges.concat(this.metadata.domains);
+
+            ranges.forEach(function (range) {
+                this.formats[range.key] = getFormatter(range);
+            }, this);
+        }
+
+        /**
+         * Retrieve the 'key' from the datum and format it accordingly to
+         * telemetry metadata in domain object.
+         *
+         * @method format
+         * @memberof module:openmct.TelemetryAPI~TelemetryFormatter#
+         */
+        TelemetryFormatter.prototype.format = function (datum, key) {
+            return this.formats[key](datum);
+        };
+
+        /**
+         * A LimitEvaluator may be used to detect when telemetry values
+         * have exceeded nominal conditions.
+         *
+         * @interface LimitEvaluator
+         * @memberof module:openmct.TelemetryAPI~
+         */
+        function LimitEvaluator(domainObject) {
+            this.domainObject = domainObject;
+            this.evaluator = domainObject.getCapability('limit');
+            if (!this.evaluator) {
+                this.evalute = function () {
+                    return '';
+                }
+            }
+        }
+
+        /** TODO: Do we need a telemetry parser, or do we assume telemetry
+        is numeric by default? */
+
+        /**
+         * Check if any limits have been exceeded.
+         *
+         * @param {*} datum a telemetry datum
+         * @param {string} key the name of the property to be evaluated
+         *        for limit violation
+         * @returns {string[]} an array of limit exceedance states
+         * @memberof module:openmct.TelemetryAPI~TelemetryFormatter#
+         */
+        LimitEvaluator.prototype.evaluate = function (datum, key) {
+            return this.evaluator.evaluate(datum, key);
+        };
+
+        /** Basic telemetry collection, needs more magic. **/
+        function TelemetryCollection(domainObject) {
+            this.domainObject = domainObject;
+            this.data = [];
+        }
+
+        _.extend(TelemetryCollection.prototype, EventEmitter.prototype);
+
+        TelemetryCollection.prototype.request = function (options) {
+            request(this.domainObject, options).then(function (data) {
+                data.forEach(function (datum) {
+                    this.addDatum(datum);
+                }, this);
+            }.bind(this));
+        };
+
+        TelemetryCollection.prototype.addDatum = function (datum) {
+            this.data.push(datum);
+            this.emit('add', datum);
+        };
+
+        TelemetryCollection.prototype.subscribe = function (options) {
+            if (this.unsubscribe) {
+                this.unsubscribe();
+                delete this.unsubscribe;
+            }
+
+            this.unsubscribe = subscribe(
+                this.domainObject,
+                function (telemetrySeries) {
+                    telemetrySeries.getData().forEach(this.addDatum, this);
+                }.bind(this),
+                options
+            );
+        };
+
+        function registerProvider(provider, strategy) {
+            // Not yet implemented.
+            console.log('registering provider', provider);
+        }
+
+        function registerEvaluator(evaluator) {
+            // not yet implemented.
+            console.log('registering evaluator', evaluator);
+        }
+
+        function request(domainObject, options) {
+            return domainObject.getCapability('telemetry')
+                .requestData(options)
+                .then(function (telemetrySeries) {
+                    return telemetrySeries.getData();
+                });
+        }
+
+        function subscribe(domainObject, callback, options) {
+            return domainObject.getCapability('telemetry')
+                .subscribe(function (series) {
+                    series.getData().forEach(callback);
+                }, options);
+        }
+
+        /**
+         * Provides telemetry data. To connect to new data sources, new
+         * TelemetryProvider implementations should be
+         * [registered]{@link module:openmct.TelemetryAPI#addProvider}.
+         *
+         * @interface TelemetryProvider
+         * @memberof module:openmct.TelemetryAPI~
+         */
+
+
+        var Telemetry = {
+            /**
+             * Check if this provider can supply telemetry data associated with
+             * this domain object.
+             *
+             * @method canProvideTelemetry
+             * @param {module:openmct.DomainObject} domainObject the object for
+             *        which telemetry would be provided
+             * @returns {boolean} true if telemetry can be provided
+             * @memberof module:openmct.TelemetryAPI~TelemetryProvider#
+             */
+            canProvideTelemetry: function () {
+
+            },
+
+            /**
+             * Register a telemetry provider with the telemetry service. This
+             * allows you to connect alternative telemetry sources.
+             * @method addProvider
+             * @memberof module:openmct.TelemetryAPI#
+             * @param {module:openmct.TelemetryAPI~TelemetryProvider} provider the new
+             *        telemetry provider
+             * @param {string} [strategy] the request strategy supported by
+             *        this provider. If omitted, this will be used as a
+             *        default provider (when no strategy is requested or no
+             *        matching strategy is found.)
+             */
+            addProvider: registerProvider,
+
+            /**
+             * Request historical telemetry for a domain object.
+             * The `options` argument allows you to specify filters
+             * (start, end, etc.), sort order, and strategies for retrieving
+             * telemetry (aggregation, latest available, etc.).
+             *
+             * @method request
+             * @memberof module:openmct.TelemetryAPI~TelemetryProvider#
+             * @param {module:openmct.DomainObject} domainObject the object
+             *        which has associated telemetry
+             * @param {module:openmct.TelemetryAPI~TelemetryRequest} options
+             *        options for this historical request
+             * @returns {Promise.<object[]>} a promise for an array of
+             *          telemetry data
+             */
+            request: request,
+
+            /**
+             * Subscribe to realtime telemetry for a specific domain object.
+             * The callback will be called whenever data is received from a
+             * realtime provider.
+             *
+             * @method subscribe
+             * @memberof module:openmct.TelemetryAPI~TelemetryProvider#
+             * @param {module:openmct.DomainObject} domainObject the object
+             *        which has associated telemetry
+             * @param {Function} callback the callback to invoke with new data, as
+             *        it becomes available
+             * @param {module:openmct.TelemetryAPI~TelemetryRequest} options
+             *        options for this request
+             * @returns {Function} a function which may be called to terminate
+             *          the subscription
+             */
+            subscribe: subscribe,
+
+            /**
+             * Get a list of all telemetry properties defined for this
+             * domain object.
+             *
+             * @param {module:openmct.DomainObject} domainObject the domain
+             *        object for which to request telemetry
+             * @returns {module:openmct.TelemetryAPI~TelemetryProperty[]}
+             *          telemetry metadata
+             * @method properties
+             * @memberof module:openmct.TelemetryAPI~TelemetryProvider#
+             */
+            properties: function (domainObject) {
+                return domainObject.getCapability('telemetry').getMetadata();
+            },
+
+            /**
+             * Telemetry formatters help you format telemetry values for
+             * display. Under the covers, they use telemetry metadata to
+             * interpret your telemetry data, and then they use the format API
+             * to format that data for display.
+             *
+             * This method is optional.
+             * If a provider does not implement this method, it is presumed
+             * that all telemetry associated with this domain object can
+             * be formatted correctly by string coercion.
+             *
+             * @param {module:openmct.DomainObject} domainObject the domain
+             *        object for which to format telemetry
+             * @returns {module:openmct.TelemetryAPI~TelemetryFormatter}
+             * @method formatter
+             * @memberof module:openmct.TelemetryAPI~TelemetryProvider#
+             */
+            Formatter: function (domainObject) {
+                if (!FORMATTER_CACHE.has(domainObject)) {
+                    FORMATTER_CACHE.set(
+                        domainObject,
+                        new TelemetryFormatter(domainObject)
+                    );
+                }
+                return FORMATTER_CACHE.get(domainObject);
+            },
+
+            /**
+             * Get a limit evaluator for this domain object.
+             * Limit Evaluators help you evaluate limit and alarm status of individual telemetry datums for display purposes without having to interact directly with the Limit API.
+             *
+             * This method is optional.
+             * If a provider does not implement this method, it is presumed
+             * that no limits are defined for this domain object's telemetry.
+             *
+             * @param {module:openmct.DomainObject} domainObject the domain
+             *        object for which to evaluate limits
+             * @returns {module:openmct.TelemetryAPI~LimitEvaluator}
+             * @method limitEvaluator
+             * @memberof module:openmct.TelemetryAPI~TelemetryProvider#
+             */
+            LimitEvaluator: function (domainObject) {
+                if (!EVALUATOR_CACHE.has(domainObject)) {
+                    EVALUATOR_CACHE.set(
+                        domainObject,
+                        new LimitEvaluator(domainObject)
+                    );
+                }
+                return EVALUATOR_CACHE.get(domainObject);
+            }
+        };
+
+        window.MCT = window.MCT || {};
+        window.MCT.telemetry = Telemetry;
+        window.testAPI = testAPI;
+
+        return Telemetry;
+    }
+
+    return TelemetryAPI;
+});

src/api/telemetry/bundle.js

@@ -0,0 +1,46 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define*/
+
+define([
+    './TelemetryAPI',
+    'legacyRegistry'
+], function (
+    TelemetryAPI,
+    legacyRegistry
+) {
+    legacyRegistry.register('api/telemetry-api', {
+        name: 'Telemetry API',
+        description: 'The public Telemetry API',
+        extensions: {
+            runs: [
+                {
+                    key: "TelemetryAPI",
+                    implementation: TelemetryAPI,
+                    depends: [
+                        'formatService'
+                    ]
+                }
+            ]
+        }
+    });
+});

src/api/types/TypeRegistry.js

@@ -0,0 +1,30 @@
+
+define([], function () {
+
+    /**
+     * A TypeRegistry maintains the definitions for different types
+     * that domain objects may have.
+     * @interface TypeRegistry
+     * @memberof module:openmct
+     */
+    function TypeRegistry() {
+
+    }
+
+    /**
+     * Register a new type of view.
+     *
+     * @param {string} typeKey a string identifier for this type
+     * @param {module:openmct.Type} type the type to add
+     * @method addProvider
+     * @memberof module:openmct.TypeRegistry#
+     */
+    TypeRegistry.prototype.addType = function (typeKey, type) {
+
+    };
+
+
+    return TypeRegistry;
+});
+
+

src/api/ui/Dialog.js

@@ -0,0 +1,78 @@
+define(['text!./dialog.html', 'zepto'], function (dialogTemplate, $) {
+
+    /**
+     * A dialog may be displayed to show blocking content to users.
+     * @param {module:openmct.View} view the view to show in the dialog
+     * @param {string [title] the title for this dialog
+     * @constructor
+     * @memberof module:openmct
+     */
+    function Dialog(view, title) {
+        this.view = view;
+        this.title = title;
+        this.showing = false;
+        this.enabledState = true;
+    }
+
+    /**
+     * Display this dialog.
+     * @returns {Promise} a promise that will be resolved if the user
+     *          chooses "OK", an rejected if the user chooses "cancel"
+     * @method show
+     * @memberof module:openmct.Dialog#
+     */
+    Dialog.prototype.show = function () {
+        if (this.showing) {
+            throw new Error("Dialog already showing.");
+        }
+
+        var $body = $('body');
+        var $dialog = $(dialogTemplate);
+        var $contents = $dialog.find('.contents .editor');
+        var $close = $dialog.find('.close');
+
+        var $ok = $dialog.find('.ok');
+        var $cancel = $dialog.find('.cancel');
+
+        if (this.title) {
+            $dialog.find('.title').text(this.title);
+        }
+
+        $body.append($dialog);
+        this.view.show($contents[0]);
+        this.$dialog = $dialog;
+        this.$ok = $ok;
+        this.showing = true;
+
+        [$ok, $cancel, $close].forEach(function ($button) {
+            $button.on('click', this.hide.bind(this));
+        }.bind(this));
+
+        return new Promise(function (resolve, reject) {
+            $ok.on('click', resolve);
+            $cancel.on('click', reject);
+            $close.on('click', reject);
+        });
+    };
+
+    Dialog.prototype.hide = function () {
+        if (!this.showing) {
+            return;
+        }
+        this.$dialog.remove();
+        this.view.destroy();
+        this.showing = false;
+    };
+
+    Dialog.prototype.enabled = function (state) {
+        if (state !== undefined) {
+            this.enabledState = state;
+            if (this.showing) {
+                this.$ok.toggleClass('disabled', !state);
+            }
+        }
+        return this.enabledState;
+    };
+
+    return Dialog;
+});

src/api/ui/GestureAPI.js

@@ -0,0 +1,28 @@
+define([], function () {
+    /**
+     * Allows support for common user actions to be attached to views.
+     * @interface GestureAPI
+     * @memberof module:openmct
+     */
+    function GestureAPI() {
+
+    }
+
+    /**
+     * Designate an HTML element as selectable, and associated with a
+     * particular object.
+     *
+     * @param {HTMLElement} htmlElement the element to make selectable
+     * @param {*} item the object which should become selected when this
+     *        element is clicked.
+     * @returns {Function} a function to remove selectability from this
+     *          HTML element.
+     * @method selectable
+     * @memberof module:openmct.GestureAPI#
+     */
+    GestureAPI.prototype.selectable = function (htmlElement, item) {
+
+    };
+
+    return GestureAPI;
+});

src/api/ui/ViewRegistry.js

@@ -0,0 +1,26 @@
+define([], function () {
+
+    /**
+     * A ViewRegistry maintains the definitions for different kinds of views
+     * that may occur in different places in the user interface.
+     * @interface ViewRegistry
+     * @memberof module:openmct
+     */
+    function ViewRegistry() {
+
+    }
+
+    /**
+     * Register a new type of view.
+     *
+     * @param {module:openmct.ViewProvider} provider the provider for this view
+     * @method addProvider
+     * @memberof module:openmct.ViewRegistry#
+     */
+    ViewRegistry.prototype.addProvider = function (provider) {
+
+    };
+
+
+    return ViewRegistry;
+});

src/api/ui/dialog.html

@@ -0,0 +1,21 @@
+<div class="abs overlay">
+    <div class="abs blocker"></div>
+    <div class="abs holder">
+        <a class="clk-icon icon ui-symbol close">x</a>
+        <div class="abs contents">
+            <div class="abs top-bar">
+                <div class="title"></div>
+                <div class="hint"></div>
+            </div>
+            <div class='abs editor'>
+            </div>
+            <div class="abs bottom-bar">
+                <a class='s-btn major ok'>OK</a>
+                <a class='s-btn cancel'>Cancel</a>
+            </div>
+        </div>
+    </div>
+</div>
+
+
+

src/defaultRegistry.js

@@ -0,0 +1,113 @@
+define([
+    'legacyRegistry',
+
+    '../src/adapter/bundle',
+    '../src/api/objects/bundle',
+
+    '../example/builtins/bundle',
+    '../example/composite/bundle',
+    '../example/eventGenerator/bundle',
+    '../example/export/bundle',
+    '../example/extensions/bundle',
+    '../example/forms/bundle',
+    '../example/generator/bundle',
+    '../example/identity/bundle',
+    '../example/imagery/bundle',
+    '../example/mobile/bundle',
+    '../example/msl/bundle',
+    '../example/notifications/bundle',
+    '../example/persistence/bundle',
+    '../example/plotOptions/bundle',
+    '../example/policy/bundle',
+    '../example/profiling/bundle',
+    '../example/scratchpad/bundle',
+    '../example/taxonomy/bundle',
+    '../example/worker/bundle',
+
+    '../platform/commonUI/about/bundle',
+    '../platform/commonUI/browse/bundle',
+    '../platform/commonUI/dialog/bundle',
+    '../platform/commonUI/edit/bundle',
+    '../platform/commonUI/formats/bundle',
+    '../platform/commonUI/general/bundle',
+    '../platform/commonUI/inspect/bundle',
+    '../platform/commonUI/mobile/bundle',
+    '../platform/commonUI/notification/bundle',
+    '../platform/commonUI/regions/bundle',
+    '../platform/commonUI/themes/espresso/bundle',
+    '../platform/commonUI/themes/snow/bundle',
+    '../platform/containment/bundle',
+    '../platform/core/bundle',
+    '../platform/entanglement/bundle',
+    '../platform/execution/bundle',
+    '../platform/exporters/bundle',
+    '../platform/features/clock/bundle',
+    '../platform/features/conductor/bundle',
+    '../platform/features/imagery/bundle',
+    '../platform/features/layout/bundle',
+    '../platform/features/pages/bundle',
+    '../platform/features/plot/bundle',
+    '../platform/features/static-markup/bundle',
+    '../platform/features/table/bundle',
+    '../platform/features/timeline/bundle',
+    '../platform/forms/bundle',
+    '../platform/framework/bundle',
+    '../platform/framework/src/load/Bundle',
+    '../platform/identity/bundle',
+    '../platform/persistence/aggregator/bundle',
+    '../platform/persistence/couch/bundle',
+    '../platform/persistence/elastic/bundle',
+    '../platform/persistence/local/bundle',
+    '../platform/persistence/queue/bundle',
+    '../platform/policy/bundle',
+    '../platform/representation/bundle',
+    '../platform/search/bundle',
+    '../platform/status/bundle',
+    '../platform/telemetry/bundle',
+], function (legacyRegistry) {
+
+    var DEFAULTS = [
+        'src/adapter',
+        'src/api/objects',
+        'platform/framework',
+        'platform/core',
+        'platform/representation',
+        'platform/commonUI/about',
+        'platform/commonUI/browse',
+        'platform/commonUI/edit',
+        'platform/commonUI/dialog',
+        'platform/commonUI/formats',
+        'platform/commonUI/general',
+        'platform/commonUI/inspect',
+        'platform/commonUI/mobile',
+        'platform/commonUI/themes/espresso',
+        'platform/commonUI/notification',
+        'platform/containment',
+        'platform/execution',
+        'platform/exporters',
+        'platform/telemetry',
+        'platform/features/clock',
+        'platform/features/imagery',
+        'platform/features/layout',
+        'platform/features/pages',
+        'platform/features/plot',
+        'platform/features/timeline',
+        'platform/features/table',
+        'platform/forms',
+        'platform/identity',
+        'platform/persistence/aggregator',
+        'platform/persistence/local',
+        'platform/persistence/queue',
+        'platform/policy',
+        'platform/entanglement',
+        'platform/search',
+        'platform/status',
+        'platform/commonUI/regions'
+    ];
+
+    DEFAULTS.forEach(function (bundlePath) {
+        legacyRegistry.enable(bundlePath);
+    });
+
+    return legacyRegistry;
+});

src/end.frag

@@ -0,0 +1,3 @@
+
+   return require('main'); 
+}));

src/openmct.js

@@ -0,0 +1,16 @@
+define(['./MCT', './api/Type'], function (MCT, Type) {
+    /**
+     * Open MCT is an extensible web application for building mission
+     * control user interfaces. This module is itself an instance of
+     * [MCT]{@link module:openmct.MCT}, which provides an interface for
+     * configuring and executing the application.
+     *
+     * @exports openmct
+     */
+    var openmct = new MCT();
+
+    openmct.MCT = MCT;
+    openmct.Type = Type;
+
+    return openmct;
+});

src/start.frag

@@ -0,0 +1,9 @@
+(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        define([], factory);
+    } else if (typeof exports === 'object') {
+        module.exports = factory();
+    } else {
+        root.MCT = factory();
+    }
+}(this, function() {

test-main.js

@@ -48,13 +48,15 @@ requirejs.config({
         "angular-route": "bower_components/angular-route/angular-route.min",
         "csv": "bower_components/comma-separated-values/csv.min",
         "es6-promise": "bower_components/es6-promise/promise.min",
+        "EventEmitter": "bower_components/eventemitter3/index",
         "moment": "bower_components/moment/moment",
         "moment-duration-format": "bower_components/moment-duration-format/lib/moment-duration-format",
         "saveAs": "bower_components/FileSaver.js/FileSaver.min",
         "screenfull": "bower_components/screenfull/dist/screenfull.min",
         "text": "bower_components/text/text",
         "uuid": "bower_components/node-uuid/uuid",
-        "zepto": "bower_components/zepto/zepto.min"
+        "zepto": "bower_components/zepto/zepto.min",
+        "lodash": "bower_components/lodash/lodash"
     },
 
     "shim": {
@@ -64,6 +66,9 @@ requirejs.config({
         "angular-route": {
             "deps": [ "angular" ]
         },
+        "EventEmitter": {
+            "exports": "EventEmitter"
+        },
         "moment-duration-format": {
             "deps": [ "moment" ]
         },
@@ -72,6 +77,9 @@ requirejs.config({
         },
         "zepto": {
             "exports": "Zepto"
+        },
+        "lodash": {
+            "exports": "lodash"
         }
     },
 

tutorial-server/app.js

@@ -0,0 +1,127 @@
+/*global require,process,console*/
+
+var CONFIG = {
+    port: 8081,
+    dictionary: "dictionary.json",
+    interval: 1000
+};
+
+(function () {
+    "use strict";
+
+    var WebSocketServer = require('ws').Server,
+        fs = require('fs'),
+        wss = new WebSocketServer({ port: CONFIG.port }),
+        dictionary = JSON.parse(fs.readFileSync(CONFIG.dictionary, "utf8")),
+        spacecraft = {
+            "prop.fuel": 77,
+            "prop.thrusters": "OFF",
+            "comms.recd": 0,
+            "comms.sent": 0,
+            "pwr.temp": 245,
+            "pwr.c": 8.15,
+            "pwr.v": 30
+        },
+        histories = {},
+        listeners = [];
+
+    function updateSpacecraft() {
+        spacecraft["prop.fuel"] = Math.max(
+            0,
+            spacecraft["prop.fuel"] -
+            (spacecraft["prop.thrusters"] === "ON" ? 0.5 : 0)
+        );
+        spacecraft["pwr.temp"] = spacecraft["pwr.temp"] * 0.985
+        + Math.random() * 0.25 + Math.sin(Date.now());
+        spacecraft["pwr.c"] = spacecraft["pwr.c"] * 0.985;
+        spacecraft["pwr.v"] = 30 + Math.pow(Math.random(), 3);
+    }
+
+    function generateTelemetry() {
+        var timestamp = Date.now(), sent = 0;
+        Object.keys(spacecraft).forEach(function (id) {
+            var state = { timestamp: timestamp, value: spacecraft[id] };
+            histories[id] = histories[id] || []; // Initialize
+            histories[id].push(state);
+            spacecraft["comms.sent"] += JSON.stringify(state).length;
+        });
+        listeners.forEach(function (listener) {
+            listener();
+        });
+    }
+
+    function update() {
+        updateSpacecraft();
+        generateTelemetry();
+    }
+
+    function handleConnection(ws) {
+        var subscriptions = {}, // Active subscriptions for this connection
+            handlers = {        // Handlers for specific requests
+                dictionary: function () {
+                    ws.send(JSON.stringify({
+                        type: "dictionary",
+                        value: dictionary
+                    }));
+                },
+                subscribe: function (id) {
+                    subscriptions[id] = true;
+                },
+                unsubscribe: function (id) {
+                    delete subscriptions[id];
+                },
+                history: function (id) {
+                    ws.send(JSON.stringify({
+                        type: "history",
+                        id: id,
+                        value: histories[id]
+                    }));
+                }
+            };
+
+        function notifySubscribers() {
+            Object.keys(subscriptions).forEach(function (id) {
+                var history = histories[id];
+                if (history) {
+                    ws.send(JSON.stringify({
+                        type: "data",
+                        id: id,
+                        value: history[history.length - 1]
+                    }));
+                }
+            });
+        }
+
+        // Listen for requests
+        ws.on('message', function (message) {
+            var parts = message.split(' '),
+                handler = handlers[parts[0]];
+            if (handler) {
+                handler.apply(handlers, parts.slice(1));
+            }
+        });
+
+        // Stop sending telemetry updates for this connection when closed
+        ws.on('close', function () {
+            listeners = listeners.filter(function (listener) {
+                return listener !== notifySubscribers;
+            });
+        });
+
+        // Notify subscribers when telemetry is updated
+        listeners.push(notifySubscribers);
+    }
+
+    update();
+    setInterval(update, CONFIG.interval);
+
+    wss.on('connection', handleConnection);
+
+    console.log("Example spacecraft running on port ");
+    console.log("Press Enter to toggle thruster state.");
+    process.stdin.on('data', function (data) {
+        spacecraft['prop.thrusters'] =
+            (spacecraft['prop.thrusters'] === "OFF") ? "ON" : "OFF";
+        console.log("Thrusters " + spacecraft["prop.thrusters"]);
+    });
+}());

tutorial-server/dictionary.json

@@ -0,0 +1,66 @@
+{
+    "name": "Example Spacecraft",
+    "identifier": "sc",
+    "subsystems": [
+        {
+            "name": "Propulsion",
+            "identifier": "prop",
+            "measurements": [
+                {
+                    "name": "Fuel",
+                    "identifier": "prop.fuel",
+                    "units": "kilograms",
+                    "type": "float"
+                },
+                {
+                    "name": "Thrusters",
+                    "identifier": "prop.thrusters",
+                    "units": "None",
+                    "type": "string"
+                }
+            ]
+        },
+        {
+            "name": "Communications",
+            "identifier": "comms",
+            "measurements": [
+                {
+                    "name": "Received",
+                    "identifier": "comms.recd",
+                    "units": "bytes",
+                    "type": "integer"
+                },
+                {
+                    "name": "Sent",
+                    "identifier": "comms.sent",
+                    "units": "bytes",
+                    "type": "integer"
+                }
+            ]
+        },
+        {
+            "name": "Power",
+            "identifier": "pwr",
+            "measurements": [
+                {
+                    "name": "Generator Temperature",
+                    "identifier": "pwr.temp",
+                    "units": "\u0080C",
+                    "type": "float"
+                },
+                {
+                    "name": "Generator Current",
+                    "identifier": "pwr.c",
+                    "units": "A",
+                    "type": "float"
+                },
+                {
+                    "name": "Generator Voltage",
+                    "identifier": "pwr.v",
+                    "units": "V",
+                    "type": "float"
+                }
+            ]
+        }
+    ]
+}

tutorials/bargraph/bundle.js

@@ -0,0 +1,66 @@
+define([
+    'legacyRegistry',
+    './src/controllers/BarGraphController'
+], function (
+    legacyRegistry,
+    BarGraphController
+    ) {
+    legacyRegistry.register("tutorials/bargraph", {
+        "name": "Bar Graph",
+        "description": "Provides the Bar Graph view of telemetry elements.",
+        "extensions": {
+            "views": [
+                {
+                    "name": "Bar Graph",
+                    "key": "example.bargraph",
+                    "glyph": "H",
+                    "templateUrl": "templates/bargraph.html",
+                    "needs": [ "telemetry" ],
+                    "delegation": true,
+                    "editable": true,
+                    "toolbar": {
+                        "sections": [
+                            {
+                                "items": [
+                                    {
+                                        "name": "Low",
+                                        "property": "low",
+                                        "required": true,
+                                        "control": "textfield",
+                                        "size": 4
+                                    },
+                                    {
+                                        "name": "Middle",
+                                        "property": "middle",
+                                        "required": true,
+                                        "control": "textfield",
+                                        "size": 4
+                                    },
+                                    {
+                                        "name": "High",
+                                        "property": "high",
+                                        "required": true,
+                                        "control": "textfield",
+                                        "size": 4
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                }
+            ],
+            "stylesheets": [
+                {
+                    "stylesheetUrl": "css/bargraph.css"
+                }
+            ],
+            "controllers": [
+                {
+                    "key": "BarGraphController",
+                    "implementation": BarGraphController,
+                    "depends": [ "$scope", "telemetryHandler" ]
+                }
+            ]
+        }
+    });
+});

tutorials/bargraph/res/templates/bargraph.html

@@ -0,0 +1,35 @@
+<div class="example-bargraph" ng-controller="BarGraphController">
+    <div class="example-tick-labels">
+        <div ng-repeat="value in [low, middle, high] track by $index"
+             class="example-tick-label"
+             style="bottom: {{ toPercent(value) }}%">
+            {{value}}
+        </div>
+    </div>
+
+    <div class="example-graph-area">
+        <div ng-repeat="telemetryObject in telemetryObjects"
+             style="left: {{barWidth * $index}}%; width: {{barWidth}}%"
+             class="example-bar-holder">
+            <div class="example-bar"
+                 ng-style="{
+                     bottom: getBottom(telemetryObject) + '%',
+                     top: getTop(telemetryObject) + '%'
+                 }">
+            </div>
+        </div>
+        <div style="bottom: {{ toPercent(middle) }}%"
+             class="example-graph-tick">
+        </div>
+    </div>
+
+    <div class="example-bar-labels">
+        <div ng-repeat="telemetryObject in telemetryObjects"
+             style="left: {{barWidth * $index}}%; width: {{barWidth}}%"
+             class="example-bar-holder example-label">
+            <mct-representation key="'label'"
+                                mct-object="telemetryObject">
+            </mct-representation>
+        </div>
+    </div>
+</div>

tutorials/bargraph/src/controllers/BarGraphController.js

@@ -0,0 +1,75 @@
+define(function () {
+    function BarGraphController($scope, telemetryHandler) {
+        var handle;
+
+        // Expose configuration constants directly in scope
+        function exposeConfiguration() {
+            $scope.low = $scope.configuration.low;
+            $scope.middle = $scope.configuration.middle;
+            $scope.high = $scope.configuration.high;
+        }
+
+        // Populate a default value in the configuration
+        function setDefault(key, value) {
+            if ($scope.configuration[key] === undefined) {
+                $scope.configuration[key] = value;
+            }
+        }
+
+        // Getter-setter for configuration properties (for view proxy)
+        function getterSetter(property) {
+            return function (value) {
+                value = parseFloat(value);
+                if (!isNaN(value)) {
+                    $scope.configuration[property] = value;
+                    exposeConfiguration();
+                }
+                return $scope.configuration[property];
+            };
+        }
+
+        // Add min/max defaults
+        setDefault('low', -1);
+        setDefault('middle', 0);
+        setDefault('high', 1);
+        exposeConfiguration($scope.configuration);
+
+        // Expose view configuration options
+        if ($scope.selection) {
+            $scope.selection.proxy({
+                low: getterSetter('low'),
+                middle: getterSetter('middle'),
+                high: getterSetter('high')
+            });
+        }
+
+        // Convert value to a percent between 0-100
+        $scope.toPercent = function (value) {
+            var pct = 100 * (value - $scope.low) /
+                ($scope.high - $scope.low);
+            return Math.min(100, Math.max(0, pct));
+        };
+
+        // Get bottom and top (as percentages) for current value
+        $scope.getBottom = function (telemetryObject) {
+            var value = handle.getRangeValue(telemetryObject);
+            return $scope.toPercent(Math.min($scope.middle, value));
+        };
+        $scope.getTop = function (telemetryObject) {
+            var value = handle.getRangeValue(telemetryObject);
+            return 100 - $scope.toPercent(Math.max($scope.middle, value));
+        };
+
+        // Use the telemetryHandler to get telemetry objects here
+        handle = telemetryHandler.handle($scope.domainObject, function () {
+            $scope.telemetryObjects = handle.getTelemetryObjects();
+            $scope.barWidth =
+                100 / Math.max(($scope.telemetryObjects).length, 1);
+        });
+
+        // Release subscriptions when scope is destroyed
+        $scope.$on('$destroy', handle.unsubscribe);
+    }
+
+    return BarGraphController;
+});

tutorials/telemetry/bundle.js

@@ -0,0 +1,90 @@
+define([
+    'legacyRegistry',
+    './src/ExampleTelemetryServerAdapter',
+    './src/ExampleTelemetryInitializer',
+    './src/ExampleTelemetryModelProvider'
+], function (
+    legacyRegistry,
+    ExampleTelemetryServerAdapter,
+    ExampleTelemetryInitializer,
+    ExampleTelemetryModelProvider
+) {
+    legacyRegistry.register("tutorials/telemetry", {
+        "name": "Example Telemetry Adapter",
+        "extensions": {
+            "types": [
+                {
+                    "name": "Spacecraft",
+                    "key": "example.spacecraft",
+                    "glyph": "o"
+                },
+                {
+                    "name": "Subsystem",
+                    "key": "example.subsystem",
+                    "glyph": "o",
+                    "model": { "composition": [] }
+                },
+                {
+                    "name": "Measurement",
+                    "key": "example.measurement",
+                    "glyph": "T",
+                    "model": { "telemetry": {} },
+                    "telemetry": {
+                        "source": "example.source",
+                        "domains": [
+                            {
+                                "name": "Time",
+                                "key": "timestamp"
+                            }
+                        ]
+                    }
+                }
+            ],
+            "roots": [
+                {
+                    "id": "example:sc",
+                    "priority": "preferred",
+                    "model": {
+                        "type": "example.spacecraft",
+                        "name": "My Spacecraft",
+                        "composition": []
+                    }
+                }
+            ],
+            "services": [
+                {
+                    "key": "example.adapter",
+                    "implementation": "ExampleTelemetryServerAdapter.js",
+                    "depends": [ "$q", "EXAMPLE_WS_URL" ]
+                }
+            ],
+            "constants": [
+                {
+                    "key": "EXAMPLE_WS_URL",
+                    "priority": "fallback",
+                    "value": "ws://localhost:8081"
+                }
+            ],
+            "runs": [
+                {
+                    "implementation": "ExampleTelemetryInitializer.js",
+                    "depends": [ "example.adapter", "objectService" ]
+                }
+            ],
+            "components": [
+                {
+                    "provides": "modelService",
+                    "type": "provider",
+                    "implementation": "ExampleTelemetryModelProvider.js",
+                    "depends": [ "example.adapter", "$q" ]
+                },
+                {
+                    "provides": "telemetryService",
+                    "type": "provider",
+                    "implementation": "ExampleTelemetryProvider.js",
+                    "depends": [ "example.adapter", "$q" ]
+                }
+            ]
+        }
+    });
+});

tutorials/telemetry/src/ExampleTelemetryInitializer.js

@@ -0,0 +1,47 @@
+define(
+    function () {
+        "use strict";
+
+        var TAXONOMY_ID = "example:sc",
+            PREFIX = "example_tlm:";
+
+        function ExampleTelemetryInitializer(adapter, objectService) {
+            // Generate a domain object identifier for a dictionary element
+            function makeId(element) {
+                return PREFIX + element.identifier;
+            }
+
+            // When the dictionary is available, add all subsystems
+            // to the composition of My Spacecraft
+            function initializeTaxonomy(dictionary) {
+                // Get the top-level container for dictionary objects
+                // from a group of domain objects.
+                function getTaxonomyObject(domainObjects) {
+                    return domainObjects[TAXONOMY_ID];
+                }
+
+                // Populate
+                function populateModel(taxonomyObject) {
+                    return taxonomyObject.useCapability(
+                        "mutation",
+                        function (model) {
+                            model.name =
+                                dictionary.name;
+                            model.composition =
+                                dictionary.subsystems.map(makeId);
+                        }
+                    );
+                }
+
+                // Look up My Spacecraft, and populate it accordingly.
+                objectService.getObjects([TAXONOMY_ID])
+                    .then(getTaxonomyObject)
+                    .then(populateModel);
+            }
+
+            adapter.dictionary().then(initializeTaxonomy);
+        }
+
+        return ExampleTelemetryInitializer;
+    }
+);

tutorials/telemetry/src/ExampleTelemetryModelProvider.js

@@ -0,0 +1,78 @@
+define(
+    function () {
+        "use strict";
+
+        var PREFIX = "example_tlm:",
+            FORMAT_MAPPINGS = {
+                float: "number",
+                integer: "number",
+                string: "string"
+            };
+
+        function ExampleTelemetryModelProvider(adapter, $q) {
+            var modelPromise, empty = $q.when({});
+
+            // Check if this model is in our dictionary (by prefix)
+            function isRelevant(id) {
+                return id.indexOf(PREFIX) === 0;
+            }
+
+            // Build a domain object identifier by adding a prefix
+            function makeId(element) {
+                return PREFIX + element.identifier;
+            }
+
+            // Create domain object models from this dictionary
+            function buildTaxonomy(dictionary) {
+                var models = {};
+
+                // Create & store a domain object model for a measurement
+                function addMeasurement(measurement) {
+                    var format = FORMAT_MAPPINGS[measurement.type];
+                    models[makeId(measurement)] = {
+                        type: "example.measurement",
+                        name: measurement.name,
+                        telemetry: {
+                            key: measurement.identifier,
+                            ranges: [{
+                                key: "value",
+                                name: "Value",
+                                units: measurement.units,
+                                format: format
+                            }]
+                        }
+                    };
+                }
+
+                // Create & store a domain object model for a subsystem
+                function addSubsystem(subsystem) {
+                    var measurements =
+                        (subsystem.measurements || []);
+                    models[makeId(subsystem)] = {
+                        type: "example.subsystem",
+                        name: subsystem.name,
+                        composition: measurements.map(makeId)
+                    };
+                    measurements.forEach(addMeasurement);
+                }
+
+                (dictionary.subsystems || []).forEach(addSubsystem);
+
+                return models;
+            }
+
+            // Begin generating models once the dictionary is available
+            modelPromise = adapter.dictionary().then(buildTaxonomy);
+
+            return {
+                getModels: function (ids) {
+                    // Return models for the dictionary only when they
+                    // are relevant to the request.
+                    return ids.some(isRelevant) ? modelPromise : empty;
+                }
+            };
+        }
+
+        return ExampleTelemetryModelProvider;
+    }
+);

tutorials/telemetry/src/ExampleTelemetryProvider.js

@@ -0,0 +1,80 @@
+define(
+    ['./ExampleTelemetrySeries'],
+    function (ExampleTelemetrySeries) {
+        "use strict";
+
+        var SOURCE = "example.source";
+
+        function ExampleTelemetryProvider(adapter, $q) {
+            var subscribers = {};
+
+            // Used to filter out requests for telemetry
+            // from some other source
+            function matchesSource(request) {
+                return (request.source === SOURCE);
+            }
+
+            // Listen for data, notify subscribers
+            adapter.listen(function (message) {
+                var packaged = {};
+                packaged[SOURCE] = {};
+                packaged[SOURCE][message.id] =
+                    new ExampleTelemetrySeries([message.value]);
+                (subscribers[message.id] || []).forEach(function (cb) {
+                    cb(packaged);
+                });
+            });
+
+            return {
+                requestTelemetry: function (requests) {
+                    var packaged = {},
+                        relevantReqs = requests.filter(matchesSource);
+
+                    // Package historical telemetry that has been received
+                    function addToPackage(history) {
+                        packaged[SOURCE][history.id] =
+                            new ExampleTelemetrySeries(history.value);
+                    }
+
+                    // Retrieve telemetry for a specific measurement
+                    function handleRequest(request) {
+                        var key = request.key;
+                        return adapter.history(key).then(addToPackage);
+                    }
+
+                    packaged[SOURCE] = {};
+                    return $q.all(relevantReqs.map(handleRequest))
+                        .then(function () { return packaged; });
+                },
+                subscribe: function (callback, requests) {
+                    var keys = requests.filter(matchesSource)
+                        .map(function (req) { return req.key; });
+
+                    function notCallback(cb) {
+                        return cb !== callback;
+                    }
+
+                    function unsubscribe(key) {
+                        subscribers[key] =
+                            (subscribers[key] || []).filter(notCallback);
+                        if (subscribers[key].length < 1) {
+                            adapter.unsubscribe(key);
+                        }
+                    }
+
+                    keys.forEach(function (key) {
+                        subscribers[key] = subscribers[key] || [];
+                        adapter.subscribe(key);
+                        subscribers[key].push(callback);
+                    });
+
+                    return function () {
+                        keys.forEach(unsubscribe);
+                    };
+                }
+            };
+        }
+
+        return ExampleTelemetryProvider;
+    }
+);

tutorials/telemetry/src/ExampleTelemetrySeries.js

@@ -0,0 +1,23 @@
+/*global define*/
+
+define(
+    function () {
+        "use strict";
+
+        function ExampleTelemetrySeries(data) {
+            return {
+                getPointCount: function () {
+                    return data.length;
+                },
+                getDomainValue: function (index) {
+                    return (data[index] || {}).timestamp;
+                },
+                getRangeValue: function (index) {
+                    return (data[index] || {}).value;
+                }
+            };
+        }
+
+        return ExampleTelemetrySeries;
+    }
+);

tutorials/telemetry/src/ExampleTelemetryServerAdapter.js

@@ -0,0 +1,60 @@
+define(
+    [],
+    function () {
+        "use strict";
+
+        function ExampleTelemetryServerAdapter($q, wsUrl) {
+            var ws = new WebSocket(wsUrl),
+                histories = {},
+                listeners = [],
+                dictionary = $q.defer();
+
+            // Handle an incoming message from the server
+            ws.onmessage = function (event) {
+                var message = JSON.parse(event.data);
+
+                switch (message.type) {
+                case "dictionary":
+                    dictionary.resolve(message.value);
+                    break;
+                case "history":
+                    histories[message.id].resolve(message);
+                    delete histories[message.id];
+                    break;
+                case "data":
+                    listeners.forEach(function (listener) {
+                        listener(message);
+                    });
+                    break;
+                }
+            };
+
+            // Request dictionary once connection is established
+            ws.onopen = function () {
+                ws.send("dictionary");
+            };
+
+            return {
+                dictionary: function () {
+                    return dictionary.promise;
+                },
+                history: function (id) {
+                    histories[id] = histories[id] || $q.defer();
+                    ws.send("history " + id);
+                    return histories[id].promise;
+                },
+                subscribe: function (id) {
+                    ws.send("subscribe " + id);
+                },
+                unsubscribe: function (id) {
+                    ws.send("unsubscribe " + id);
+                },
+                listen: function (callback) {
+                    listeners.push(callback);
+                }
+            };
+        }
+
+        return ExampleTelemetryServerAdapter;
+    }
+);

tutorials/todo/todo-dialog.html

@@ -0,0 +1,3 @@
+<label>Description:
+    <input type="text" class="description">
+</label>

tutorials/todo/todo-task.html

@@ -0,0 +1,5 @@
+<li>
+    <input type="checkbox" class="example-task-checked">
+    <span class="example-task-description">
+    </span>
+</li>

tutorials/todo/todo-toolbar.html

@@ -0,0 +1,9 @@
+<div class="tool-bar btn-bar contents abs">
+    <a class="s-btn labeled example-add">
+        <span class="ui-symbol icon">+</span>
+        <span class="title-label">Add Task</span>
+    </a>
+    <a class="s-btn example-remove">
+        <span class="ui-symbol icon">Z</span>
+    </a>
+</div>

tutorials/todo/todo.css

@@ -0,0 +1,29 @@
+.example-todo div.example-button-group {
+    margin-top: 12px;
+    margin-bottom: 12px;
+}
+
+.example-todo .example-button-group a {
+    padding: 3px;
+    margin: 3px;
+}
+
+.example-todo .example-button-group a.selected {
+    border: 1px gray solid;
+    border-radius: 3px;
+    background: #444;
+}
+
+.example-todo .example-task-completed .example-task-description {
+    text-decoration: line-through;
+    opacity: 0.75;
+}
+
+.example-todo .example-task-description.selected {
+    background: #46A;
+    border-radius: 3px;
+}
+
+.example-todo .example-message {
+    font-style: italic;
+}

tutorials/todo/todo.html

@@ -0,0 +1,14 @@
+<div class="example-todo">
+    <div class="example-button-group">
+        <a class="example-todo-button" data-filter="all">All</a>
+        <a class="example-todo-button" data-filter="incomplete">Incomplete</a>
+        <a class="example-todo-button" data-filter="complete">Complete</a>
+    </div>
+
+    <ul class="example-todo-task-list">
+    </ul>
+
+    <div class="example-no-tasks">
+        There are no tasks to show.
+    </div>
+</div>

tutorials/todo/todo.js

@@ -0,0 +1,273 @@
+define([
+    "text!./todo.html",
+    "text!./todo-task.html",
+    "text!./todo-toolbar.html",
+    "text!./todo-dialog.html",
+    "../../src/api/objects/object-utils",
+    "zepto"
+], function (todoTemplate, taskTemplate, toolbarTemplate, dialogTemplate, utils, $) {
+    /**
+     * @param {mct.MCT} mct
+     */
+    return function todoPlugin(mct) {
+        var todoType = new mct.Type({
+            metadata: {
+                label: "To-Do List",
+                glyph: "2",
+                description: "A list of things that need to be done."
+            },
+            initialize: function (model) {
+                model.tasks = [
+                    { description: "This is a task." }
+                ];
+            },
+            creatable: true
+        });
+
+        function TodoView(domainObject) {
+            this.tasks = domainObject.tasks;
+            this.filterValue = "all";
+
+            this.setTaskStatus = this.setTaskStatus.bind(this);
+            this.selectTask = this.selectTask.bind(this);
+
+<<<<<<< HEAD
+            this.mutableObject = mct.Objects.getMutable(domainObject);
+            this.mutableObject.on('tasks', this.updateTasks.bind(this));
+=======
+            //If anything on object changes, re-render view
+            this.mutableObject.on("*", this.objectChanged);
+        };
+
+        TodoView.prototype.show = function (container) {
+            var self = this;
+            this.destroy();
+
+            self.$els = $(todoTemplate);
+            self.$buttons = {
+                all: self.$els.find('.example-todo-button-all'),
+                incomplete: self.$els.find('.example-todo-button-incomplete'),
+                complete: self.$els.find('.example-todo-button-complete')
+            };
+
+            $(container).empty().append(self.$els);
+>>>>>>> origin/api-tutorials
+
+            this.$el = $(todoTemplate);
+            this.$emptyMessage = this.$el.find('.example-no-tasks');
+            this.$taskList = this.$el.find('.example-todo-task-list');
+            this.$el.on('click', '[data-filter]', this.updateFilter.bind(this));
+            this.$el.on('change', 'li', this.setTaskStatus.bind(this));
+            this.$el.on('click', '.example-task-description', this.selectTask.bind(this));
+
+<<<<<<< HEAD
+            this.updateSelection = this.updateSelection.bind(this);
+            mct.selection.on('change', this.updateSelection);
+        }
+
+        TodoView.prototype.show = function (container) {
+            $(container).empty().append(this.$el);
+            this.render();
+=======
+            self.initialize();
+            self.objectChanged(this.domainObject);
+
+            mct.selection.on('change', self.render);
+>>>>>>> origin/api-tutorials
+        };
+
+        TodoView.prototype.destroy = function () {
+            this.mutableObject.stopListening();
+            mct.selection.off('change', this.updateSelection);
+        };
+
+        TodoView.prototype.updateSelection = function (selection) {
+            if (selection && selection.length) {
+                this.selection = selection[0].index;
+            } else {
+                this.selection = -1;
+            }
+            this.render();
+        };
+
+        TodoView.prototype.updateTasks = function (tasks) {
+            this.tasks = tasks;
+            this.render();
+        };
+
+        TodoView.prototype.updateFilter = function (e) {
+            this.filterValue = $(e.target).data('filter');
+            this.render();
+        };
+
+        TodoView.prototype.setTaskStatus = function (e) {
+            var $checkbox = $(e.target);
+            var taskIndex = $checkbox.data('taskIndex');
+            var completed = !!$checkbox.prop('checked');
+            this.tasks[taskIndex].completed = completed;
+            this.mutableObject.set('tasks[' + taskIndex + '].checked', completed);
+        };
+
+        TodoView.prototype.selectTask = function (e) {
+            var taskIndex = $(e.target).data('taskIndex');
+            mct.selection.clear();
+            mct.selection.select({index: taskIndex});
+        };
+
+        TodoView.prototype.getFilteredTasks = function () {
+            return this.tasks.filter({
+                all: function () {
+                    return true;
+                },
+                incomplete: function (task) {
+                    return !task.completed;
+                },
+                complete: function (task) {
+                    return task.completed;
+                }
+            }[this.filterValue]);
+        };
+
+        TodoView.prototype.render = function () {
+            var filteredTasks = this.getFilteredTasks();
+            this.$emptyMessage.toggle(filteredTasks.length === 0);
+            this.$taskList.empty();
+            filteredTasks
+                .forEach(function (task) {
+                    var $taskEl = $(taskTemplate),
+                        taskIndex = this.tasks.indexOf(task);
+                    $taskEl.find('.example-task-checked')
+                        .prop('checked', task.completed)
+                        .attr('data-task-index', taskIndex);
+                    $taskEl.find('.example-task-description')
+                        .text(task.description)
+                        .toggleClass('selected', taskIndex === this.selection)
+                        .attr('data-task-index', taskIndex);
+
+                    this.$taskList.append($taskEl);
+                }, this);
+        };
+
+        function TodoToolbarView(domainObject) {
+            this.tasks = domainObject.tasks;
+            this.mutableObject = mct.Objects.getMutable(domainObject);
+
+            this.handleSelectionChange = this.handleSelectionChange.bind(this);
+
+            this.mutableObject.on('tasks', this.updateTasks.bind(this));
+            mct.selection.on('change', this.handleSelectionChange);
+            this.$el = $(toolbarTemplate);
+            this.$remove = this.$el.find('.example-remove');
+            this.$el.on('click', '.example-add', this.addTask.bind(this));
+            this.$el.on('click', '.example-remove', this.removeTask.bind(this));
+        }
+
+        TodoToolbarView.prototype.updateTasks = function (tasks) {
+            this.tasks = tasks;
+        };
+
+        TodoToolbarView.prototype.addTask = function () {
+            var $dialog = $(dialogTemplate),
+                view = {
+                    show: function (container) {
+                        $(container).append($dialog);
+                    },
+                    destroy: function () {}
+                };
+
+            mct.dialog(view, "Add a Task").then(function () {
+                var description = $dialog.find('input').val();
+                this.tasks.push({description: description});
+                this.mutableObject.set('tasks', this.tasks);
+            }.bind(this));
+        };
+
+        TodoToolbarView.prototype.removeTask = function () {
+            if (this.selection >= 0) {
+                this.tasks.splice(this.selection, 1);
+                this.mutableObject.set('tasks', this.tasks);
+                mct.selection.clear();
+                this.render();
+            }
+        };
+
+        TodoToolbarView.prototype.show = function (container) {
+            var self = this;
+            this.destroy();
+            this.$els = $(toolbarTemplate);
+            this.render();
+            $(container).append(this.$els);
+        };
+
+        TodoToolbarView.prototype.render = function () {
+            var self = this;
+            var $els = this.$els;
+
+            self.mutableObject = mct.Objects.getMutable(this.domainObject);
+
+            var $add = $els.find('a.example-add');
+            var $remove = $els.find('a.example-remove');
+
+            $add.on('click', function () {
+                var $dialog = $(dialogTemplate),
+                    view = {
+                        show: function (container) {
+                            $(container).append($dialog);
+                        },
+                        destroy: function () {}
+                    };
+
+                new mct.Dialog(view, "Add a Task").show().then(function () {
+                    var description = $dialog.find('input').val();
+                    var tasks = self.mutableObject.get('tasks');
+                    tasks.push({ description: description });
+                    self.mutableObject.set('tasks', tasks);
+                });
+            });
+            $remove.on('click', function () {
+                var index = mct.selection.selected()[0].index;
+                if (index !== undefined) {
+                    var tasks = self.mutableObject.get('tasks').filter(function (t, i) {
+                        return i !== index;
+                    });
+                    self.mutableObject.set("tasks", tasks);
+                    self.mutableObject.set("selected", undefined);
+                    mct.selection.clear();
+                }
+            });
+            self.$remove = $remove;
+            self.handleSelectionChange();
+            mct.selection.on('change', self.handleSelectionChange);
+        };
+
+        TodoToolbarView.prototype.handleSelectionChange = function () {
+            var selected = mct.selection.selected();
+            if (this.$remove) {
+                this.$remove.toggle(selected.length > 0);
+            }
+            this.render();
+        };
+
+        TodoToolbarView.prototype.destroy = function () {
+            mct.selection.off('change', this.handleSelectionChange);
+            this.mutableObject.stopListening();
+        };
+
+        mct.type('example.todo', todoType);
+        mct.view(mct.regions.main, {
+            view: function (domainObject) {
+                return new TodoView(domainObject);
+            },
+            canView: todoType.check.bind(todoType)
+        });
+
+        mct.view(mct.regions.toolbar, {
+            view: function (domainObject) {
+                return new TodoToolbarView(domainObject);
+            },
+            canView: todoType.check.bind(todoType)
+        });
+
+        return mct;
+    };
+});