Add check for destroy method on store.

Change failing test to use new data getter.

.circleci/config.yml

@@ -56,38 +56,14 @@ workflows:
           browser: ChromeHeadless
           always-pass: false
       - test:
-          name: node12-firefoxESR-build-only
+          name: node12-firefoxESR
           node-version: lts/erbium
           browser: FirefoxESR
           always-pass: true
       - test:
-          name: node14-chrome-build-only
+          name: node14-chrome
           node-version: lts/fermium
           browser: ChromeHeadless
           always-pass: true
-  nightly:
-    jobs:
-      - test:
-          name: node10-chrome-nightly
-          node-version: lts/dubnium
-          browser: ChromeHeadless
-          always-pass: false
-      - test:
-          name: node12-firefoxESR-nightly
-          node-version: lts/erbium
-          browser: FirefoxESR
-          always-pass: false
-      - test:
-          name: node14-chrome-nightly
-          node-version: lts/fermium
-          browser: ChromeHeadless
-          always-pass: false
-    triggers:
-      - schedule:
-          cron: "0 0 * * *"
-          filters:
-            branches:
-              only:
-                - master      
 
 

.github/workflows/codeql-analysis.yml

@@ -1,33 +0,0 @@
-
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ master ]
-  schedule:
-    - cron: '28 21 * * 3'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      with:
-        languages: javascript
-
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1

.npmrc

@@ -1 +0,0 @@
-loglevel=warn

API.md

@@ -996,7 +996,7 @@ reveal additional information when the mouse cursor is hovered over it.
 A common use case for indicators is to convey the state of some external system such as a 
 persistence backend or HTTP server. So long as this system is accessible via HTTP request, 
 Open MCT provides a general purpose indicator to show whether the server is available and 
-returning a 2xx status code. The URL Status Indicator is made available as a default plugin. See
+returing a 2xx status code. The URL Status Indicator is made available as a default plugin. See
 the [documentation](./src/plugins/URLIndicatorPlugin) for details on how to install and configure the 
 URL Status Indicator.
 

docs/src/design/proposals/APIRedesign.md

@@ -423,7 +423,7 @@ which can help with this, however.
   instead of separate approaches for static and substitutable
   dependencies.
 * Removes need to understand Angular's DI mechanism.
-* Improves usability of documentation (`typeService` is an
+* Improves useability of documentation (`typeService` is an
   instance of `CompositeService` and implements `TypeService`
   so you can easily traverse links in the JSDoc.)
 * Can be used more easily from Web Workers, allowing services

docs/src/index.md

@@ -25,7 +25,7 @@
 ## Legacy Documentation
 
 As we transition to a new API, the following documentation for the old API
-(which is supported during the transition) may be useful as well:
+(which is supported during the transtion) may be useful as well:
 
  * The [Architecture Overview](architecture/) describes the concepts used
  throughout Open MCT, and gives a high level overview of the platform's design.

example/forms/bundle.js

@@ -41,6 +41,11 @@ define([
                             "$scope"
                         ]
                     }
+                ],
+                "routes": [
+                    {
+                        "templateUrl": "templates/exampleForm.html"
+                    }
                 ]
             }
         }

example/generator/GeneratorProvider.js

@@ -96,9 +96,5 @@ define([
         return this.workerInterface.subscribe(workerRequest, callback);
     };
 
-    GeneratorProvider.prototype.destroy = function () {
-        this.workerInterface.destroy();
-    };
-
     return GeneratorProvider;
 });

example/generator/StateGeneratorProvider.js

@@ -63,7 +63,7 @@ define([
 
     StateGeneratorProvider.prototype.request = function (domainObject, options) {
         var start = options.start;
-        var end = Math.min(Date.now(), options.end); // no future values
+        var end = options.end;
         var duration = domainObject.telemetry.duration * 1000;
         if (options.strategy === 'latest' || options.size === 1) {
             start = end;

example/generator/WorkerInterface.js

@@ -40,11 +40,6 @@ define([
         this.callbacks = {};
     }
 
-    WorkerInterface.prototype.destroy = function () {
-        delete this.worker.onmessage;
-        this.worker.terminate();
-    };
-
     WorkerInterface.prototype.onMessage = function (message) {
         message = message.data;
         var callback = this.callbacks[message.id];

example/generator/plugin.js

@@ -146,11 +146,7 @@ define([
             }
         });
 
-        const generatorProvider = new GeneratorProvider();
-        openmct.once('destroy', () => {
-            generatorProvider.destroy();
-        });
-        openmct.telemetry.addProvider(generatorProvider);
+        openmct.telemetry.addProvider(new GeneratorProvider());
         openmct.telemetry.addProvider(new GeneratorMetadataProvider());
         openmct.telemetry.addProvider(new SinewaveLimitProvider());
     };

example/styleguide/res/templates/glyphs.html

@@ -152,7 +152,7 @@
         <h2>How to Use Glyphs</h2>
         <div class="cols cols1-1">
             <div class="col">
-                <p>The easiest way to use a glyph is to include its CSS class in an element. The CSS adds a pseudo <code>:before</code> HTML element to whatever element it's attached to that makes proper use of the symbols font.</p>
+                <p>The easiest way to use a glyph is to include its CSS class in an element. The CSS adds a psuedo <code>:before</code> HTML element to whatever element it's attached to that makes proper use of the symbols font.</p>
                 <p>Alternately, you can use the <code>.ui-symbol</code> class in an object that contains encoded HTML entities. This method is only recommended if you cannot use the aforementioned CSS class approach.</p>
             </div>
             <mct-example><a class="s-button icon-gear" title="Settings"></a>

index.html

@@ -195,6 +195,7 @@
             ['table', 'telemetry.plot.overlay', 'telemetry.plot.stacked'],
             {indicator: true}
         ));
+        openmct.install(openmct.plugins.Clock({ enableClockIndicator: true }));
         openmct.start();
     </script>
 </html>

indexTest.js

@@ -1,36 +1,3 @@
-
-const jasmineIt = window.it;
-const specIdsToExpectCount = new Map();
-const failures = [];
-
-window.it = function (name, specFunction) {
-    const expectRE = /expect\(/g;
-    const expectCount = (specFunction.toString().match(expectRE) || []).length;
-    const spec = jasmineIt(name, specFunction);
-
-    specIdsToExpectCount.set(spec.id, expectCount);
-
-    return spec;
-};
-
 const testsContext = require.context('.', true, /\/(src|platform)\/.*Spec.js$/);
 
-jasmine.getEnv().addReporter({
-    specDone(spec) {
-        const totalExpectsRun = (spec.failedExpectations || []).length + (spec.passedExpectations || []).length;
-        const totalExpectsDefined = specIdsToExpectCount.get(spec.id);
-
-        if (totalExpectsRun < totalExpectsDefined) {
-            failures.push(`Executed ${totalExpectsRun} but ${totalExpectsDefined} were defined for spec ${spec.fullName}`);
-        }
-
-    },
-    jasmineDone() {
-        window.it = jasmineIt;
-        failures.forEach(failure => {
-            console.error(failure);
-        });
-    }
-});
-
 testsContext.keys().forEach(testsContext);

package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmct",
-  "version": "1.7.8-SNAPSHOT",
+  "version": "1.7.6-SNAPSHOT",
   "description": "The Open MCT core platform",
   "dependencies": {},
   "devDependencies": {

platform/commonUI/about/bundle.js

@@ -164,6 +164,16 @@ define([
                         "license": "license-apache",
                         "link": "http://logging.apache.org/log4net/license.html"
                     }
+                ],
+                "routes": [
+                    {
+                        "when": "/licenses",
+                        "template": licensesTemplate
+                    },
+                    {
+                        "when": "/licenses-md",
+                        "template": licensesExportMdTemplate
+                    }
                 ]
             }
         }

platform/commonUI/browse/bundle.js

@@ -50,6 +50,8 @@ define([
         name: "platform/commonUI/browse",
         definition: {
             "extensions": {
+                "routes": [
+                ],
                 "constants": [
                     {
                         "key": "DEFAULT_PATH",

platform/commonUI/browse/src/navigation/NavigationService.js

@@ -39,6 +39,9 @@ define(
             this.callbacks = [];
             this.checks = [];
             this.$window = $window;
+
+            this.oldUnload = $window.onbeforeunload;
+            $window.onbeforeunload = this.onBeforeUnload.bind(this);
         }
 
         /**
@@ -61,7 +64,7 @@ define(
          *
          * @param {DomainObject} domainObject the domain object to navigate to
          * @param {Boolean} force if true, force navigation to occur.
-         * @returns {Boolean} true if navigation occurred, otherwise false.
+         * @returns {Boolean} true if navigation occured, otherwise false.
          */
         NavigationService.prototype.setNavigation = function (domainObject, force) {
             if (force) {

platform/commonUI/edit/test/actions/SaveAsActionSpec.js

@@ -0,0 +1,249 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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(
+    ["../../src/actions/SaveAsAction"],
+    function (SaveAsAction) {
+
+        xdescribe("The Save As action", function () {
+            var mockDomainObject,
+                mockClonedObject,
+                mockEditorCapability,
+                mockActionCapability,
+                mockObjectService,
+                mockDialogService,
+                mockCopyService,
+                mockNotificationService,
+                mockParent,
+                actionContext,
+                capabilities = {},
+                action;
+
+            function noop() {}
+
+            function mockPromise(value) {
+                return (value || {}).then ? value
+                    : {
+                        then: function (callback) {
+                            return mockPromise(callback(value));
+                        },
+                        catch: function (callback) {
+                            return mockPromise(callback(value));
+                        }
+                    };
+            }
+
+            beforeEach(function () {
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    [
+                        "getCapability",
+                        "hasCapability",
+                        "getModel",
+                        "getId"
+                    ]
+                );
+                mockDomainObject.hasCapability.and.returnValue(true);
+                mockDomainObject.getCapability.and.callFake(function (capability) {
+                    return capabilities[capability];
+                });
+                mockDomainObject.getModel.and.returnValue({
+                    location: 'a',
+                    persisted: undefined
+                });
+                mockDomainObject.getId.and.returnValue(0);
+
+                mockClonedObject = jasmine.createSpyObj(
+                    "clonedObject",
+                    [
+                        "getId"
+                    ]
+                );
+                mockClonedObject.getId.and.returnValue(1);
+
+                mockParent = jasmine.createSpyObj(
+                    "parentObject",
+                    [
+                        "getCapability",
+                        "hasCapability",
+                        "getModel"
+                    ]
+                );
+
+                mockEditorCapability = jasmine.createSpyObj(
+                    "editor",
+                    ["save", "finish", "isEditContextRoot"]
+                );
+                mockEditorCapability.save.and.returnValue(mockPromise(true));
+                mockEditorCapability.finish.and.returnValue(mockPromise(true));
+                mockEditorCapability.isEditContextRoot.and.returnValue(true);
+                capabilities.editor = mockEditorCapability;
+
+                mockActionCapability = jasmine.createSpyObj(
+                    "action",
+                    ["perform"]
+                );
+                capabilities.action = mockActionCapability;
+
+                mockObjectService = jasmine.createSpyObj(
+                    "objectService",
+                    ["getObjects"]
+                );
+                mockObjectService.getObjects.and.returnValue(mockPromise({'a': mockParent}));
+
+                mockDialogService = jasmine.createSpyObj(
+                    "dialogService",
+                    [
+                        "getUserInput",
+                        "showBlockingMessage"
+                    ]
+                );
+                mockDialogService.getUserInput.and.returnValue(mockPromise(undefined));
+
+                mockCopyService = jasmine.createSpyObj(
+                    "copyService",
+                    [
+                        "perform"
+                    ]
+                );
+                mockCopyService.perform.and.returnValue(mockPromise(mockClonedObject));
+
+                mockNotificationService = jasmine.createSpyObj(
+                    "notificationService",
+                    [
+                        "info",
+                        "error"
+                    ]
+                );
+
+                actionContext = {
+                    domainObject: mockDomainObject
+                };
+
+                action = new SaveAsAction(
+                    undefined,
+                    undefined,
+                    mockDialogService,
+                    mockCopyService,
+                    mockNotificationService,
+                    actionContext);
+
+                spyOn(action, "getObjectService");
+                action.getObjectService.and.returnValue(mockObjectService);
+
+                spyOn(action, "createWizard");
+                action.createWizard.and.returnValue({
+                    getFormStructure: noop,
+                    getInitialFormValue: noop,
+                    populateObjectFromInput: function () {
+                        return mockDomainObject;
+                    }
+                });
+
+            });
+
+            it("only applies to domain object with an editor capability", function () {
+                expect(SaveAsAction.appliesTo(actionContext)).toBe(true);
+                expect(mockDomainObject.hasCapability).toHaveBeenCalledWith("editor");
+
+                mockDomainObject.hasCapability.and.returnValue(false);
+                mockDomainObject.getCapability.and.returnValue(undefined);
+                expect(SaveAsAction.appliesTo(actionContext)).toBe(false);
+            });
+
+            it("only applies to domain object that has not already been"
+                + " persisted", function () {
+                expect(SaveAsAction.appliesTo(actionContext)).toBe(true);
+                expect(mockDomainObject.hasCapability).toHaveBeenCalledWith("editor");
+
+                mockDomainObject.getModel.and.returnValue({persisted: 0});
+                expect(SaveAsAction.appliesTo(actionContext)).toBe(false);
+            });
+
+            it("uses the editor capability to save the object", function () {
+                mockEditorCapability.save.and.returnValue(Promise.resolve());
+
+                return action.perform().then(function () {
+                    expect(mockEditorCapability.save).toHaveBeenCalled();
+                });
+            });
+
+            it("uses the editor capability to finish editing the object", function () {
+                return action.perform().then(function () {
+                    expect(mockEditorCapability.finish.calls.count()).toBeGreaterThan(0);
+                });
+            });
+
+            it("returns to browse after save", function () {
+                spyOn(action, "save");
+                action.save.and.returnValue(mockPromise(mockDomainObject));
+                action.perform();
+                expect(mockActionCapability.perform).toHaveBeenCalledWith(
+                    "navigate"
+                );
+            });
+
+            it("prompts the user for object details", function () {
+                action.perform();
+                expect(mockDialogService.getUserInput).toHaveBeenCalled();
+            });
+
+            describe("in order to keep the user in the loop", function () {
+                var mockDialogHandle;
+
+                beforeEach(function () {
+                    mockDialogHandle = jasmine.createSpyObj("dialogHandle", ["dismiss"]);
+                    mockDialogService.showBlockingMessage.and.returnValue(mockDialogHandle);
+                });
+
+                it("shows a blocking dialog indicating that saving is in progress", function () {
+                    mockEditorCapability.save.and.returnValue(new Promise(function () {}));
+                    action.perform();
+                    expect(mockDialogService.showBlockingMessage).toHaveBeenCalled();
+                    expect(mockDialogHandle.dismiss).not.toHaveBeenCalled();
+                });
+
+                it("hides the blocking dialog after saving finishes", function () {
+                    return action.perform().then(function () {
+                        expect(mockDialogService.showBlockingMessage).toHaveBeenCalled();
+                        expect(mockDialogHandle.dismiss).toHaveBeenCalled();
+                    });
+                });
+
+                it("notifies if saving succeeded", function () {
+                    return action.perform().then(function () {
+                        expect(mockNotificationService.info).toHaveBeenCalled();
+                        expect(mockNotificationService.error).not.toHaveBeenCalled();
+                    });
+                });
+
+                it("notifies if saving failed", function () {
+                    mockCopyService.perform.and.returnValue(Promise.reject("some failure reason"));
+                    action.perform().then(function () {
+                        expect(mockNotificationService.error).toHaveBeenCalled();
+                        expect(mockNotificationService.info).not.toHaveBeenCalled();
+                    });
+                });
+            });
+        });
+    }
+);

platform/commonUI/edit/test/capabilities/EditorCapabilitySpec.js

@@ -0,0 +1,192 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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(
+    ["../../src/capabilities/EditorCapability"],
+    function (EditorCapability) {
+
+        xdescribe("The editor capability", function () {
+            var mockDomainObject,
+                capabilities,
+                mockParentObject,
+                mockTransactionService,
+                mockStatusCapability,
+                mockParentStatus,
+                mockContextCapability,
+                capability;
+
+            function fastPromise(val) {
+                return {
+                    then: function (callback) {
+                        return callback(val);
+                    }
+                };
+            }
+
+            beforeEach(function () {
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    ["getId", "getModel", "hasCapability", "getCapability", "useCapability"]
+                );
+                mockParentObject = jasmine.createSpyObj(
+                    "domainObject",
+                    ["getId", "getModel", "hasCapability", "getCapability", "useCapability"]
+                );
+                mockTransactionService = jasmine.createSpyObj(
+                    "transactionService",
+                    [
+                        "startTransaction",
+                        "size",
+                        "commit",
+                        "cancel"
+                    ]
+                );
+                mockTransactionService.commit.and.returnValue(fastPromise());
+                mockTransactionService.cancel.and.returnValue(fastPromise());
+                mockTransactionService.isActive = jasmine.createSpy('isActive');
+
+                mockStatusCapability = jasmine.createSpyObj(
+                    "statusCapability",
+                    ["get", "set"]
+                );
+                mockParentStatus = jasmine.createSpyObj(
+                    "statusCapability",
+                    ["get", "set"]
+                );
+                mockContextCapability = jasmine.createSpyObj(
+                    "contextCapability",
+                    ["getParent"]
+                );
+                mockContextCapability.getParent.and.returnValue(mockParentObject);
+
+                capabilities = {
+                    context: mockContextCapability,
+                    status: mockStatusCapability
+                };
+
+                mockDomainObject.hasCapability.and.callFake(function (name) {
+                    return capabilities[name] !== undefined;
+                });
+
+                mockDomainObject.getCapability.and.callFake(function (name) {
+                    return capabilities[name];
+                });
+
+                mockParentObject.getCapability.and.returnValue(mockParentStatus);
+                mockParentObject.hasCapability.and.returnValue(false);
+
+                capability = new EditorCapability(
+                    mockTransactionService,
+                    mockDomainObject
+                );
+            });
+
+            it("starts a transaction when edit is invoked", function () {
+                capability.edit();
+                expect(mockTransactionService.startTransaction).toHaveBeenCalled();
+            });
+
+            it("sets editing status on object", function () {
+                capability.edit();
+                expect(mockStatusCapability.set).toHaveBeenCalledWith("editing", true);
+            });
+
+            it("uses editing status to determine editing context root", function () {
+                capability.edit();
+                mockStatusCapability.get.and.returnValue(false);
+                expect(capability.isEditContextRoot()).toBe(false);
+                mockStatusCapability.get.and.returnValue(true);
+                expect(capability.isEditContextRoot()).toBe(true);
+            });
+
+            it("inEditingContext returns true if parent object is being"
+                + " edited", function () {
+                mockStatusCapability.get.and.returnValue(false);
+                mockParentStatus.get.and.returnValue(false);
+                expect(capability.inEditContext()).toBe(false);
+                mockParentStatus.get.and.returnValue(true);
+                expect(capability.inEditContext()).toBe(true);
+            });
+
+            describe("save", function () {
+                beforeEach(function () {
+                    capability.edit();
+                    capability.save();
+                });
+                it("commits the transaction", function () {
+                    expect(mockTransactionService.commit).toHaveBeenCalled();
+                });
+                it("begins a new transaction", function () {
+                    expect(mockTransactionService.startTransaction).toHaveBeenCalled();
+                });
+            });
+
+            describe("finish", function () {
+                beforeEach(function () {
+                    mockTransactionService.isActive.and.returnValue(true);
+                    capability.edit();
+                    capability.finish();
+                });
+                it("cancels the transaction", function () {
+                    expect(mockTransactionService.cancel).toHaveBeenCalled();
+                });
+                it("resets the edit state", function () {
+                    expect(mockStatusCapability.set).toHaveBeenCalledWith('editing', false);
+                });
+            });
+
+            describe("finish", function () {
+                beforeEach(function () {
+                    mockTransactionService.isActive.and.returnValue(false);
+                    capability.edit();
+                });
+
+                it("does not cancel transaction when transaction is not active", function () {
+                    capability.finish();
+                    expect(mockTransactionService.cancel).not.toHaveBeenCalled();
+                });
+
+                it("returns a promise", function () {
+                    expect(capability.finish() instanceof Promise).toBe(true);
+                });
+
+            });
+
+            describe("dirty", function () {
+                var model = {};
+
+                beforeEach(function () {
+                    mockDomainObject.getModel.and.returnValue(model);
+                    capability.edit();
+                    capability.finish();
+                });
+                it("returns true if the object has been modified since it"
+                    + " was last persisted", function () {
+                    mockTransactionService.size.and.returnValue(0);
+                    expect(capability.dirty()).toBe(false);
+                    mockTransactionService.size.and.returnValue(1);
+                    expect(capability.dirty()).toBe(true);
+                });
+            });
+        });
+    }
+);

platform/commonUI/edit/test/creation/CreateActionSpec.js

@@ -0,0 +1,186 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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.
+ *****************************************************************************/
+
+/**
+ * MCTRepresentationSpec. Created by vwoeltje on 11/6/14.
+ */
+define(
+    ["../../src/creation/CreateAction"],
+    function (CreateAction) {
+
+        xdescribe("The create action", function () {
+            var mockType,
+                mockParent,
+                mockContext,
+                mockDomainObject,
+                capabilities = {},
+                mockEditAction,
+                action;
+
+            function mockPromise(value) {
+                return {
+                    then: function (callback) {
+                        return mockPromise(callback(value));
+                    }
+                };
+            }
+
+            beforeEach(function () {
+                mockType = jasmine.createSpyObj(
+                    "type",
+                    [
+                        "getKey",
+                        "getGlyph",
+                        "getCssClass",
+                        "getName",
+                        "getDescription",
+                        "getProperties",
+                        "getInitialModel"
+                    ]
+                );
+                mockParent = jasmine.createSpyObj(
+                    "domainObject",
+                    [
+                        "getId",
+                        "getModel",
+                        "getCapability",
+                        "useCapability"
+                    ]
+                );
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    [
+                        "getId",
+                        "getModel",
+                        "getCapability",
+                        "hasCapability",
+                        "useCapability"
+                    ]
+                );
+                mockDomainObject.hasCapability.and.callFake(function (name) {
+                    return Boolean(capabilities[name]);
+                });
+                mockDomainObject.getCapability.and.callFake(function (name) {
+                    return capabilities[name];
+                });
+
+                capabilities.action = jasmine.createSpyObj(
+                    "actionCapability",
+                    [
+                        "getActions",
+                        "perform"
+                    ]
+                );
+
+                capabilities.editor = jasmine.createSpyObj(
+                    "editorCapability",
+                    [
+                        "edit",
+                        "save",
+                        "finish"
+                    ]
+                );
+
+                mockEditAction = jasmine.createSpyObj(
+                    "editAction",
+                    [
+                        "perform"
+                    ]
+                );
+
+                mockContext = {
+                    domainObject: mockParent
+                };
+                mockParent.useCapability.and.returnValue(mockDomainObject);
+
+                mockType.getKey.and.returnValue("test");
+                mockType.getCssClass.and.returnValue("icon-telemetry");
+                mockType.getDescription.and.returnValue("a test type");
+                mockType.getName.and.returnValue("Test");
+                mockType.getProperties.and.returnValue([]);
+                mockType.getInitialModel.and.returnValue({});
+
+                action = new CreateAction(
+                    mockType,
+                    mockParent,
+                    mockContext
+                );
+            });
+
+            it("exposes type-appropriate metadata", function () {
+                var metadata = action.getMetadata();
+
+                expect(metadata.name).toEqual("Test");
+                expect(metadata.description).toEqual("a test type");
+                expect(metadata.cssClass).toEqual("icon-telemetry");
+            });
+
+            describe("the perform function", function () {
+                var promise = jasmine.createSpyObj("promise", ["then"]);
+                beforeEach(function () {
+                    capabilities.action.getActions.and.returnValue([mockEditAction]);
+                });
+
+                it("uses the instantiation capability when performed", function () {
+                    action.perform();
+                    expect(mockParent.useCapability).toHaveBeenCalledWith("instantiation", jasmine.any(Object));
+                });
+
+                it("uses the edit action if available", function () {
+                    action.perform();
+                    expect(mockEditAction.perform).toHaveBeenCalled();
+                });
+
+                it("uses the save-as action if object does not have an edit action"
+                    + " available", function () {
+                    capabilities.action.getActions.and.returnValue([]);
+                    capabilities.action.perform.and.returnValue(mockPromise(undefined));
+                    capabilities.editor.save.and.returnValue(promise);
+                    action.perform();
+                    expect(capabilities.action.perform).toHaveBeenCalledWith("save-as");
+                });
+
+                describe("uses to editor capability", function () {
+                    beforeEach(function () {
+                        capabilities.action.getActions.and.returnValue([]);
+                        capabilities.action.perform.and.returnValue(promise);
+                        capabilities.editor.save.and.returnValue(promise);
+                    });
+
+                    it("to save the edit if user saves dialog", function () {
+                        action.perform();
+                        expect(promise.then).toHaveBeenCalled();
+                        promise.then.calls.mostRecent().args[0]();
+                        expect(capabilities.editor.save).toHaveBeenCalled();
+                    });
+
+                    it("to finish the edit if user cancels dialog", function () {
+                        action.perform();
+                        promise.then.calls.mostRecent().args[1]();
+                        expect(capabilities.editor.finish).toHaveBeenCalled();
+                    });
+                });
+            });
+
+        });
+    }
+);

platform/commonUI/edit/test/creation/CreateWizardSpec.js

@@ -0,0 +1,197 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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.
+ *****************************************************************************/
+
+/**
+ * MCTRepresentationSpec. Created by vwoeltje on 11/6/14.
+ */
+define(
+    ["../../src/creation/CreateWizard"],
+    function (CreateWizard) {
+
+        xdescribe("The create wizard", function () {
+            var mockType,
+                mockParent,
+                mockProperties,
+                mockPolicyService,
+                testModel,
+                mockDomainObject,
+                wizard;
+
+            function createMockProperty(name) {
+                var mockProperty = jasmine.createSpyObj(
+                    "property" + name,
+                    ["getDefinition", "getValue", "setValue"]
+                );
+                mockProperty.getDefinition.and.returnValue({
+                    control: "textfield"
+                });
+                mockProperty.getValue.and.returnValue(name);
+
+                return mockProperty;
+            }
+
+            beforeEach(function () {
+                mockType = jasmine.createSpyObj(
+                    "type",
+                    [
+                        "getKey",
+                        "getGlyph",
+                        "getCssClass",
+                        "getName",
+                        "getDescription",
+                        "getProperties",
+                        "getInitialModel"
+                    ]
+                );
+                mockParent = jasmine.createSpyObj(
+                    "domainObject",
+                    [
+                        "getId",
+                        "getModel",
+                        "getCapability"
+                    ]
+                );
+                mockProperties = ["A", "B", "C"].map(createMockProperty);
+                mockPolicyService = jasmine.createSpyObj('policyService', ['allow']);
+
+                testModel = { someKey: "some value" };
+
+                mockType.getKey.and.returnValue("test");
+                mockType.getCssClass.and.returnValue("icon-telemetry");
+                mockType.getDescription.and.returnValue("a test type");
+                mockType.getName.and.returnValue("Test");
+                mockType.getInitialModel.and.returnValue(testModel);
+                mockType.getProperties.and.returnValue(mockProperties);
+
+                mockDomainObject = jasmine.createSpyObj(
+                    'domainObject',
+                    ['getCapability', 'useCapability', 'getModel']
+                );
+
+                //Mocking the getCapability('type') call
+                mockDomainObject.getCapability.and.returnValue(mockType);
+                mockDomainObject.useCapability.and.returnValue();
+                mockDomainObject.getModel.and.returnValue(testModel);
+
+                wizard = new CreateWizard(
+                    mockDomainObject,
+                    mockParent,
+                    mockPolicyService
+                );
+            });
+
+            it("creates a form model with a Properties section", function () {
+                expect(wizard.getFormStructure().sections[0].name)
+                    .toEqual("Properties");
+            });
+
+            it("adds one row per defined type property", function () {
+                // Three properties were defined in the mock type
+                expect(wizard.getFormStructure().sections[0].rows.length)
+                    .toEqual(3);
+            });
+
+            it("interprets form data using type-defined properties", function () {
+                // Use key names from mock properties
+                wizard.createModel([
+                    "field 0",
+                    "field 1",
+                    "field 2"
+                ]);
+
+                // Should have gotten a setValue call
+                mockProperties.forEach(function (mockProperty, i) {
+                    expect(mockProperty.setValue).toHaveBeenCalledWith(
+                        {
+                            someKey: "some value",
+                            type: 'test'
+                        },
+                        "field " + i
+                    );
+                });
+            });
+
+            it("looks up initial values from properties", function () {
+                var initialValue = wizard.getInitialFormValue();
+
+                expect(initialValue[0]).toEqual("A");
+                expect(initialValue[1]).toEqual("B");
+                expect(initialValue[2]).toEqual("C");
+
+                // Verify that expected argument was passed
+                mockProperties.forEach(function (mockProperty) {
+                    expect(mockProperty.getValue)
+                        .toHaveBeenCalledWith(testModel);
+                });
+            });
+
+            it("populates the model on the associated object", function () {
+                var formValue = {
+                        "A": "ValueA",
+                        "B": "ValueB",
+                        "C": "ValueC"
+                    },
+                    compareModel = wizard.createModel(formValue);
+                //populateObjectFromInput adds a .location attribute that is not added by createModel.
+                compareModel.location = undefined;
+                wizard.populateObjectFromInput(formValue);
+                expect(mockDomainObject.useCapability).toHaveBeenCalledWith('mutation', jasmine.any(Function));
+                expect(mockDomainObject.useCapability.calls.mostRecent().args[1]()).toEqual(compareModel);
+            });
+
+            it("validates selection types using policy", function () {
+                var mockDomainObj = jasmine.createSpyObj(
+                        'domainObject',
+                        ['getCapability']
+                    ),
+                    mockOtherType = jasmine.createSpyObj(
+                        'otherType',
+                        ['getKey']
+                    ),
+
+                    //Create a form structure with location
+                    structure = wizard.getFormStructure(true),
+                    sections = structure.sections,
+                    rows = structure.sections[sections.length - 1].rows,
+                    locationRow = rows[rows.length - 1];
+
+                mockDomainObj.getCapability.and.returnValue(mockOtherType);
+                locationRow.validate(mockDomainObj);
+
+                // Should check policy to see if the user-selected location
+                // can actually contain objects of this type
+                expect(mockPolicyService.allow).toHaveBeenCalledWith(
+                    'composition',
+                    mockDomainObj,
+                    mockDomainObject
+                );
+            });
+
+            it("creates a form model without a location if not requested", function () {
+                expect(wizard.getFormStructure(false).sections.some(function (section) {
+                    return section.name === 'Location';
+                })).toEqual(false);
+            });
+
+        });
+    }
+);

platform/commonUI/general/test/ui/TreeViewSpec.js

@@ -0,0 +1,290 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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([
+    '../../src/ui/TreeView',
+    'zepto'
+], function (TreeView, $) {
+
+    xdescribe("TreeView", function () {
+        var mockGestureService,
+            mockGestureHandle,
+            mockDomainObject,
+            mockMutation,
+            mockUnlisten,
+            testCapabilities,
+            treeView;
+
+        function makeMockDomainObject(id, model, capabilities) {
+            var mockDomainObj = jasmine.createSpyObj(
+                'domainObject-' + id,
+                [
+                    'getId',
+                    'getModel',
+                    'getCapability',
+                    'hasCapability',
+                    'useCapability'
+                ]
+            );
+            mockDomainObj.getId.and.returnValue(id);
+            mockDomainObj.getModel.and.returnValue(model);
+            mockDomainObj.hasCapability.and.callFake(function (c) {
+                return Boolean(capabilities[c]);
+            });
+            mockDomainObj.getCapability.and.callFake(function (c) {
+                return capabilities[c];
+            });
+            mockDomainObj.useCapability.and.callFake(function (c) {
+                return capabilities[c] && capabilities[c].invoke();
+            });
+
+            return mockDomainObj;
+        }
+
+        beforeEach(function () {
+            mockGestureService = jasmine.createSpyObj(
+                'gestureService',
+                ['attachGestures']
+            );
+
+            mockGestureHandle = jasmine.createSpyObj('gestures', ['destroy']);
+
+            mockGestureService.attachGestures.and.returnValue(mockGestureHandle);
+
+            mockMutation = jasmine.createSpyObj('mutation', ['listen']);
+            mockUnlisten = jasmine.createSpy('unlisten');
+            mockMutation.listen.and.returnValue(mockUnlisten);
+
+            testCapabilities = { mutation: mockMutation };
+
+            mockDomainObject =
+                makeMockDomainObject('parent', {}, testCapabilities);
+
+            treeView = new TreeView(mockGestureService);
+        });
+
+        describe("elements", function () {
+            var elements;
+
+            beforeEach(function () {
+                elements = treeView.elements();
+            });
+
+            it("is an unordered list", function () {
+                expect(elements[0].tagName.toLowerCase())
+                    .toEqual('ul');
+            });
+        });
+
+        describe("model", function () {
+            var mockComposition;
+
+            function makeGenericCapabilities() {
+                var mockStatus =
+                        jasmine.createSpyObj('status', ['listen', 'list']);
+
+                mockStatus.list.and.returnValue([]);
+
+                return {
+                    context: jasmine.createSpyObj('context', ['getPath']),
+                    type: jasmine.createSpyObj('type', ['getCssClass']),
+                    location: jasmine.createSpyObj('location', ['isLink']),
+                    mutation: jasmine.createSpyObj('mutation', ['listen']),
+                    status: mockStatus
+                };
+            }
+
+            beforeEach(function () {
+                mockComposition = ['a', 'b', 'c'].map(function (id) {
+                    var testCaps = makeGenericCapabilities(),
+                        mockChild =
+                            makeMockDomainObject(id, {}, testCaps);
+
+                    testCaps.context.getPath
+                        .and.returnValue([mockDomainObject, mockChild]);
+
+                    return mockChild;
+                });
+
+                testCapabilities.composition =
+                    jasmine.createSpyObj('composition', ['invoke']);
+                testCapabilities.composition.invoke
+                    .and.returnValue(Promise.resolve(mockComposition));
+
+                treeView.model(mockDomainObject);
+
+                return testCapabilities.composition.invoke();
+            });
+
+            it("adds one node per composition element", function () {
+                expect(treeView.elements()[0].childElementCount)
+                    .toEqual(mockComposition.length);
+            });
+
+            it("listens for mutation", function () {
+                expect(testCapabilities.mutation.listen)
+                    .toHaveBeenCalledWith(jasmine.any(Function));
+            });
+
+            describe("when mutation occurs", function () {
+                beforeEach(function () {
+                    mockComposition.pop();
+                    testCapabilities.mutation.listen
+                        .calls.mostRecent().args[0](mockDomainObject.getModel());
+
+                    return testCapabilities.composition.invoke();
+                });
+
+                it("continues to show one node per composition element", function () {
+                    expect(treeView.elements()[0].childElementCount)
+                        .toEqual(mockComposition.length);
+                });
+            });
+
+            describe("when replaced with a non-compositional domain object", function () {
+                beforeEach(function () {
+                    delete testCapabilities.composition;
+                    treeView.model(mockDomainObject);
+                });
+
+                it("stops listening for mutation", function () {
+                    expect(mockUnlisten).toHaveBeenCalled();
+                });
+
+                it("removes all tree nodes", function () {
+                    expect(treeView.elements()[0].childElementCount)
+                        .toEqual(0);
+                });
+            });
+
+            describe("when selection state changes", function () {
+                var selectionIndex = 1;
+
+                beforeEach(function () {
+                    treeView.value(mockComposition[selectionIndex]);
+                });
+
+                it("communicates selection state to an appropriate node", function () {
+                    var selected = $(treeView.elements()[0]).find('.selected');
+                    expect(selected.length).toEqual(1);
+                });
+            });
+
+            describe("when a context-less object is selected", function () {
+                beforeEach(function () {
+                    var testCaps = makeGenericCapabilities(),
+                        mockDomainObj =
+                            makeMockDomainObject('xyz', {}, testCaps);
+                    delete testCaps.context;
+                    treeView.value(mockDomainObj);
+                });
+
+                it("clears all selection state", function () {
+                    var selected = $(treeView.elements()[0]).find('.selected');
+                    expect(selected.length).toEqual(0);
+                });
+            });
+
+            describe("when children contain children", function () {
+                beforeEach(function () {
+                    var newCapabilities = makeGenericCapabilities(),
+                        gcCapabilities = makeGenericCapabilities(),
+                        mockNewChild =
+                            makeMockDomainObject('d', {}, newCapabilities),
+                        mockGrandchild =
+                            makeMockDomainObject('gc', {}, gcCapabilities);
+
+                    newCapabilities.composition =
+                        jasmine.createSpyObj('composition', ['invoke']);
+                    newCapabilities.composition.invoke
+                        .and.returnValue(Promise.resolve([mockGrandchild]));
+                    mockComposition.push(mockNewChild);
+
+                    newCapabilities.context.getPath.and.returnValue([
+                        mockDomainObject,
+                        mockNewChild
+                    ]);
+                    gcCapabilities.context.getPath.and.returnValue([
+                        mockDomainObject,
+                        mockNewChild,
+                        mockGrandchild
+                    ]);
+
+                    testCapabilities.mutation.listen
+                        .calls.mostRecent().args[0](mockDomainObject);
+
+                    return testCapabilities.composition.invoke().then(function () {
+                        treeView.value(mockGrandchild);
+
+                        return newCapabilities.composition.invoke();
+                    });
+                });
+
+                it("creates inner trees", function () {
+                    expect($(treeView.elements()[0]).find('ul').length)
+                        .toEqual(1);
+                });
+            });
+
+            describe("when status changes", function () {
+                var testStatuses;
+
+                beforeEach(function () {
+                    var mockStatus = mockComposition[1].getCapability('status');
+
+                    testStatuses = ['foo'];
+
+                    mockStatus.list.and.returnValue(testStatuses);
+                    mockStatus.listen.calls.mostRecent().args[0](testStatuses);
+                });
+
+                it("reflects the status change in the tree", function () {
+                    expect($(treeView.elements()).find('.s-status-foo').length)
+                        .toEqual(1);
+                });
+            });
+        });
+
+        describe("observe", function () {
+            var mockCallback,
+                unobserve;
+
+            beforeEach(function () {
+                mockCallback = jasmine.createSpy('callback');
+                unobserve = treeView.observe(mockCallback);
+            });
+
+            it("notifies listeners when value is changed", function () {
+                treeView.value(mockDomainObject, {some: event});
+                expect(mockCallback)
+                    .toHaveBeenCalledWith(mockDomainObject, {some: event});
+            });
+
+            it("does not notify listeners when deactivated", function () {
+                unobserve();
+                treeView.value(mockDomainObject);
+                expect(mockCallback).not.toHaveBeenCalled();
+            });
+        });
+    });
+
+});

platform/commonUI/mobile/bundle.js

@@ -21,14 +21,28 @@
  *****************************************************************************/
 
 define([
-    "./src/AgentService"
+    "./src/MCTDevice",
+    "./src/AgentService",
+    "./src/DeviceClassifier"
 ], function (
-    AgentService
+    MCTDevice,
+    AgentService,
+    DeviceClassifier
 ) {
+
     return {
         name: "platform/commonUI/mobile",
         definition: {
             "extensions": {
+                "directives": [
+                    {
+                        "key": "mctDevice",
+                        "implementation": MCTDevice,
+                        "depends": [
+                            "agentService"
+                        ]
+                    }
+                ],
                 "services": [
                     {
                         "key": "agentService",
@@ -37,6 +51,15 @@ define([
                             "$window"
                         ]
                     }
+                ],
+                "runs": [
+                    {
+                        "implementation": DeviceClassifier,
+                        "depends": [
+                            "agentService",
+                            "$document"
+                        ]
+                    }
                 ]
             }
         }

platform/commonUI/mobile/src/AgentService.js

@@ -20,12 +20,122 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-define(["../../../../src/utils/agent/Agent.js"], function (Agent) {
-    function AngularAgentServiceWrapper(window) {
-        const AS = Agent.default;
+/**
+ * Provides features which support variant behavior on mobile devices.
+ *
+ * @namespace platform/commonUI/mobile
+ */
+define(
+    [],
+    function () {
 
-        return new AS(window);
+        /**
+         * The query service handles calls for browser and userAgent
+         * info using a comparison between the userAgent and key
+         * device names
+         * @constructor
+         * @param $window Angular-injected instance of the window
+         * @memberof platform/commonUI/mobile
+         */
+        function AgentService($window) {
+            var userAgent = $window.navigator.userAgent,
+                matches = userAgent.match(/iPad|iPhone|Android/i) || [];
+
+            this.userAgent = userAgent;
+            this.mobileName = matches[0];
+            this.$window = $window;
+            this.touchEnabled = ($window.ontouchstart !== undefined);
+        }
+
+        /**
+         * Check if the user is on a mobile device.
+         * @returns {boolean} true on mobile
+         */
+        AgentService.prototype.isMobile = function () {
+            return Boolean(this.mobileName);
+        };
+
+        /**
+         * Check if the user is on a phone-sized mobile device.
+         * @returns {boolean} true on a phone
+         */
+        AgentService.prototype.isPhone = function () {
+            if (this.isMobile()) {
+                if (this.isAndroidTablet()) {
+                    return false;
+                } else if (this.mobileName === 'iPad') {
+                    return false;
+                } else {
+                    return true;
+                }
+            } else {
+                return false;
+            }
+        };
+
+        /**
+         * Check if the user is on a tablet sized android device
+         * @returns {boolean} true on an android tablet
+         */
+        AgentService.prototype.isAndroidTablet = function () {
+            if (this.mobileName === 'Android') {
+                if (this.isPortrait() && window.innerWidth >= 768) {
+                    return true;
+                } else if (this.isLandscape() && window.innerHeight >= 768) {
+                    return true;
+                }
+            } else {
+                return false;
+            }
+        };
+
+        /**
+         * Check if the user is on a tablet-sized mobile device.
+         * @returns {boolean} true on a tablet
+         */
+        AgentService.prototype.isTablet = function () {
+            return (this.isMobile() && !this.isPhone() && this.mobileName !== 'Android') || (this.isMobile() && this.isAndroidTablet());
+        };
+
+        /**
+         * Check if the user's device is in a portrait-style
+         * orientation (display width is narrower than display height.)
+         * @returns {boolean} true in portrait mode
+         */
+        AgentService.prototype.isPortrait = function () {
+            return this.$window.innerWidth < this.$window.innerHeight;
+        };
+
+        /**
+         * Check if the user's device is in a landscape-style
+         * orientation (display width is greater than display height.)
+         * @returns {boolean} true in landscape mode
+         */
+        AgentService.prototype.isLandscape = function () {
+            return !this.isPortrait();
+        };
+
+        /**
+         * Check if the user's device supports a touch interface.
+         * @returns {boolean} true if touch is supported
+         */
+        AgentService.prototype.isTouch = function () {
+            return this.touchEnabled;
+        };
+
+        /**
+         * Check if the user agent matches a certain named device,
+         * as indicated by checking for a case-insensitive substring
+         * match.
+         * @param {string} name the name to check for
+         * @returns {boolean} true if the user agent includes that name
+         */
+        AgentService.prototype.isBrowser = function (name) {
+            name = name.toLowerCase();
+
+            return this.userAgent.toLowerCase().indexOf(name) !== -1;
+        };
+
+        return AgentService;
     }
-
-    return AngularAgentServiceWrapper;
-});
+);

platform/commonUI/mobile/src/AgentServiceSpec.js

@@ -1,96 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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.
- *****************************************************************************/
-import AgentService from "./AgentService";
-
-const TEST_USER_AGENTS = {
-    DESKTOP:
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.89 Safari/537.36",
-    IPAD:
-    "Mozilla/5.0 (iPad; CPU OS 7_0 like Mac OS X) AppleWebKit/537.51.1 (KHTML, like Gecko) Version/7.0 Mobile/11A465 Safari/9537.53",
-    IPHONE:
-    "Mozilla/5.0 (iPhone; CPU iPhone OS 7_0 like Mac OS X; en-us) AppleWebKit/537.51.1 (KHTML, like Gecko) Version/7.0 Mobile/11A465 Safari/9537.53"
-};
-
-describe("The AgentService", function () {
-    let testWindow;
-    let agentService;
-
-    beforeEach(function () {
-        testWindow = {
-            innerWidth: 640,
-            innerHeight: 480,
-            navigator: {
-                userAgent: TEST_USER_AGENTS.DESKTOP
-            }
-        };
-    });
-
-    it("recognizes desktop devices as non-mobile", function () {
-        testWindow.navigator.userAgent = TEST_USER_AGENTS.DESKTOP;
-        agentService = new AgentService(testWindow);
-        expect(agentService.isMobile()).toBeFalsy();
-        expect(agentService.isPhone()).toBeFalsy();
-        expect(agentService.isTablet()).toBeFalsy();
-    });
-
-    it("detects iPhones", function () {
-        testWindow.navigator.userAgent = TEST_USER_AGENTS.IPHONE;
-        agentService = new AgentService(testWindow);
-        expect(agentService.isMobile()).toBeTruthy();
-        expect(agentService.isPhone()).toBeTruthy();
-        expect(agentService.isTablet()).toBeFalsy();
-    });
-
-    it("detects iPads", function () {
-        testWindow.navigator.userAgent = TEST_USER_AGENTS.IPAD;
-        agentService = new AgentService(testWindow);
-        expect(agentService.isMobile()).toBeTruthy();
-        expect(agentService.isPhone()).toBeFalsy();
-        expect(agentService.isTablet()).toBeTruthy();
-    });
-
-    it("detects display orientation", function () {
-        agentService = new AgentService(testWindow);
-        testWindow.innerWidth = 1024;
-        testWindow.innerHeight = 400;
-        expect(agentService.isPortrait()).toBeFalsy();
-        expect(agentService.isLandscape()).toBeTruthy();
-        testWindow.innerWidth = 400;
-        testWindow.innerHeight = 1024;
-        expect(agentService.isPortrait()).toBeTruthy();
-        expect(agentService.isLandscape()).toBeFalsy();
-    });
-
-    it("detects touch support", function () {
-        testWindow.ontouchstart = null;
-        expect(new AgentService(testWindow).isTouch()).toBe(true);
-        delete testWindow.ontouchstart;
-        expect(new AgentService(testWindow).isTouch()).toBe(false);
-    });
-
-    it("allows for checking browser type", function () {
-        testWindow.navigator.userAgent = "Chromezilla Safarifox";
-        agentService = new AgentService(testWindow);
-        expect(agentService.isBrowser("Chrome")).toBe(true);
-        expect(agentService.isBrowser("Firefox")).toBe(false);
-    });
-});

platform/commonUI/mobile/src/DeviceClassifier.js

@@ -0,0 +1,72 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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(
+    ['./DeviceMatchers'],
+    function (DeviceMatchers) {
+
+        /**
+         * Runs at application startup and adds a subset of the following
+         * CSS classes to the body of the document, depending on device
+         * attributes:
+         *
+         * * `mobile`: Phones or tablets.
+         * * `phone`: Phones specifically.
+         * * `tablet`: Tablets specifically.
+         * * `desktop`: Non-mobile devices.
+         * * `portrait`: Devices in a portrait-style orientation.
+         * * `landscape`: Devices in a landscape-style orientation.
+         * * `touch`: Device supports touch events.
+         *
+         * @param {platform/commonUI/mobile.AgentService} agentService
+         *        the service used to examine the user agent
+         * @param $document Angular's jqLite-wrapped document element
+         * @constructor
+         */
+        function MobileClassifier(agentService, $document) {
+            var body = $document.find('body');
+
+            Object.keys(DeviceMatchers).forEach(function (key, index, array) {
+                if (DeviceMatchers[key](agentService)) {
+                    body.addClass(key);
+                }
+            });
+
+            if (agentService.isMobile()) {
+                var mediaQuery = window.matchMedia('(orientation: landscape)');
+
+                mediaQuery.addListener(function (event) {
+                    if (event.matches) {
+                        body.removeClass('portrait');
+                        body.addClass('landscape');
+                    } else {
+                        body.removeClass('landscape');
+                        body.addClass('portrait');
+                    }
+                });
+            }
+        }
+
+        return MobileClassifier;
+
+    }
+);

platform/commonUI/mobile/src/DeviceMatchers.js

@@ -0,0 +1,58 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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(function () {
+
+    /**
+     * An object containing key-value pairs, where keys are symbolic of
+     * device attributes, and values are functions that take the
+     * `agentService` as inputs and return boolean values indicating
+     * whether or not the current device has these attributes.
+     *
+     * For internal use by the mobile support bundle.
+     *
+     * @memberof platform/commonUI/mobile
+     * @private
+     */
+    return {
+        mobile: function (agentService) {
+            return agentService.isMobile();
+        },
+        phone: function (agentService) {
+            return agentService.isPhone();
+        },
+        tablet: function (agentService) {
+            return agentService.isTablet();
+        },
+        desktop: function (agentService) {
+            return !agentService.isMobile();
+        },
+        portrait: function (agentService) {
+            return agentService.isPortrait();
+        },
+        landscape: function (agentService) {
+            return agentService.isLandscape();
+        },
+        touch: function (agentService) {
+            return agentService.isTouch();
+        }
+    };
+});

platform/commonUI/mobile/src/MCTDevice.js

@@ -0,0 +1,88 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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(
+    ['./DeviceMatchers'],
+    function (DeviceMatchers) {
+
+        /**
+         * The `mct-device` directive, when applied as an attribute,
+         * only includes the element when the device being used matches
+         * a set of characteristics required.
+         *
+         * Required characteristics are given as space-separated strings
+         * as the value to this attribute, e.g.:
+         *
+         *    <span mct-device="mobile portrait">Hello world!</span>
+         *
+         * ...will only show Hello world! when viewed on a mobile device
+         * in the portrait orientation.
+         *
+         * Valid device characteristics to detect are:
+         *
+         * * `mobile`: Phones or tablets.
+         * * `phone`: Phones specifically.
+         * * `tablet`: Tablets specifically.
+         * * `desktop`: Non-mobile devices.
+         * * `portrait`: Devices in a portrait-style orientation.
+         * * `landscape`: Devices in a landscape-style orientation.
+         * * `touch`: Device supports touch events.
+         *
+         * @param {AgentService} agentService used to detect device type
+         *        based on information about the user agent
+         */
+        function MCTDevice(agentService) {
+
+            function deviceMatches(tokens) {
+                tokens = tokens || "";
+
+                return tokens.split(" ").every(function (token) {
+                    var fn = DeviceMatchers[token];
+
+                    return fn && fn(agentService);
+                });
+            }
+
+            function link(scope, element, attrs, ctrl, transclude) {
+                if (deviceMatches(attrs.mctDevice)) {
+                    transclude(function (clone) {
+                        element.replaceWith(clone);
+                    });
+                }
+            }
+
+            return {
+                link: link,
+                // We are transcluding the whole element (like ng-if)
+                transclude: 'element',
+                // 1 more than ng-if
+                priority: 601,
+                // Also terminal, since element will be transcluded
+                terminal: true,
+                // Only apply as an attribute
+                restrict: "A"
+            };
+        }
+
+        return MCTDevice;
+    }
+);

platform/commonUI/mobile/test/AgentServiceSpec.js

@@ -0,0 +1,99 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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(
+    ["../src/AgentService"],
+    function (AgentService) {
+
+        var TEST_USER_AGENTS = {
+            DESKTOP: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.89 Safari/537.36",
+            IPAD: "Mozilla/5.0 (iPad; CPU OS 7_0 like Mac OS X) AppleWebKit/537.51.1 (KHTML, like Gecko) Version/7.0 Mobile/11A465 Safari/9537.53",
+            IPHONE: "Mozilla/5.0 (iPhone; CPU iPhone OS 7_0 like Mac OS X; en-us) AppleWebKit/537.51.1 (KHTML, like Gecko) Version/7.0 Mobile/11A465 Safari/9537.53"
+        };
+
+        describe("The AgentService", function () {
+            var testWindow, agentService;
+
+            beforeEach(function () {
+                testWindow = {
+                    innerWidth: 640,
+                    innerHeight: 480,
+                    navigator: {
+                        userAgent: TEST_USER_AGENTS.DESKTOP
+                    }
+                };
+            });
+
+            it("recognizes desktop devices as non-mobile", function () {
+                testWindow.navigator.userAgent = TEST_USER_AGENTS.DESKTOP;
+                agentService = new AgentService(testWindow);
+                expect(agentService.isMobile()).toBeFalsy();
+                expect(agentService.isPhone()).toBeFalsy();
+                expect(agentService.isTablet()).toBeFalsy();
+            });
+
+            it("detects iPhones", function () {
+                testWindow.navigator.userAgent = TEST_USER_AGENTS.IPHONE;
+                agentService = new AgentService(testWindow);
+                expect(agentService.isMobile()).toBeTruthy();
+                expect(agentService.isPhone()).toBeTruthy();
+                expect(agentService.isTablet()).toBeFalsy();
+            });
+
+            it("detects iPads", function () {
+                testWindow.navigator.userAgent = TEST_USER_AGENTS.IPAD;
+                agentService = new AgentService(testWindow);
+                expect(agentService.isMobile()).toBeTruthy();
+                expect(agentService.isPhone()).toBeFalsy();
+                expect(agentService.isTablet()).toBeTruthy();
+            });
+
+            it("detects display orientation", function () {
+                agentService = new AgentService(testWindow);
+                testWindow.innerWidth = 1024;
+                testWindow.innerHeight = 400;
+                expect(agentService.isPortrait()).toBeFalsy();
+                expect(agentService.isLandscape()).toBeTruthy();
+                testWindow.innerWidth = 400;
+                testWindow.innerHeight = 1024;
+                expect(agentService.isPortrait()).toBeTruthy();
+                expect(agentService.isLandscape()).toBeFalsy();
+            });
+
+            it("detects touch support", function () {
+                testWindow.ontouchstart = null;
+                expect(new AgentService(testWindow).isTouch())
+                    .toBe(true);
+                delete testWindow.ontouchstart;
+                expect(new AgentService(testWindow).isTouch())
+                    .toBe(false);
+            });
+
+            it("allows for checking browser type", function () {
+                testWindow.navigator.userAgent = "Chromezilla Safarifox";
+                agentService = new AgentService(testWindow);
+                expect(agentService.isBrowser("Chrome")).toBe(true);
+                expect(agentService.isBrowser("Firefox")).toBe(false);
+            });
+        });
+    }
+);

platform/commonUI/mobile/test/DeviceClassifierSpec.js

@@ -0,0 +1,109 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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(
+    ["../src/DeviceClassifier", "../src/DeviceMatchers"],
+    function (DeviceClassifier, DeviceMatchers) {
+
+        var AGENT_SERVICE_METHODS = [
+                'isMobile',
+                'isPhone',
+                'isTablet',
+                'isPortrait',
+                'isLandscape',
+                'isTouch'
+            ],
+            TEST_PERMUTATIONS = [
+                ['isMobile', 'isPhone', 'isTouch', 'isPortrait'],
+                ['isMobile', 'isPhone', 'isTouch', 'isLandscape'],
+                ['isMobile', 'isTablet', 'isTouch', 'isPortrait'],
+                ['isMobile', 'isTablet', 'isTouch', 'isLandscape'],
+                ['isTouch'],
+                []
+            ];
+
+        describe("DeviceClassifier", function () {
+            var mockAgentService,
+                mockDocument,
+                mockBody;
+
+            beforeEach(function () {
+                mockAgentService = jasmine.createSpyObj(
+                    'agentService',
+                    AGENT_SERVICE_METHODS
+                );
+                mockDocument = jasmine.createSpyObj(
+                    '$document',
+                    ['find']
+                );
+                mockBody = jasmine.createSpyObj(
+                    'body',
+                    ['addClass']
+                );
+                mockDocument.find.and.callFake(function (sel) {
+                    return sel === 'body' && mockBody;
+                });
+                AGENT_SERVICE_METHODS.forEach(function (m) {
+                    mockAgentService[m].and.returnValue(false);
+                });
+            });
+
+            TEST_PERMUTATIONS.forEach(function (trueMethods) {
+                var summary = trueMethods.length === 0
+                    ? "device has no detected characteristics"
+                    : "device " + (trueMethods.join(", "));
+
+                describe("when " + summary, function () {
+                    var classifier; // eslint-disable-line
+
+                    beforeEach(function () {
+                        trueMethods.forEach(function (m) {
+                            mockAgentService[m].and.returnValue(true);
+                        });
+                        classifier = new DeviceClassifier(
+                            mockAgentService,
+                            mockDocument
+                        );
+                    });
+
+                    it("adds classes for matching, detected characteristics", function () {
+                        Object.keys(DeviceMatchers).filter(function (m) {
+                            return DeviceMatchers[m](mockAgentService);
+                        }).forEach(function (key) {
+                            expect(mockBody.addClass)
+                                .toHaveBeenCalledWith(key);
+                        });
+                    });
+
+                    it("does not add classes for non-matching characteristics", function () {
+                        Object.keys(DeviceMatchers).filter(function (m) {
+                            return !DeviceMatchers[m](mockAgentService);
+                        }).forEach(function (key) {
+                            expect(mockBody.addClass)
+                                .not.toHaveBeenCalledWith(key);
+                        });
+                    });
+                });
+            });
+        });
+    }
+);

platform/commonUI/mobile/test/DeviceMatchersSpec.js

@@ -0,0 +1,78 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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(
+    ["../src/DeviceMatchers"],
+    function (DeviceMatchers) {
+
+        describe("DeviceMatchers", function () {
+            var mockAgentService;
+
+            beforeEach(function () {
+                mockAgentService = jasmine.createSpyObj(
+                    'agentService',
+                    [
+                        'isMobile',
+                        'isPhone',
+                        'isTablet',
+                        'isPortrait',
+                        'isLandscape',
+                        'isTouch'
+                    ]
+                );
+            });
+
+            it("detects when a device is a desktop device", function () {
+                mockAgentService.isMobile.and.returnValue(false);
+                expect(DeviceMatchers.desktop(mockAgentService))
+                    .toBe(true);
+                mockAgentService.isMobile.and.returnValue(true);
+                expect(DeviceMatchers.desktop(mockAgentService))
+                    .toBe(false);
+            });
+
+            function method(deviceType) {
+                return "is" + deviceType[0].toUpperCase() + deviceType.slice(1);
+            }
+
+            [
+                "mobile",
+                "phone",
+                "tablet",
+                "landscape",
+                "portrait",
+                "landscape",
+                "touch"
+            ].forEach(function (deviceType) {
+                it("detects when a device is a " + deviceType + " device", function () {
+                    mockAgentService[method(deviceType)].and.returnValue(true);
+                    expect(DeviceMatchers[deviceType](mockAgentService))
+                        .toBe(true);
+                    mockAgentService[method(deviceType)].and.returnValue(false);
+                    expect(DeviceMatchers[deviceType](mockAgentService))
+                        .toBe(false);
+                });
+            });
+
+        });
+    }
+);

platform/commonUI/mobile/test/MCTDeviceSpec.js

@@ -0,0 +1,168 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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(
+    ['../src/MCTDevice'],
+    function (MCTDevice) {
+
+        var JQLITE_METHODS = ['replaceWith'];
+
+        describe("The mct-device directive", function () {
+            var mockAgentService,
+                mockTransclude,
+                mockElement,
+                mockClone,
+                testAttrs,
+                directive;
+
+            function link() {
+                directive.link(null, mockElement, testAttrs, null, mockTransclude);
+            }
+
+            beforeEach(function () {
+                mockAgentService = jasmine.createSpyObj(
+                    "agentService",
+                    ["isMobile", "isPhone", "isTablet", "isPortrait", "isLandscape"]
+                );
+                mockTransclude = jasmine.createSpy("$transclude");
+                mockElement = jasmine.createSpyObj(name, JQLITE_METHODS);
+                mockClone = jasmine.createSpyObj(name, JQLITE_METHODS);
+
+                mockTransclude.and.callFake(function (fn) {
+                    fn(mockClone);
+                });
+
+                // Look desktop-like by default
+                mockAgentService.isLandscape.and.returnValue(true);
+
+                testAttrs = {};
+
+                directive = new MCTDevice(mockAgentService);
+            });
+
+            function expectInclusion() {
+                expect(mockElement.replaceWith)
+                    .toHaveBeenCalledWith(mockClone);
+            }
+
+            function expectExclusion() {
+                expect(mockElement.replaceWith).not.toHaveBeenCalled();
+            }
+
+            it("is applicable at the attribute level", function () {
+                expect(directive.restrict).toEqual("A");
+            });
+
+            it("transcludes at the element level", function () {
+                expect(directive.transclude).toEqual('element');
+            });
+
+            it("has a greater priority number than ng-if", function () {
+                expect(directive.priority > 600).toBeTruthy();
+            });
+
+            it("restricts element inclusion for mobile devices", function () {
+                testAttrs.mctDevice = "mobile";
+                link();
+                expectExclusion();
+
+                mockAgentService.isMobile.and.returnValue(true);
+                link();
+                expectInclusion();
+            });
+
+            it("restricts element inclusion for tablet devices", function () {
+                testAttrs.mctDevice = "tablet";
+                mockAgentService.isMobile.and.returnValue(true);
+                link();
+                expectExclusion();
+
+                mockAgentService.isTablet.and.returnValue(true);
+                link();
+                expectInclusion();
+            });
+
+            it("restricts element inclusion for phone devices", function () {
+                testAttrs.mctDevice = "phone";
+                mockAgentService.isMobile.and.returnValue(true);
+                link();
+                expectExclusion();
+
+                mockAgentService.isPhone.and.returnValue(true);
+                link();
+                expectInclusion();
+            });
+
+            it("restricts element inclusion for desktop devices", function () {
+                testAttrs.mctDevice = "desktop";
+                mockAgentService.isMobile.and.returnValue(true);
+                link();
+                expectExclusion();
+
+                mockAgentService.isMobile.and.returnValue(false);
+                link();
+                expectInclusion();
+            });
+
+            it("restricts element inclusion for portrait orientation", function () {
+                testAttrs.mctDevice = "portrait";
+                link();
+                expectExclusion();
+
+                mockAgentService.isPortrait.and.returnValue(true);
+                link();
+                expectInclusion();
+            });
+
+            it("restricts element inclusion for landscape orientation", function () {
+                testAttrs.mctDevice = "landscape";
+                mockAgentService.isLandscape.and.returnValue(false);
+                mockAgentService.isPortrait.and.returnValue(true);
+                link();
+                expectExclusion();
+
+                mockAgentService.isLandscape.and.returnValue(true);
+                link();
+                expectInclusion();
+            });
+
+            it("allows multiple device characteristics to be requested", function () {
+                // Won't try to test every permutation here, just
+                // make sure the multi-characteristic feature has support.
+                testAttrs.mctDevice = "portrait mobile";
+                link();
+                // Neither portrait nor mobile, not called
+                expectExclusion();
+
+                mockAgentService.isPortrait.and.returnValue(true);
+                link();
+
+                // Was portrait, but not mobile, so no
+                expectExclusion();
+
+                mockAgentService.isMobile.and.returnValue(true);
+                link();
+                expectInclusion();
+            });
+        });
+    }
+);

platform/containment/test/ComposeActionPolicySpec.js

@@ -0,0 +1,95 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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(
+    ["../src/ComposeActionPolicy"],
+    function (ComposeActionPolicy) {
+        xdescribe("The compose action policy", function () {
+            var mockInjector,
+                mockPolicyService,
+                mockTypes,
+                mockDomainObjects,
+                mockAction,
+                testContext,
+                policy;
+
+            beforeEach(function () {
+                mockInjector = jasmine.createSpyObj('$injector', ['get']);
+                mockPolicyService = jasmine.createSpyObj(
+                    'policyService',
+                    ['allow']
+                );
+                mockTypes = ['a', 'b'].map(function (type) {
+                    var mockType = jasmine.createSpyObj('type-' + type, ['getKey']);
+                    mockType.getKey.and.returnValue(type);
+
+                    return mockType;
+                });
+                mockDomainObjects = ['a', 'b'].map(function (id, index) {
+                    var mockDomainObject = jasmine.createSpyObj(
+                        'domainObject-' + id,
+                        ['getId', 'getCapability']
+                    );
+                    mockDomainObject.getId.and.returnValue(id);
+                    mockDomainObject.getCapability.and.callFake(function (c) {
+                        return c === 'type' && mockTypes[index];
+                    });
+
+                    return mockDomainObject;
+                });
+                mockAction = jasmine.createSpyObj('action', ['getMetadata']);
+
+                testContext = {
+                    key: 'compose',
+                    domainObject: mockDomainObjects[0],
+                    selectedObject: mockDomainObjects[1]
+                };
+
+                mockAction.getMetadata.and.returnValue(testContext);
+                mockInjector.get.and.callFake(function (service) {
+                    return service === 'policyService' && mockPolicyService;
+                });
+
+                policy = new ComposeActionPolicy(mockInjector);
+            });
+
+            it("defers to composition policy", function () {
+                mockPolicyService.allow.and.returnValue(false);
+                expect(policy.allow(mockAction, testContext)).toBeFalsy();
+                mockPolicyService.allow.and.returnValue(true);
+                expect(policy.allow(mockAction, testContext)).toBeTruthy();
+
+                expect(mockPolicyService.allow).toHaveBeenCalledWith(
+                    'composition',
+                    mockDomainObjects[0],
+                    mockDomainObjects[1]
+                );
+            });
+
+            it("allows actions other than compose", function () {
+                testContext.key = 'somethingElse';
+                mockPolicyService.allow.and.returnValue(false);
+                expect(policy.allow(mockAction, testContext)).toBeTruthy();
+            });
+        });
+    }
+);

platform/core/bundle.js

@@ -379,7 +379,7 @@ define([
                     {
                         "name": "Math.uuid.js",
                         "version": "1.4.7",
-                        "description": "Unique identifier generation (code adapted.)",
+                        "description": "Unique identifer generation (code adapted.)",
                         "author": "Robert Kieffer",
                         "website": "https://github.com/broofa/node-uuid",
                         "copyright": "Copyright (c) 2010-2012 Robert Kieffer",

platform/features/clock/bundle.js

@@ -21,32 +21,24 @@
  *****************************************************************************/
 
 define([
-    "moment-timezone",
-    "./src/indicators/ClockIndicator",
     "./src/services/TickerService",
     "./src/services/TimerService",
-    "./src/controllers/ClockController",
     "./src/controllers/TimerController",
     "./src/controllers/RefreshingController",
     "./src/actions/StartTimerAction",
     "./src/actions/RestartTimerAction",
     "./src/actions/StopTimerAction",
     "./src/actions/PauseTimerAction",
-    "./res/templates/clock.html",
     "./res/templates/timer.html"
 ], function (
-    MomentTimezone,
-    ClockIndicator,
     TickerService,
     TimerService,
-    ClockController,
     TimerController,
     RefreshingController,
     StartTimerAction,
     RestartTimerAction,
     StopTimerAction,
     PauseTimerAction,
-    clockTemplate,
     timerTemplate
 ) {
     return {
@@ -73,24 +65,13 @@ define([
                         "value": "YYYY/MM/DD HH:mm:ss"
                     }
                 ],
-                "indicators": [
-                    {
-                        "implementation": ClockIndicator,
-                        "depends": [
-                            "tickerService",
-                            "CLOCK_INDICATOR_FORMAT"
-                        ],
-                        "priority": "preferred"
-                    }
-                ],
                 "services": [
                     {
                         "key": "tickerService",
                         "implementation": TickerService,
                         "depends": [
                             "$timeout",
-                            "now",
-                            "$rootScope"
+                            "now"
                         ]
                     },
                     {
@@ -100,14 +81,6 @@ define([
                     }
                 ],
                 "controllers": [
-                    {
-                        "key": "ClockController",
-                        "implementation": ClockController,
-                        "depends": [
-                            "$scope",
-                            "tickerService"
-                        ]
-                    },
                     {
                         "key": "TimerController",
                         "implementation": TimerController,
@@ -127,12 +100,6 @@ define([
                     }
                 ],
                 "views": [
-                    {
-                        "key": "clock",
-                        "type": "clock",
-                        "editable": false,
-                        "template": clockTemplate
-                    },
                     {
                         "key": "timer",
                         "type": "timer",
@@ -187,70 +154,6 @@ define([
                     }
                 ],
                 "types": [
-                    {
-                        "key": "clock",
-                        "name": "Clock",
-                        "cssClass": "icon-clock",
-                        "description": "A UTC-based clock that supports a variety of display formats. Clocks can be added to Display Layouts.",
-                        "priority": 101,
-                        "features": [
-                            "creation"
-                        ],
-                        "properties": [
-                            {
-                                "key": "clockFormat",
-                                "name": "Display Format",
-                                "control": "composite",
-                                "items": [
-                                    {
-                                        "control": "select",
-                                        "options": [
-                                            {
-                                                "value": "YYYY/MM/DD hh:mm:ss",
-                                                "name": "YYYY/MM/DD hh:mm:ss"
-                                            },
-                                            {
-                                                "value": "YYYY/DDD hh:mm:ss",
-                                                "name": "YYYY/DDD hh:mm:ss"
-                                            },
-                                            {
-                                                "value": "hh:mm:ss",
-                                                "name": "hh:mm:ss"
-                                            }
-                                        ],
-                                        "cssClass": "l-inline"
-                                    },
-                                    {
-                                        "control": "select",
-                                        "options": [
-                                            {
-                                                "value": "clock12",
-                                                "name": "12hr"
-                                            },
-                                            {
-                                                "value": "clock24",
-                                                "name": "24hr"
-                                            }
-                                        ],
-                                        "cssClass": "l-inline"
-                                    }
-                                ]
-                            },
-                            {
-                                "key": "timezone",
-                                "name": "Timezone",
-                                "control": "autocomplete",
-                                "options": MomentTimezone.tz.names()
-                            }
-                        ],
-                        "model": {
-                            "clockFormat": [
-                                "YYYY/MM/DD hh:mm:ss",
-                                "clock12"
-                            ],
-                            "timezone": "UTC"
-                        }
-                    },
                     {
                         "key": "timer",
                         "name": "Timer",

platform/features/clock/res/templates/clock.html

@@ -1,32 +0,0 @@
-<!--
- Open MCT, Copyright (c) 2009-2016, United States Government
- as represented by the Administrator of the National Aeronautics and Space
- Administration. All rights reserved.
-
- Open MCT 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 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.
--->
-<div class="c-clock l-time-display u-style-receiver js-style-receiver" ng-controller="ClockController as clock">
-	<div class="c-clock__timezone">
-		{{clock.zone()}}
-	</div>
-	<div class="c-clock__value">
-		{{clock.text()}}
-	</div>
-	<div class="c-clock__ampm">
-		{{clock.ampm()}}
-	</div>
-</div>

platform/features/clock/src/controllers/ClockController.js

@@ -1,110 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2009-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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([
-    'moment',
-    'moment-timezone'
-],
-function (
-    moment,
-    momentTimezone
-) {
-
-    /**
-         * Controller for views of a Clock domain object.
-         *
-         * @constructor
-         * @memberof platform/features/clock
-         * @param {angular.Scope} $scope the Angular scope
-         * @param {platform/features/clock.TickerService} tickerService
-         *        a service used to align behavior with clock ticks
-         */
-    function ClockController($scope, tickerService) {
-        var lastTimestamp,
-            unlisten,
-            timeFormat,
-            zoneName,
-            self = this;
-
-        function update() {
-            var m = zoneName
-                ? moment.utc(lastTimestamp).tz(zoneName) : moment.utc(lastTimestamp);
-            self.zoneAbbr = m.zoneAbbr();
-            self.textValue = timeFormat && m.format(timeFormat);
-            self.ampmValue = m.format("A"); // Just the AM or PM part
-        }
-
-        function tick(timestamp) {
-            lastTimestamp = timestamp;
-            update();
-        }
-
-        function updateModel(model) {
-            var baseFormat;
-            if (model !== undefined) {
-                baseFormat = model.clockFormat[0];
-
-                self.use24 = model.clockFormat[1] === 'clock24';
-                timeFormat = self.use24
-                    ? baseFormat.replace('hh', "HH") : baseFormat;
-                // If wrong timezone is provided, the UTC will be used
-                zoneName = momentTimezone.tz.names().includes(model.timezone)
-                    ? model.timezone : "UTC";
-                update();
-            }
-        }
-
-        // Pull in the model (clockFormat and timezone) from the domain object model
-        $scope.$watch('model', updateModel);
-
-        // Listen for clock ticks ... and stop listening on destroy
-        unlisten = tickerService.listen(tick);
-        $scope.$on('$destroy', unlisten);
-    }
-
-    /**
-         * Get the clock's time zone, as displayable text.
-         * @returns {string}
-         */
-    ClockController.prototype.zone = function () {
-        return this.zoneAbbr;
-    };
-
-    /**
-         * Get the current time, as displayable text.
-         * @returns {string}
-         */
-    ClockController.prototype.text = function () {
-        return this.textValue;
-    };
-
-    /**
-         * Get the text to display to qualify a time as AM or PM.
-         * @returns {string}
-         */
-    ClockController.prototype.ampm = function () {
-        return this.use24 ? '' : this.ampmValue;
-    };
-
-    return ClockController;
-}
-);

platform/features/clock/src/indicators/ClockIndicator.js

@@ -1,65 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2009-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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(
-    ['moment'],
-    function (moment) {
-
-        /**
-         * Indicator that displays the current UTC time in the status area.
-         * @implements {Indicator}
-         * @memberof platform/features/clock
-         * @param {platform/features/clock.TickerService} tickerService
-         *        a service used to align behavior with clock ticks
-         * @param {string} indicatorFormat format string for timestamps
-         *        shown in this indicator
-         */
-        function ClockIndicator(tickerService, indicatorFormat) {
-            var self = this;
-
-            this.text = "";
-
-            tickerService.listen(function (timestamp) {
-                self.text = moment.utc(timestamp)
-                    .format(indicatorFormat) + " UTC";
-            });
-        }
-
-        ClockIndicator.prototype.getGlyphClass = function () {
-            return "";
-        };
-
-        ClockIndicator.prototype.getCssClass = function () {
-            return "t-indicator-clock icon-clock no-minify c-indicator--not-clickable";
-        };
-
-        ClockIndicator.prototype.getText = function () {
-            return this.text;
-        };
-
-        ClockIndicator.prototype.getDescription = function () {
-            return "";
-        };
-
-        return ClockIndicator;
-    }
-);

platform/features/clock/src/services/TickerService.js

@@ -32,13 +32,8 @@ define(
          * @param $timeout Angular's $timeout
          * @param {Function} now function to provide the current time in ms
          */
-        function TickerService($timeout, now, $rootScope) {
+        function TickerService($timeout, now) {
             var self = this;
-            var timeoutId;
-
-            $rootScope.$on('$destroy', function () {
-                $timeout.cancel(timeoutId);
-            });
 
             function tick() {
                 var timestamp = now(),
@@ -53,7 +48,7 @@ define(
                 }
 
                 // Try to update at exactly the next second
-                timeoutId = $timeout(tick, 1000 - millis, true);
+                $timeout(tick, 1000 - millis, true);
             }
 
             tick();

platform/features/clock/test/controllers/ClockControllerSpec.js

@@ -1,107 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2009-2017, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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(
-    ["../../src/controllers/ClockController"],
-    function (ClockController) {
-
-        // Wed, 03 Jun 2015 17:56:14 GMT
-        var TEST_TIMESTAMP = 1433354174000;
-
-        describe("A clock view's controller", function () {
-            var mockScope,
-                mockTicker,
-                mockUnticker,
-                controller;
-
-            beforeEach(function () {
-                mockScope = jasmine.createSpyObj('$scope', ['$watch', '$on']);
-                mockTicker = jasmine.createSpyObj('ticker', ['listen']);
-                mockUnticker = jasmine.createSpy('unticker');
-
-                mockTicker.listen.and.returnValue(mockUnticker);
-
-                controller = new ClockController(mockScope, mockTicker);
-            });
-
-            it("watches for model (clockFormat and timezone) from the domain object model", function () {
-                expect(mockScope.$watch).toHaveBeenCalledWith(
-                    "model",
-                    jasmine.any(Function)
-                );
-            });
-
-            it("subscribes to clock ticks", function () {
-                expect(mockTicker.listen)
-                    .toHaveBeenCalledWith(jasmine.any(Function));
-            });
-
-            it("unsubscribes to ticks when destroyed", function () {
-                // Make sure $destroy is being listened for...
-                expect(mockScope.$on.calls.mostRecent().args[0]).toEqual('$destroy');
-                expect(mockUnticker).not.toHaveBeenCalled();
-
-                // ...and makes sure that its listener unsubscribes from ticker
-                mockScope.$on.calls.mostRecent().args[1]();
-                expect(mockUnticker).toHaveBeenCalled();
-            });
-
-            it("formats using the format string from the model", function () {
-                mockTicker.listen.calls.mostRecent().args[0](TEST_TIMESTAMP);
-                mockScope.$watch.calls.mostRecent().args[1]({
-                    "clockFormat": [
-                        "YYYY-DDD hh:mm:ss",
-                        "clock24"
-                    ],
-                    "timezone": "Canada/Eastern"
-                });
-
-                expect(controller.zone()).toEqual("EDT");
-                expect(controller.text()).toEqual("2015-154 13:56:14");
-                expect(controller.ampm()).toEqual("");
-            });
-
-            it("formats 12-hour time", function () {
-                mockTicker.listen.calls.mostRecent().args[0](TEST_TIMESTAMP);
-                mockScope.$watch.calls.mostRecent().args[1]({
-                    "clockFormat": [
-                        "YYYY-DDD hh:mm:ss",
-                        "clock12"
-                    ],
-                    "timezone": ""
-                });
-
-                expect(controller.zone()).toEqual("UTC");
-                expect(controller.text()).toEqual("2015-154 05:56:14");
-                expect(controller.ampm()).toEqual("PM");
-            });
-
-            it("does not throw exceptions when model is undefined", function () {
-                mockTicker.listen.calls.mostRecent().args[0](TEST_TIMESTAMP);
-                expect(function () {
-                    mockScope.$watch.calls.mostRecent().args[1](undefined);
-                }).not.toThrow();
-            });
-
-        });
-    }
-);

platform/features/clock/test/indicators/ClockIndicatorSpec.js

@@ -1,58 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2009-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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(
-    ["../../src/indicators/ClockIndicator"],
-    function (ClockIndicator) {
-
-        // Wed, 03 Jun 2015 17:56:14 GMT
-        var TEST_TIMESTAMP = 1433354174000,
-            TEST_FORMAT = "YYYY-DDD HH:mm:ss";
-
-        describe("The clock indicator", function () {
-            var mockTicker,
-                mockUnticker,
-                indicator;
-
-            beforeEach(function () {
-                mockTicker = jasmine.createSpyObj('ticker', ['listen']);
-                mockUnticker = jasmine.createSpy('unticker');
-
-                mockTicker.listen.and.returnValue(mockUnticker);
-
-                indicator = new ClockIndicator(mockTicker, TEST_FORMAT);
-            });
-
-            it("displays the current time", function () {
-                mockTicker.listen.calls.mostRecent().args[0](TEST_TIMESTAMP);
-                expect(indicator.getText()).toEqual("2015-154 17:56:14 UTC");
-            });
-
-            it("implements the Indicator interface", function () {
-                expect(indicator.getCssClass()).toEqual(jasmine.any(String));
-                expect(indicator.getText()).toEqual(jasmine.any(String));
-                expect(indicator.getDescription()).toEqual(jasmine.any(String));
-            });
-
-        });
-    }
-);

platform/features/clock/test/services/TickerServiceSpec.js

@@ -30,18 +30,16 @@ define(
             var mockTimeout,
                 mockNow,
                 mockCallback,
-                tickerService,
-                mockRootScope;
+                tickerService;
 
             beforeEach(function () {
                 mockTimeout = jasmine.createSpy('$timeout');
                 mockNow = jasmine.createSpy('now');
                 mockCallback = jasmine.createSpy('callback');
-                mockRootScope = jasmine.createSpyObj('rootScope', ['$on']);
 
                 mockNow.and.returnValue(TEST_TIMESTAMP);
 
-                tickerService = new TickerService(mockTimeout, mockNow, mockRootScope);
+                tickerService = new TickerService(mockTimeout, mockNow);
             });
 
             it("notifies listeners of clock ticks", function () {

platform/framework/src/FrameworkLayer.js

@@ -58,7 +58,7 @@ define([
     ) {
         var $http = this.$http,
             $log = this.$log,
-            app = angular.module(Constants.MODULE_NAME, []),
+            app = angular.module(Constants.MODULE_NAME, ["ngRoute"]),
             loader = new BundleLoader($http, $log, openmct.legacyRegistry),
             resolver = new BundleResolver(
                 new ExtensionResolver(

platform/framework/src/Main.js

@@ -28,7 +28,8 @@
 define(
     [
         './FrameworkLayer',
-        'angular'
+        'angular',
+        'angular-route'
     ],
     function (
         FrameworkLayer,

platform/framework/src/register/CustomRegistrars.js

@@ -138,6 +138,34 @@ define(
             }
         }
 
+        // Custom registration function for extensions of category "route"
+        function registerRoute(extension) {
+            var app = this.app,
+                $log = this.$log,
+                route = Object.create(extension);
+
+            // Adjust path for bundle
+            if (route.templateUrl) {
+                route.templateUrl = [
+                    route.bundle.path,
+                    route.bundle.resources,
+                    route.templateUrl
+                ].join(Constants.SEPARATOR);
+            }
+
+            // Log the registration
+            $log.info("Registering route: " + (route.key || route.when));
+
+            // Register the route with Angular
+            app.config(['$routeProvider', function ($routeProvider) {
+                if (route.when) {
+                    $routeProvider.when(route.when, route);
+                } else {
+                    $routeProvider.otherwise(route);
+                }
+            }]);
+        }
+
         // Handle service compositing
         function registerComponents(components) {
             var app = this.app,
@@ -166,6 +194,13 @@ define(
         CustomRegistrars.prototype.constants =
             mapUpon(registerConstant);
 
+        /**
+         * Register Angular routes.
+         * @param {Array} extensions the resolved extensions
+         */
+        CustomRegistrars.prototype.routes =
+            mapUpon(registerRoute);
+
         /**
          * Register Angular directives.
          * @param {Array} extensions the resolved extensions

platform/framework/test/register/CustomRegistrarsSpec.js

@@ -57,6 +57,7 @@ define(
                 expect(customRegistrars.directives).toBeTruthy();
                 expect(customRegistrars.controllers).toBeTruthy();
                 expect(customRegistrars.services).toBeTruthy();
+                expect(customRegistrars.routes).toBeTruthy();
                 expect(customRegistrars.constants).toBeTruthy();
                 expect(customRegistrars.runs).toBeTruthy();
             });
@@ -138,6 +139,47 @@ define(
                 expect(mockLog.warn.calls.count()).toEqual(0);
             });
 
+            it("allows routes to be registered", function () {
+                var mockRouteProvider = jasmine.createSpyObj(
+                        "$routeProvider",
+                        ["when", "otherwise"]
+                    ),
+                    bundle = {
+                        path: "test/bundle",
+                        resources: "res"
+                    },
+                    routes = [
+                        {
+                            when: "foo",
+                            templateUrl: "templates/test.html",
+                            bundle: bundle
+                        },
+                        {
+                            templateUrl: "templates/default.html",
+                            bundle: bundle
+                        }
+                    ];
+
+                customRegistrars.routes(routes);
+
+                // Give it the route provider based on its config call
+                mockApp.config.calls.all().forEach(function (call) {
+                    // Invoke the provided callback
+                    call.args[0][1](mockRouteProvider);
+                });
+
+                // The "when" clause should have been mapped to the when method...
+                expect(mockRouteProvider.when).toHaveBeenCalled();
+                expect(mockRouteProvider.when.calls.mostRecent().args[0]).toEqual("foo");
+                expect(mockRouteProvider.when.calls.mostRecent().args[1].templateUrl)
+                    .toEqual("test/bundle/res/templates/test.html");
+
+                // ...while the other should have been treated as a default route
+                expect(mockRouteProvider.otherwise).toHaveBeenCalled();
+                expect(mockRouteProvider.otherwise.calls.mostRecent().args[0].templateUrl)
+                    .toEqual("test/bundle/res/templates/default.html");
+            });
+
             it("accepts components for service compositing", function () {
                 // Most relevant code will be exercised in service compositor spec
                 expect(customRegistrars.components).toBeTruthy();

platform/import-export/bundle.js

@@ -30,8 +30,8 @@ define([
 
     return function ImportExportPlugin() {
         return function (openmct) {
-            ExportAsJSONAction.prototype.appliesTo = function (context) {
-                return this.openmct.$injector.get('policyService')
+            ExportAsJSONAction.appliesTo = function (context) {
+                return openmct.$injector.get('policyService')
                     .allow("creation", context.domainObject.getCapability("type")
                     );
             };

platform/import-export/test/actions/ExportAsJSONActionSpec.js

@@ -29,7 +29,7 @@ define(
     ],
     function (ExportAsJSONAction, domainObjectFactory, MCT, AdapterCapability) {
 
-        describe("The export JSON action", function () {
+        xdescribe("The export JSON action", function () {
 
             var context,
                 action,
@@ -102,7 +102,7 @@ define(
                 expect(action).toBeDefined();
             });
 
-            xit("doesn't export non-creatable objects in tree", function () {
+            it("doesn't export non-creatable objects in tree", function () {
                 var nonCreatableType = {
                     hasFeature:
                         function (feature) {
@@ -149,7 +149,7 @@ define(
                 });
             });
 
-            xit("can export self-containing objects", function () {
+            it("can export self-containing objects", function () {
                 var parent = domainObjectFactory({
                     name: 'parent',
                     model: {
@@ -191,7 +191,7 @@ define(
                 });
             });
 
-            xit("exports links to external objects as new objects", function () {
+            it("exports links to external objects as new objects", function () {
                 var parent = domainObjectFactory({
                     name: 'parent',
                     model: {

platform/import-export/test/actions/ImportAsJSONActionSpec.js

@@ -27,7 +27,7 @@ define(
     ],
     function (ImportAsJSONAction, domainObjectFactory) {
 
-        describe("The import JSON action", function () {
+        xdescribe("The import JSON action", function () {
 
             var context = {};
             var action,
@@ -146,7 +146,7 @@ define(
                 });
             });
 
-            xit("can import self-containing objects", function () {
+            it("can import self-containing objects", function () {
                 var compDomainObject = domainObjectFactory({
                     name: 'compObject',
                     model: { name: 'compObject'},
@@ -198,7 +198,7 @@ define(
                 });
             });
 
-            xit("assigns new ids to each imported object", function () {
+            it("assigns new ids to each imported object", function () {
                 dialogService.getUserInput.and.returnValue(Promise.resolve(
                     {
                         selectFile: {

platform/persistence/elastic/src/ElasticPersistenceProvider.js

@@ -47,7 +47,7 @@ define(
          * @param $interval Angular's $interval service
          * @param {string} space the name of the persistence space being served
          * @param {string} root the root of the path to ElasticSearch
-         * @param {string} path the path to domain objects within ElasticSearch
+         * @param {stirng} path the path to domain objects within ElasticSearch
          */
         function ElasticPersistenceProvider($http, $q, space, root, path) {
             this.spaces = [space];

platform/search/src/services/GenericSearchProvider.js

@@ -110,15 +110,8 @@ define([
             worker = workerService.run('bareBonesSearchWorker');
         }
 
-        function handleWorkerMessage(messageEvent) {
+        worker.addEventListener('message', function (messageEvent) {
             provider.onWorkerMessage(messageEvent);
-        }
-
-        worker.addEventListener('message', handleWorkerMessage);
-
-        this.openmct.once('destroy', () => {
-            worker.removeEventListener('message', handleWorkerMessage);
-            worker.terminate();
         });
 
         return worker;

src/MCT.js

@@ -31,6 +31,7 @@ define([
     'objectUtils',
     './plugins/plugins',
     './adapter/indicators/legacy-indicators-plugin',
+    './plugins/buildInfo/plugin',
     './ui/registries/ViewRegistry',
     './plugins/imagery/plugin',
     './ui/registries/InspectorViewRegistry',
@@ -39,7 +40,6 @@ define([
     './ui/router/Browse',
     '../platform/framework/src/Main',
     './ui/layout/Layout.vue',
-    './ui/inspector/styles/StylesManager',
     '../platform/core/src/objects/DomainObjectImpl',
     '../platform/core/src/capabilities/ContextualDomainObject',
     './ui/preview/plugin',
@@ -60,6 +60,7 @@ define([
     objectUtils,
     plugins,
     LegacyIndicatorsPlugin,
+    buildInfoPlugin,
     ViewRegistry,
     ImageryPlugin,
     InspectorViewRegistry,
@@ -68,7 +69,6 @@ define([
     Browse,
     Main,
     Layout,
-    stylesManager,
     DomainObjectImpl,
     ContextualDomainObject,
     PreviewPlugin,
@@ -123,7 +123,6 @@ define([
         };
 
         this.destroy = this.destroy.bind(this);
-
         /**
          * Tracks current selection state of the application.
          * @private
@@ -288,7 +287,6 @@ define([
         this.install(this.plugins.ViewLargeAction());
         this.install(this.plugins.ObjectInterceptors());
         this.install(this.plugins.NonEditableFolder());
-        this.install(this.plugins.DeviceClassifier());
     }
 
     MCT.prototype = Object.create(EventEmitter.prototype);
@@ -377,7 +375,6 @@ define([
      *        MCT; if undefined, MCT will be run in the body of the document
      */
     MCT.prototype.start = function (domElement = document.body, isHeadlessMode = false) {
-
         if (this.types.get('layout') === undefined) {
             this.install(this.plugins.DisplayLayout({
                 showAsView: ['summary-widget']
@@ -436,9 +433,6 @@ define([
                     domElement.appendChild(appLayout.$mount().$el);
 
                     this.layout = appLayout.$refs.layout;
-                    this.once('destroy', () => {
-                        appLayout.$destroy();
-                    });
                     Browse(this);
                 }
 
@@ -467,40 +461,9 @@ define([
     };
 
     MCT.prototype.destroy = function () {
-        if (this._destroyed === true) {
-            return;
-        }
-
         window.removeEventListener('beforeunload', this.destroy);
-
         this.emit('destroy');
-        this.removeAllListeners();
-
-        if (this.$injector) {
-            this.$injector.get('$rootScope').$destroy();
-            this.$injector = null;
-        }
-
-        if (this.$angular) {
-            this.$angular.element(this.element).off().removeData();
-            this.$angular.element(this.element).empty();
-            this.$angular = null;
-        }
-
-        this.overlays.destroy();
-
-        if (this.element) {
-            this.element.remove();
-        }
-
-        stylesManager.default.removeAllListeners();
-
-        window.angular = null;
-        window.openmct = null;
-
-        Object.keys(require.cache).forEach(key => delete require.cache[key]);
-
-        this._destroyed = true;
+        this.router.destroy();
     };
 
     MCT.prototype.plugins = plugins;

src/adapter/runs/AlternateCompositionInitializer.js

@@ -32,10 +32,6 @@ define([
     // cannot be injected.
     function AlternateCompositionInitializer(openmct) {
         AlternateCompositionCapability.appliesTo = function (model, id) {
-            openmct.once('destroy', () => {
-                delete AlternateCompositionCapability.appliesTo;
-            });
-
             model = objectUtils.toNewFormat(model, id || '');
 
             return Boolean(openmct.composition.get(model));

src/api/Editor.js

@@ -28,10 +28,6 @@ export default class Editor extends EventEmitter {
         super();
         this.editing = false;
         this.openmct = openmct;
-
-        openmct.once('destroy', () => {
-            this.removeAllListeners();
-        });
     }
 
     /**

src/api/actions/ActionCollectionSpec.js

@@ -44,15 +44,7 @@ describe('The ActionCollection', () => {
             }
         });
 
-        openmct.$injector.get.and.callFake((key) => {
-            return {
-                'identifierService': mockIdentifierService,
-                '$rootScope': {
-                    '$destroy': () => {}
-                }
-            }[key];
-        });
-
+        openmct.$injector.get.and.returnValue(mockIdentifierService);
         mockObjectPath = [
             {
                 name: 'mock folder',

src/api/actions/ActionsAPI.js

@@ -60,7 +60,9 @@ class ActionsAPI extends EventEmitter {
     }
 
     _getCachedActionCollection(objectPath, view) {
-        return this._actionCollections.get(view);
+        let cachedActionCollection = this._actionCollections.get(view);
+
+        return cachedActionCollection;
     }
 
     _newActionCollection(objectPath, view, skipEnvironmentObservers) {

src/api/notifications/NotificationAPI.js

@@ -42,7 +42,7 @@ import EventEmitter from 'EventEmitter';
  *
  * @typedef {object} NotificationModel
  * @property {string} message The message to be displayed by the notification
- * @property {number | 'unknown'} [progress] The progress of some ongoing task. Should be a number between 0 and 100, or
+ * @property {number | 'unknown'} [progress] The progres of some ongoing task. Should be a number between 0 and 100, or
  * with the string literal 'unknown'.
  * @property {string} [progressText] A message conveying progress of some ongoing task.
 
@@ -98,7 +98,7 @@ export default class NotificationAPI extends EventEmitter {
      * Present an alert to the user.
      * @param {string} message The message to display to the user.
      * @param {Object} [options] object with following properties
-     *      autoDismissTimeout: {number} in milliseconds to automatically dismisses notification
+     *      autoDismissTimeout: {number} in miliseconds to automatically dismisses notification
      *      link: {Object} Add a link to notifications for navigation
      *              onClick: callback function
      *              cssClass: css class name to add style on link
@@ -119,7 +119,7 @@ export default class NotificationAPI extends EventEmitter {
      * Present an error message to the user
      * @param {string} message
      * @param {Object} [options] object with following properties
-     *      autoDismissTimeout: {number} in milliseconds to automatically dismisses notification
+     *      autoDismissTimeout: {number} in miliseconds to automatically dismisses notification
      *      link: {Object} Add a link to notifications for navigation
      *              onClick: callback function
      *              cssClass: css class name to add style on link

src/api/overlays/OverlayAPI.js

@@ -17,7 +17,11 @@ class OverlayAPI {
 
         this.dismissLastOverlay = this.dismissLastOverlay.bind(this);
 
-        document.addEventListener('keyup', this.dismissLastOverlay);
+        document.addEventListener('keyup', (event) => {
+            if (event.key === 'Escape') {
+                this.dismissLastOverlay();
+            }
+        });
 
     }
 
@@ -45,12 +49,10 @@ class OverlayAPI {
     /**
      * private
      */
-    dismissLastOverlay(event) {
-        if (event.key === 'Escape') {
-            let lastOverlay = this.activeOverlays[this.activeOverlays.length - 1];
-            if (lastOverlay && lastOverlay.dismissable) {
-                lastOverlay.dismiss();
-            }
+    dismissLastOverlay() {
+        let lastOverlay = this.activeOverlays[this.activeOverlays.length - 1];
+        if (lastOverlay && lastOverlay.dismissable) {
+            lastOverlay.dismiss();
         }
     }
 
@@ -127,10 +129,6 @@ class OverlayAPI {
         return progressDialog;
     }
 
-    destroy() {
-        document.removeEventListener('keyup', this.dismissLastOverlay);
-    }
-
 }
 
 export default OverlayAPI;

src/api/overlays/components/OverlayComponent.vue

@@ -12,7 +12,7 @@
         ></button>
         <div
             ref="element"
-            class="c-overlay__contents js-notebook-snapshot-item-wrapper"
+            class="c-overlay__contents"
             tabindex="0"
         ></div>
         <div

src/api/status/StatusAPI.js

@@ -32,10 +32,6 @@ export default class StatusAPI extends EventEmitter {
         this.get = this.get.bind(this);
         this.set = this.set.bind(this);
         this.observe = this.observe.bind(this);
-
-        openmct.once('destroy', () => {
-            this.removeAllListeners();
-        });
     }
 
     get(identifier) {

src/api/telemetry/TelemetryAPI.js

@@ -20,8 +20,6 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-const { TelemetryCollection } = require("./TelemetryCollection");
-
 define([
     '../../plugins/displayLayout/CustomStringFormatter',
     './TelemetryMetadataManager',
@@ -275,28 +273,6 @@ define([
         }
     };
 
-    /**
-     * Request telemetry collection 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 requestCollection
-     * @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 telemetry collection request
-     * @returns {TelemetryCollection} a TelemetryCollection instance
-     */
-    TelemetryAPI.prototype.requestCollection = function (domainObject, options = {}) {
-        return new TelemetryCollection(
-            this.openmct,
-            domainObject,
-            options
-        );
-    };
-
     /**
      * Request historical telemetry for a domain object.
      * The `options` argument allows you to specify filters

src/api/telemetry/TelemetryCollection.js

@@ -1,388 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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.
- *****************************************************************************/
-
-import _ from 'lodash';
-import EventEmitter from 'EventEmitter';
-
-const ERRORS = {
-    TIMESYSTEM_KEY: 'All telemetry metadata must have a telemetry value with a key that matches the key of the active time system.',
-    LOADED: 'Telemetry Collection has already been loaded.'
-};
-
-/** Class representing a Telemetry Collection. */
-
-export class TelemetryCollection extends EventEmitter {
-    /**
-     * Creates a Telemetry Collection
-     *
-     * @param  {object} openmct - Openm MCT
-     * @param  {object} domainObject - Domain Object to user for telemetry collection
-     * @param  {object} options - Any options passed in for request/subscribe
-     */
-    constructor(openmct, domainObject, options) {
-        super();
-
-        this.loaded = false;
-        this.openmct = openmct;
-        this.domainObject = domainObject;
-        this.boundedTelemetry = [];
-        this.futureBuffer = [];
-        this.parseTime = undefined;
-        this.metadata = this.openmct.telemetry.getMetadata(domainObject);
-        this.unsubscribe = undefined;
-        this.historicalProvider = undefined;
-        this.options = options;
-        this.pageState = undefined;
-        this.lastBounds = undefined;
-        this.requestAbort = undefined;
-    }
-
-    /**
-     * This will start the requests for historical and realtime data,
-     * as well as setting up initial values and watchers
-     */
-    load() {
-        if (this.loaded) {
-            this._error(ERRORS.LOADED);
-        }
-
-        this._timeSystem(this.openmct.time.timeSystem());
-        this.lastBounds = this.openmct.time.bounds();
-
-        this._watchBounds();
-        this._watchTimeSystem();
-
-        this._initiateHistoricalRequests();
-        this._initiateSubscriptionTelemetry();
-
-        this.loaded = true;
-    }
-
-    /**
-     * can/should be called by the requester of the telemetry collection
-     * to remove any listeners
-     */
-    destroy() {
-        if (this.requestAbort) {
-            this.requestAbort.abort();
-        }
-
-        this._unwatchBounds();
-        this._unwatchTimeSystem();
-        if (this.unsubscribe) {
-            this.unsubscribe();
-        }
-
-        this.removeAllListeners();
-    }
-
-    /**
-     * This will start the requests for historical and realtime data,
-     * as well as setting up initial values and watchers
-     */
-    getAll() {
-        return this.boundedTelemetry;
-    }
-
-    /**
-     * Sets up  the telemetry collection for historical requests,
-     * this uses the "standardizeRequestOptions" from Telemetry API
-     * @private
-     */
-    _initiateHistoricalRequests() {
-        this.openmct.telemetry.standardizeRequestOptions(this.options);
-        this.historicalProvider = this.openmct.telemetry.
-            findRequestProvider(this.domainObject, this.options);
-
-        this._requestHistoricalTelemetry();
-    }
-    /**
-     * If a historical provider exists, then historical requests will be made
-     * @private
-     */
-    async _requestHistoricalTelemetry() {
-        if (!this.historicalProvider) {
-            return;
-        }
-
-        let historicalData;
-
-        try {
-            this.requestAbort = new AbortController();
-            this.options.signal = this.requestAbort.signal;
-            historicalData = await this.historicalProvider.request(this.domainObject, this.options);
-            this.requestAbort = undefined;
-        } catch (error) {
-            console.error('Error requesting telemetry data...');
-            this.requestAbort = undefined;
-            this._error(error);
-        }
-
-        this._processNewTelemetry(historicalData);
-
-    }
-    /**
-     * This uses the built in subscription function from Telemetry API
-     * @private
-     */
-    _initiateSubscriptionTelemetry() {
-
-        if (this.unsubscribe) {
-            this.unsubscribe();
-        }
-
-        this.unsubscribe = this.openmct.telemetry
-            .subscribe(
-                this.domainObject,
-                datum => this._processNewTelemetry(datum),
-                this.options
-            );
-    }
-
-    /**
-     * Filter any new telemetry (add/page, historical, subscription) based on
-     * time bounds and dupes
-     *
-     * @param  {(Object|Object[])} telemetryData - telemetry data object or
-     * array of telemetry data objects
-     * @private
-     */
-    _processNewTelemetry(telemetryData) {
-        let data = Array.isArray(telemetryData) ? telemetryData : [telemetryData];
-        let parsedValue;
-        let beforeStartOfBounds;
-        let afterEndOfBounds;
-        let added = [];
-
-        for (let datum of data) {
-            parsedValue = this.parseTime(datum);
-            beforeStartOfBounds = parsedValue < this.lastBounds.start;
-            afterEndOfBounds = parsedValue > this.lastBounds.end;
-
-            if (!afterEndOfBounds && !beforeStartOfBounds) {
-                let isDuplicate = false;
-                let startIndex = this._sortedIndex(datum);
-                let endIndex = undefined;
-
-                // dupe check
-                if (startIndex !== this.boundedTelemetry.length) {
-                    endIndex = _.sortedLastIndexBy(
-                        this.boundedTelemetry,
-                        datum,
-                        boundedDatum => this.parseTime(boundedDatum)
-                    );
-
-                    if (endIndex > startIndex) {
-                        let potentialDupes = this.boundedTelemetry.slice(startIndex, endIndex);
-
-                        isDuplicate = potentialDupes.some(_.isEqual.bind(undefined, datum));
-                    }
-                }
-
-                if (!isDuplicate) {
-                    let index = endIndex || startIndex;
-
-                    this.boundedTelemetry.splice(index, 0, datum);
-                    added.push(datum);
-                }
-
-            } else if (afterEndOfBounds) {
-                this.futureBuffer.push(datum);
-            }
-        }
-
-        if (added.length) {
-            this.emit('add', added);
-        }
-    }
-
-    /**
-     * Finds the correct insertion point for the given telemetry datum.
-     * Leverages lodash's `sortedIndexBy` function which implements a binary search.
-     * @private
-     */
-    _sortedIndex(datum) {
-        if (this.boundedTelemetry.length === 0) {
-            return 0;
-        }
-
-        let parsedValue = this.parseTime(datum);
-        let lastValue = this.parseTime(this.boundedTelemetry[this.boundedTelemetry.length - 1]);
-
-        if (parsedValue > lastValue || parsedValue === lastValue) {
-            return this.boundedTelemetry.length;
-        } else {
-            return _.sortedIndexBy(
-                this.boundedTelemetry,
-                datum,
-                boundedDatum => this.parseTime(boundedDatum)
-            );
-        }
-    }
-
-    /**
-     * when the start time, end time, or both have been updated.
-     * data could be added OR removed here we update the current
-     * bounded telemetry
-     *
-     * @param  {TimeConductorBounds} bounds The newly updated bounds
-     * @param  {boolean} [tick] `true` if the bounds update was due to
-     * a "tick" event (ie. was an automatic update), false otherwise.
-     * @private
-     */
-    _bounds(bounds, isTick) {
-        let startChanged = this.lastBounds.start !== bounds.start;
-        let endChanged = this.lastBounds.end !== bounds.end;
-
-        this.lastBounds = bounds;
-
-        if (isTick) {
-            // need to check futureBuffer and need to check
-            // if anything has fallen out of bounds
-            let startIndex = 0;
-            let endIndex = 0;
-
-            let discarded = [];
-            let added = [];
-            let testDatum = {};
-
-            if (startChanged) {
-                testDatum[this.timeKey] = bounds.start;
-                // Calculate the new index of the first item within the bounds
-                startIndex = _.sortedIndexBy(
-                    this.boundedTelemetry,
-                    testDatum,
-                    datum => this.parseTime(datum)
-                );
-                discarded = this.boundedTelemetry.splice(0, startIndex);
-            }
-
-            if (endChanged) {
-                testDatum[this.timeKey] = bounds.end;
-                // Calculate the new index of the last item in bounds
-                endIndex = _.sortedLastIndexBy(
-                    this.futureBuffer,
-                    testDatum,
-                    datum => this.parseTime(datum)
-                );
-                added = this.futureBuffer.splice(0, endIndex);
-                this.boundedTelemetry = [...this.boundedTelemetry, ...added];
-            }
-
-            if (discarded.length > 0) {
-                this.emit('remove', discarded);
-            }
-
-            if (added.length > 0) {
-                this.emit('add', added);
-            }
-
-        } else {
-            // user bounds change, reset
-            this._reset();
-        }
-
-    }
-
-    /**
-     * whenever the time system is updated need to update related values in
-     * the Telemetry Collection and reset the telemetry collection
-     *
-     * @param  {TimeSystem} timeSystem - the value of the currently applied
-     * Time System
-     * @private
-     */
-    _timeSystem(timeSystem) {
-        let domains = this.metadata.valuesForHints(['domain']);
-        let domain = domains.find((d) => d.key === timeSystem.key);
-
-        if (domain === undefined) {
-            this._error(ERRORS.TIMESYSTEM_KEY);
-        }
-
-        // timeKey is used to create a dummy datum used for sorting
-        this.timeKey = domain.source; // this defaults to key if no source is set
-        let metadataValue = this.metadata.value(timeSystem.key) || { format: timeSystem.key };
-        let valueFormatter = this.openmct.telemetry.getValueFormatter(metadataValue);
-
-        this.parseTime = (datum) => {
-            return valueFormatter.parse(datum);
-        };
-
-        this._reset();
-    }
-
-    /**
-     * Reset the telemetry data of the collection, and re-request
-     * historical telemetry
-     * @private
-     *
-     * @todo handle subscriptions more granually
-     */
-    _reset() {
-        this.boundedTelemetry = [];
-        this.futureBuffer = [];
-
-        this._requestHistoricalTelemetry();
-    }
-
-    /**
-     * adds the _bounds callback to the 'bounds' timeAPI listener
-     * @private
-     */
-    _watchBounds() {
-        this.openmct.time.on('bounds', this._bounds, this);
-    }
-
-    /**
-     * removes the _bounds callback from the 'bounds' timeAPI listener
-     * @private
-     */
-    _unwatchBounds() {
-        this.openmct.time.off('bounds', this._bounds, this);
-    }
-
-    /**
-     * adds the _timeSystem callback to the 'timeSystem' timeAPI listener
-     * @private
-     */
-    _watchTimeSystem() {
-        this.openmct.time.on('timeSystem', this._timeSystem, this);
-    }
-
-    /**
-     * removes the _timeSystem callback from the 'timeSystem' timeAPI listener
-     * @private
-     */
-    _unwatchTimeSystem() {
-        this.openmct.time.off('timeSystem', this._timeSystem, this);
-    }
-
-    /**
-     * will throw a new Error, for passed in message
-     * @param  {string} message Message describing the error
-     * @private
-     */
-    _error(message) {
-        throw new Error(message);
-    }
-}

src/exporters/ImageExporter.js

@@ -78,9 +78,6 @@ class ImageExporter {
         }
 
         return html2canvas(element, {
-            useCORS: true,
-            allowTaint: true,
-            logging: false,
             onclone: function (document) {
                 if (className) {
                     const clonedElement = document.getElementById(exportId);

src/plugins/DeviceClassifier/src/DeviceClassifier.js

@@ -1,72 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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.
- *****************************************************************************/
-
-/**
- * Runs at application startup and adds a subset of the following
- * CSS classes to the body of the document, depending on device
- * attributes:
- *
- * * `mobile`: Phones or tablets.
- * * `phone`: Phones specifically.
- * * `tablet`: Tablets specifically.
- * * `desktop`: Non-mobile devices.
- * * `portrait`: Devices in a portrait-style orientation.
- * * `landscape`: Devices in a landscape-style orientation.
- * * `touch`: Device supports touch events.
- *
- * @param {utils/agent/Agent} agent
- *        the service used to examine the user agent
- * @param document the HTML DOM document object
- * @constructor
- */
-import DeviceMatchers from "./DeviceMatchers";
-
-export default (agent, document) => {
-    const body = document.body;
-
-    Object.keys(DeviceMatchers).forEach((key, index, array) => {
-        if (DeviceMatchers[key](agent)) {
-            body.classList.add(key);
-        }
-    });
-
-    if (agent.isMobile()) {
-        const mediaQuery = window.matchMedia("(orientation: landscape)");
-        function eventHandler(event) {
-            console.log("changed");
-            if (event.matches) {
-                body.classList.remove("portrait");
-                body.classList.add("landscape");
-            } else {
-                body.classList.remove("landscape");
-                body.classList.add("portrait");
-            }
-        }
-
-        if (mediaQuery.addEventListener) {
-            mediaQuery.addEventListener(`change`, eventHandler);
-        } else {
-            // Deprecated 'MediaQueryList' API, <Safari 14, IE, <Edge 16
-            mediaQuery.addListener(eventHandler);
-        }
-    }
-};

src/plugins/DeviceClassifier/src/DeviceClassifierSpec.js

@@ -1,105 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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.
- *****************************************************************************/
-import DeviceClassifier from "./DeviceClassifier";
-import DeviceMatchers from "./DeviceMatchers";
-
-const AGENT_METHODS = [
-    "isMobile",
-    "isPhone",
-    "isTablet",
-    "isPortrait",
-    "isLandscape",
-    "isTouch"
-];
-const TEST_PERMUTATIONS = [
-    ["isMobile", "isPhone", "isTouch", "isPortrait"],
-    ["isMobile", "isPhone", "isTouch", "isLandscape"],
-    ["isMobile", "isTablet", "isTouch", "isPortrait"],
-    ["isMobile", "isTablet", "isTouch", "isLandscape"],
-    ["isTouch"],
-    []
-];
-
-describe("DeviceClassifier", function () {
-    let mockAgent;
-    let mockDocument;
-    let mockClassList;
-
-    beforeEach(function () {
-        mockAgent = jasmine.createSpyObj(
-            "agent",
-            AGENT_METHODS
-        );
-
-        mockClassList = jasmine.createSpyObj("classList", ["add"]);
-
-        mockDocument = jasmine.createSpyObj(
-            "document",
-            {},
-            { body: { classList: mockClassList } }
-        );
-
-        AGENT_METHODS.forEach(function (m) {
-            mockAgent[m].and.returnValue(false);
-        });
-    });
-
-    TEST_PERMUTATIONS.forEach(function (trueMethods) {
-        const summary =
-      trueMethods.length === 0
-          ? "device has no detected characteristics"
-          : "device " + trueMethods.join(", ");
-
-        describe("when " + summary, function () {
-            beforeEach(function () {
-                trueMethods.forEach(function (m) {
-                    mockAgent[m].and.returnValue(true);
-                });
-
-                // eslint-disable-next-line no-new
-                DeviceClassifier(mockAgent, mockDocument);
-            });
-
-            it("adds classes for matching, detected characteristics", function () {
-                Object.keys(DeviceMatchers)
-                    .filter(function (m) {
-                        return DeviceMatchers[m](mockAgent);
-                    })
-                    .forEach(function (key) {
-                        expect(mockDocument.body.classList.add).toHaveBeenCalledWith(key);
-                    });
-            });
-
-            it("does not add classes for non-matching characteristics", function () {
-                Object.keys(DeviceMatchers)
-                    .filter(function (m) {
-                        return !DeviceMatchers[m](mockAgent);
-                    })
-                    .forEach(function (key) {
-                        expect(mockDocument.body.classList.add).not.toHaveBeenCalledWith(
-                            key
-                        );
-                    });
-            });
-        });
-    });
-});

src/plugins/DeviceClassifier/src/DeviceMatchersSpec.js

@@ -1,65 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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.
- *****************************************************************************/
-import DeviceMatchers from "./DeviceMatchers";
-
-describe("DeviceMatchers", function () {
-    let mockAgent;
-
-    beforeEach(function () {
-        mockAgent = jasmine.createSpyObj("agent", [
-            "isMobile",
-            "isPhone",
-            "isTablet",
-            "isPortrait",
-            "isLandscape",
-            "isTouch"
-        ]);
-    });
-
-    it("detects when a device is a desktop device", function () {
-        mockAgent.isMobile.and.returnValue(false);
-        expect(DeviceMatchers.desktop(mockAgent)).toBe(true);
-        mockAgent.isMobile.and.returnValue(true);
-        expect(DeviceMatchers.desktop(mockAgent)).toBe(false);
-    });
-
-    function method(deviceType) {
-        return "is" + deviceType[0].toUpperCase() + deviceType.slice(1);
-    }
-
-    [
-        "mobile",
-        "phone",
-        "tablet",
-        "landscape",
-        "portrait",
-        "landscape",
-        "touch"
-    ].forEach(function (deviceType) {
-        it("detects when a device is a " + deviceType + " device", function () {
-            mockAgent[method(deviceType)].and.returnValue(true);
-            expect(DeviceMatchers[deviceType](mockAgent)).toBe(true);
-            mockAgent[method(deviceType)].and.returnValue(false);
-            expect(DeviceMatchers[deviceType](mockAgent)).toBe(false);
-        });
-    });
-});

src/plugins/clearData/ClearDataAction.js

@@ -1,78 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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.
- *****************************************************************************/
-
-function inSelectionPath(openmct, domainObject) {
-    const domainObjectIdentifier = domainObject.identifier;
-
-    return openmct.selection.get().some(selectionPath => {
-        return selectionPath.some(objectInPath => {
-            const objectInPathIdentifier = objectInPath.context.item.identifier;
-
-            return openmct.objects.areIdsEqual(objectInPathIdentifier, domainObjectIdentifier);
-        });
-    });
-}
-
-export default class ClearDataAction {
-    constructor(openmct, appliesToObjects) {
-        this.name = 'Clear Data for Object';
-        this.key = 'clear-data-action';
-        this.description = 'Clears current data for object, unsubscribes and resubscribes to data';
-        this.cssClass = 'icon-clear-data';
-
-        this._openmct = openmct;
-        this._appliesToObjects = appliesToObjects;
-    }
-    invoke(objectPath) {
-        let domainObject = null;
-        if (objectPath) {
-            domainObject = objectPath[0];
-        }
-
-        this._openmct.objectViews.emit('clearData', domainObject);
-    }
-    appliesTo(objectPath) {
-        if (!objectPath) {
-            return false;
-        }
-
-        const contextualDomainObject = objectPath[0];
-        // first check to see if this action applies to this sort of object at all
-        const appliesToThisObject = this._appliesToObjects.some(type => {
-            return contextualDomainObject.type === type;
-        });
-        if (!appliesToThisObject) {
-            // we've selected something not applicable
-            return false;
-        }
-
-        const objectInSelectionPath = inSelectionPath(this._openmct, contextualDomainObject);
-        if (objectInSelectionPath) {
-            return true;
-        } else {
-            // if this it doesn't match up, check to see if we're in a composition (i.e., layout)
-            const routerPath = this._openmct.router.path[0];
-
-            return routerPath.type === 'layout';
-        }
-    }
-}

src/plugins/clearData/clearDataAction.js

@@ -19,14 +19,23 @@
  * this source code distribution or the Licensing information page available
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
-import Agent from "../../utils/agent/Agent";
-import DeviceClassifier from "./src/DeviceClassifier";
 
-export default () => {
-    return (openmct) => {
-        openmct.on("start", () => {
-            const agent = new Agent(window);
-            DeviceClassifier(agent, window.document);
-        });
-    };
-};
+export default class ClearDataAction {
+    constructor(openmct, appliesToObjects) {
+        this.name = 'Clear Data for Object';
+        this.key = 'clear-data-action';
+        this.description = 'Clears current data for object, unsubscribes and resubscribes to data';
+        this.cssClass = 'icon-clear-data';
+
+        this._openmct = openmct;
+        this._appliesToObjects = appliesToObjects;
+    }
+    invoke(objectPath) {
+        this._openmct.objectViews.emit('clearData', objectPath[0]);
+    }
+    appliesTo(objectPath) {
+        let contextualDomainObject = objectPath[0];
+
+        return this._appliesToObjects.filter(type => contextualDomainObject.type === type).length;
+    }
+}

src/plugins/clearData/plugin.js

@@ -22,7 +22,7 @@
 
 define([
     './components/globalClearIndicator.vue',
-    './ClearDataAction',
+    './clearDataAction',
     'vue'
 ], function (
     GlobaClearIndicator,

src/plugins/clearData/test/ClearDataActionSpec.js

@@ -1,140 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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.
- *****************************************************************************/
-
-import ClearDataActionPlugin from '../plugin.js';
-import ClearDataAction from '../ClearDataAction.js';
-
-describe('When the Clear Data Plugin is installed,', () => {
-    const mockObjectViews = jasmine.createSpyObj('objectViews', ['emit']);
-    const mockIndicatorProvider = jasmine.createSpyObj('indicators', ['add']);
-    const mockActionsProvider = jasmine.createSpyObj('actions', ['register']);
-    const goodMockSelectionPath = [[{
-        context: {
-            item: {
-                identifier: {
-                    key: 'apple',
-                    namespace: ''
-                }
-            }
-        }
-    }]];
-
-    const openmct = {
-        objectViews: mockObjectViews,
-        indicators: mockIndicatorProvider,
-        actions: mockActionsProvider,
-        install: function (plugin) {
-            plugin(this);
-        },
-        selection: {
-            get: function () {
-                return goodMockSelectionPath;
-            }
-        },
-        objects: {
-            areIdsEqual: function (obj1, obj2) {
-                return true;
-            }
-        }
-    };
-
-    const mockObjectPath = [
-        {
-            name: 'mockObject1',
-            type: 'apple'
-        },
-        {
-            name: 'mockObject2',
-            type: 'banana'
-        }
-    ];
-
-    it('Global Clear Indicator is installed', () => {
-        openmct.install(ClearDataActionPlugin([]));
-
-        expect(mockIndicatorProvider.add).toHaveBeenCalled();
-    });
-
-    it('Clear Data context menu action is installed', () => {
-        openmct.install(ClearDataActionPlugin([]));
-
-        expect(mockActionsProvider.register).toHaveBeenCalled();
-    });
-
-    it('clear data action emits a clearData event when invoked', () => {
-        const action = new ClearDataAction(openmct);
-
-        action.invoke(mockObjectPath);
-
-        expect(mockObjectViews.emit).toHaveBeenCalledWith('clearData', mockObjectPath[0]);
-    });
-
-    it('clears data on applicable objects', () => {
-        let action = new ClearDataAction(openmct, ['apple']);
-
-        const actionApplies = action.appliesTo(mockObjectPath);
-
-        expect(actionApplies).toBe(true);
-    });
-
-    it('does not clear data on inapplicable objects', () => {
-        let action = new ClearDataAction(openmct, ['pineapple']);
-
-        const actionApplies = action.appliesTo(mockObjectPath);
-
-        expect(actionApplies).toBe(false);
-    });
-
-    it('does not clear data if not in the selection path and not a layout', () => {
-        openmct.objects = {
-            areIdsEqual: function (obj1, obj2) {
-                return false;
-            }
-        };
-        openmct.router = {
-            path: [{type: 'not-a-layout'}]
-        };
-
-        let action = new ClearDataAction(openmct, ['apple']);
-
-        const actionApplies = action.appliesTo(mockObjectPath);
-
-        expect(actionApplies).toBe(false);
-    });
-
-    it('does clear data if not in the selection path and is a layout', () => {
-        openmct.objects = {
-            areIdsEqual: function (obj1, obj2) {
-                return false;
-            }
-        };
-        openmct.router = {
-            path: [{type: 'layout'}]
-        };
-
-        let action = new ClearDataAction(openmct, ['apple']);
-
-        const actionApplies = action.appliesTo(mockObjectPath);
-
-        expect(actionApplies).toBe(true);
-    });
-});

src/plugins/clearData/test/clearDataActionSpec.js

@@ -0,0 +1,64 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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.
+ *****************************************************************************/
+
+import ClearDataActionPlugin from '../plugin.js';
+import ClearDataAction from '../clearDataAction.js';
+
+describe('When the Clear Data Plugin is installed,', function () {
+    const mockObjectViews = jasmine.createSpyObj('objectViews', ['emit']);
+    const mockIndicatorProvider = jasmine.createSpyObj('indicators', ['add']);
+    const mockActionsProvider = jasmine.createSpyObj('actions', ['register']);
+
+    const openmct = {
+        objectViews: mockObjectViews,
+        indicators: mockIndicatorProvider,
+        actions: mockActionsProvider,
+        install: function (plugin) {
+            plugin(this);
+        }
+    };
+
+    const mockObjectPath = [
+        {name: 'mockObject1'},
+        {name: 'mockObject2'}
+    ];
+
+    it('Global Clear Indicator is installed', function () {
+        openmct.install(ClearDataActionPlugin([]));
+
+        expect(mockIndicatorProvider.add).toHaveBeenCalled();
+    });
+
+    it('Clear Data context menu action is installed', function () {
+        openmct.install(ClearDataActionPlugin([]));
+
+        expect(mockActionsProvider.register).toHaveBeenCalled();
+    });
+
+    it('clear data action emits a clearData event when invoked', function () {
+        let action = new ClearDataAction(openmct);
+
+        action.invoke(mockObjectPath);
+
+        expect(mockObjectViews.emit).toHaveBeenCalledWith('clearData', mockObjectPath[0]);
+    });
+});

src/plugins/clock/ClockViewProvider.js

@@ -20,38 +20,40 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-/**
- * An object containing key-value pairs, where keys are symbolic of
- * device attributes, and values are functions that take the
- * `agent` as inputs and return boolean values indicating
- * whether or not the current device has these attributes.
- *
- * For internal use by the mobile support bundle.
- *
- * @memberof src/plugins/DeviceClassifier
- * @private
- */
+import Clock from './components/Clock.vue';
+import Vue from 'vue';
 
-export default {
-    mobile: function (agent) {
-        return agent.isMobile();
-    },
-    phone: function (agent) {
-        return agent.isPhone();
-    },
-    tablet: function (agent) {
-        return agent.isTablet();
-    },
-    desktop: function (agent) {
-        return !agent.isMobile();
-    },
-    portrait: function (agent) {
-        return agent.isPortrait();
-    },
-    landscape: function (agent) {
-        return agent.isLandscape();
-    },
-    touch: function (agent) {
-        return agent.isTouch();
-    }
-};
+export default function ClockViewProvider(openmct) {
+    return {
+        key: 'clock.view',
+        name: 'Clock',
+        cssClass: 'icon-clock',
+        canView(domainObject) {
+            return domainObject.type === 'clock';
+        },
+
+        view: function (domainObject) {
+            let component;
+
+            return {
+                show: function (element) {
+                    component = new Vue({
+                        el: element,
+                        components: {
+                            Clock
+                        },
+                        provide: {
+                            openmct,
+                            domainObject
+                        },
+                        template: '<clock></clock>'
+                    });
+                },
+                destroy: function () {
+                    component.$destroy();
+                    component = undefined;
+                }
+            };
+        }
+    };
+}

src/plugins/clock/components/Clock.vue

@@ -0,0 +1,99 @@
+<!--
+ Open MCT, Copyright (c) 2014-2021, United States Government
+ as represented by the Administrator of the National Aeronautics and Space
+ Administration. All rights reserved.
+
+ Open MCT 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 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.
+-->
+
+<template>
+<div class="l-angular-ov-wrapper">
+    <div class="u-contents">
+        <div class="c-clock l-time-display u-style-receiver js-style-receiver">
+            <div class="c-clock__timezone">
+                {{ timeZoneAbbr }}
+            </div>
+            <div class="c-clock__value">
+                {{ timeTextValue }}
+            </div>
+            <div class="c-clock__ampm">
+                {{ timeAmPm }}
+            </div>
+        </div>
+    </div>
+</div>
+</template>
+
+<script>
+import moment from 'moment';
+import momentTimezone from 'moment-timezone';
+
+export default {
+    inject: ['openmct', 'domainObject'],
+    data() {
+        return {
+            lastTimestamp: null
+        };
+    },
+    computed: {
+        configuration() {
+            return this.domainObject.configuration;
+        },
+        baseFormat() {
+            return this.configuration.baseFormat;
+        },
+        use24() {
+            return this.configuration.use24 === 'clock24';
+        },
+        timezone() {
+            return this.configuration.timezone;
+        },
+        timeFormat() {
+            return this.use24 ? this.baseFormat.replace('hh', "HH") : this.baseFormat;
+        },
+        zoneName() {
+            return momentTimezone.tz.names().includes(this.timezone) ? this.timezone : "UTC";
+        },
+        momentTime() {
+            return this.zoneName ? moment.utc(this.lastTimestamp).tz(this.zoneName) : moment.utc(this.lastTimestamp);
+        },
+        timeZoneAbbr() {
+            return this.momentTime.zoneAbbr();
+        },
+        timeTextValue() {
+            return this.timeFormat && this.momentTime.format(this.timeFormat);
+        },
+        timeAmPm() {
+            return this.use24 ? '' : this.momentTime.format("A");
+        }
+    },
+    mounted() {
+        const TickerService = this.openmct.$injector.get('tickerService');
+        this.unlisten = TickerService.listen(this.tick);
+    },
+    beforeDestroy() {
+        if (this.unlisten) {
+            this.unlisten();
+        }
+    },
+    methods: {
+        tick(timestamp) {
+            this.lastTimestamp = timestamp;
+        }
+    }
+};
+</script>

src/plugins/clock/components/ClockIndicator.vue

@@ -0,0 +1,64 @@
+<!--
+ Open MCT, Copyright (c) 2014-2021, United States Government
+ as represented by the Administrator of the National Aeronautics and Space
+ Administration. All rights reserved.
+
+ Open MCT 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 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.
+-->
+
+<template>
+<div class="c-indicator t-indicator-clock icon-clock no-minify c-indicator--not-clickable">
+    <span class="label c-indicator__label">
+        {{ timeTextValue }}
+    </span>
+</div>
+</template>
+
+<script>
+import moment from 'moment';
+
+export default {
+    inject: ['openmct'],
+    props: {
+        indicatorFormat: {
+            type: String,
+            required: true
+        }
+    },
+    data() {
+        return {
+            timeTextValue: null
+        };
+    },
+    mounted() {
+        this.openmct.on('start', () => {
+            const TickerService = this.openmct.$injector.get('tickerService');
+            this.unlisten = TickerService.listen(this.tick);
+        });
+    },
+    beforeDestroy() {
+        if (this.unlisten) {
+            this.unlisten();
+        }
+    },
+    methods: {
+        tick(timestamp) {
+            this.timeTextValue = `${moment.utc(timestamp).format(this.indicatorFormat)} UTC`;
+        }
+    }
+};
+</script>

src/plugins/clock/plugin.js

@@ -0,0 +1,154 @@
+
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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.
+ *****************************************************************************/
+
+import ClockViewProvider from './ClockViewProvider';
+import ClockIndicator from './components/ClockIndicator.vue';
+
+import momentTimezone from 'moment-timezone';
+import Vue from 'vue';
+
+export default function ClockPlugin(options) {
+    return function install(openmct) {
+        const CLOCK_INDICATOR_FORMAT = 'YYYY/MM/DD HH:mm:ss';
+        openmct.types.addType('clock', {
+            name: 'Clock',
+            description: 'A UTC-based clock that supports a variety of display formats. Clocks can be added to Display Layouts.',
+            creatable: true,
+            cssClass: 'icon-clock',
+            initialize: function (domainObject) {
+                domainObject.configuration = {
+                    baseFormat: 'YYYY/MM/DD hh:mm:ss',
+                    use24: 'clock12',
+                    timezone: 'UTC'
+                };
+            },
+            "form": [
+                {
+                    "key": "displayFormat",
+                    "name": "Display Format",
+                    control: 'select',
+                    options: [
+                        {
+                            value: 'YYYY/MM/DD hh:mm:ss',
+                            name: 'YYYY/MM/DD hh:mm:ss'
+                        },
+                        {
+                            value: 'YYYY/DDD hh:mm:ss',
+                            name: 'YYYY/DDD hh:mm:ss'
+                        },
+                        {
+                            value: 'hh:mm:ss',
+                            name: 'hh:mm:ss'
+                        }
+                    ],
+                    cssClass: 'l-inline',
+                    property: [
+                        'configuration',
+                        'baseFormat'
+                    ]
+                },
+                {
+                    control: 'select',
+                    options: [
+                        {
+                            value: 'clock12',
+                            name: '12hr'
+                        },
+                        {
+                            value: 'clock24',
+                            name: '24hr'
+                        }
+                    ],
+                    cssClass: 'l-inline',
+                    property: [
+                        'configuration',
+                        'use24'
+                    ]
+                },
+                {
+                    "key": "timezone",
+                    "name": "Timezone",
+                    "control": "autocomplete",
+                    "options": momentTimezone.tz.names(),
+                    property: [
+                        'configuration',
+                        'timezone'
+                    ]
+                }
+            ]
+        });
+        openmct.objectViews.addProvider(new ClockViewProvider(openmct));
+
+        if (options && options.enableClockIndicator) {
+            const clockIndicator = new Vue ({
+                components: {
+                    ClockIndicator
+                },
+                provide: {
+                    openmct
+                },
+                data() {
+                    return {
+                        indicatorFormat: CLOCK_INDICATOR_FORMAT
+                    };
+                },
+                template: '<ClockIndicator :indicator-format="indicatorFormat"></ClockIndicator>'
+            });
+            const indicator = {
+                element: clockIndicator.$mount().$el,
+                key: 'clock-indicator'
+            };
+
+            openmct.indicators.add(indicator);
+        }
+
+        openmct.objects.addGetInterceptor({
+            appliesTo: (identifier, domainObject) => {
+                return domainObject && domainObject.type === 'clock';
+            },
+            invoke: (identifier, domainObject) => {
+                if (domainObject.configuration) {
+                    return domainObject;
+                }
+
+                if (domainObject.clockFormat
+                    && domainObject.timezone) {
+                    const baseFormat = domainObject.clockFormat[0];
+                    const use24 = domainObject.clockFormat[1];
+                    const timezone = domainObject.timezone;
+
+                    domainObject.configuration = {
+                        baseFormat,
+                        use24,
+                        timezone
+                    };
+
+                    openmct.objects.mutate(domainObject, 'configuration', domainObject.configuration);
+                }
+
+                return domainObject;
+            }
+        });
+
+    };
+}

src/plugins/condition/components/inspector/StylesView.vue

@@ -141,7 +141,6 @@ const NON_STYLEABLE_CONTAINER_TYPES = [
 const NON_STYLEABLE_LAYOUT_ITEM_TYPES = [
     'line-view',
     'box-view',
-    'ellipse-view',
     'image-view'
 ];
 
@@ -322,7 +321,7 @@ export default {
             if (item) {
                 const type = this.openmct.types.get(item.type);
                 if (type && type.definition) {
-                    creatable = (type.definition.creatable !== undefined && (type.definition.creatable === 'true' || type.definition.creatable === true));
+                    creatable = (type.definition.creatable === true);
                 }
             }
 

src/plugins/condition/pluginSpec.js

@@ -230,7 +230,7 @@ describe('the plugin', function () {
         };
         const staticStyle = {
             "style": {
-                "backgroundColor": "#666666",
+                "backgroundColor": "#717171",
                 "border": "1px solid #00ffff"
             }
         };
@@ -238,7 +238,7 @@ describe('the plugin', function () {
             "conditionId": "39584410-cbf9-499e-96dc-76f27e69885d",
             "style": {
                 "isStyleInvisible": "",
-                "backgroundColor": "#666666",
+                "backgroundColor": "#717171",
                 "border": "1px solid #ffff00"
             }
         };
@@ -250,7 +250,7 @@ describe('the plugin', function () {
                 "configuration": {
                     "items": [
                         {
-                            "fill": "#666666",
+                            "fill": "#717171",
                             "stroke": "",
                             "x": 1,
                             "y": 1,
@@ -259,22 +259,12 @@ describe('the plugin', function () {
                             "type": "box-view",
                             "id": "89b88746-d325-487b-aec4-11b79afff9e8"
                         },
-                        {
-                            "fill": "#666666",
-                            "stroke": "",
-                            "x": 1,
-                            "y": 1,
-                            "width": 10,
-                            "height": 5,
-                            "type": "ellipse-view",
-                            "id": "19b88746-d325-487b-aec4-11b79afff9z8"
-                        },
                         {
                             "x": 18,
                             "y": 9,
                             "x2": 23,
                             "y2": 4,
-                            "stroke": "#666666",
+                            "stroke": "#717171",
                             "type": "line-view",
                             "id": "57d49a28-7863-43bd-9593-6570758916f0"
                         },
@@ -309,12 +299,12 @@ describe('the plugin', function () {
                 "y": 9,
                 "x2": 23,
                 "y2": 4,
-                "stroke": "#666666",
+                "stroke": "#717171",
                 "type": "line-view",
                 "id": "57d49a28-7863-43bd-9593-6570758916f0"
             };
             boxLayoutItem = {
-                "fill": "#666666",
+                "fill": "#717171",
                 "stroke": "",
                 "x": 1,
                 "y": 1,

src/plugins/condition/utils/styleUtils.js

@@ -29,10 +29,9 @@ const styleProps = {
         noneValue: NONE_VALUE,
         applicableForType: type => {
             return !type ? true : (type === 'text-view'
-                                            || type === 'telemetry-view'
-                                            || type === 'box-view'
-                                            || type === 'ellipse-view'
-                                            || type === 'subobject-view');
+                                      || type === 'telemetry-view'
+                                      || type === 'box-view'
+                                      || type === 'subobject-view');
         }
     },
     border: {
@@ -42,7 +41,6 @@ const styleProps = {
             return !type ? true : (type === 'text-view'
                                             || type === 'telemetry-view'
                                             || type === 'box-view'
-                                            || type === 'ellipse-view'
                                             || type === 'image-view'
                                             || type === 'line-view'
                                             || type === 'subobject-view');

src/plugins/displayLayout/DisplayLayoutToolbar.js

@@ -149,7 +149,6 @@ define(['lodash'], function (_) {
                         return type === 'text-view'
                             || type === 'telemetry-view'
                             || type === 'box-view'
-                            || type === 'ellipse-view'
                             || type === 'image-view'
                             || type === 'line-view'
                             || type === 'subobject-view';
@@ -181,10 +180,6 @@ define(['lodash'], function (_) {
                                     "name": "Box",
                                     "class": "icon-box-round-corners"
                                 },
-                                {
-                                    "name": "Ellipse",
-                                    "class": "icon-circle"
-                                },
                                 {
                                     "name": "Line",
                                     "class": "icon-line-horz"
@@ -750,7 +745,7 @@ define(['lodash'], function (_) {
                         if (toolbar.remove.length === 0) {
                             toolbar.remove = [getRemoveButton(selectedParent, selectionPath, selectedObjects)];
                         }
-                    } else if (layoutItem.type === 'box-view' || layoutItem.type === 'ellipse-view') {
+                    } else if (layoutItem.type === 'box-view') {
                         if (toolbar.position.length === 0) {
                             toolbar.position = [
                                 getStackOrder(selectedParent, selectionPath),

src/plugins/displayLayout/components/BoxView.vue

@@ -43,7 +43,7 @@ import conditionalStylesMixin from '../mixins/objectStyles-mixin';
 export default {
     makeDefinition() {
         return {
-            fill: '#666666',
+            fill: '#717171',
             stroke: '',
             x: 1,
             y: 1,

src/plugins/displayLayout/components/DisplayLayout.vue

@@ -76,7 +76,6 @@ import uuid from 'uuid';
 import SubobjectView from './SubobjectView.vue';
 import TelemetryView from './TelemetryView.vue';
 import BoxView from './BoxView.vue';
-import EllipseView from './EllipseView.vue';
 import TextView from './TextView.vue';
 import LineView from './LineView.vue';
 import ImageView from './ImageView.vue';
@@ -113,7 +112,6 @@ const ITEM_TYPE_VIEW_MAP = {
     'subobject-view': SubobjectView,
     'telemetry-view': TelemetryView,
     'box-view': BoxView,
-    'ellipse-view': EllipseView,
     'line-view': LineView,
     'text-view': TextView,
     'image-view': ImageView

src/plugins/displayLayout/components/EditMarquee.vue

@@ -28,19 +28,19 @@
 >
     <div
         class="c-frame-edit__handle c-frame-edit__handle--nw"
-        @mousedown.left="startResize([1,1], [-1,-1], $event)"
+        @mousedown="startResize([1,1], [-1,-1], $event)"
     ></div>
     <div
         class="c-frame-edit__handle c-frame-edit__handle--ne"
-        @mousedown.left="startResize([0,1], [1,-1], $event)"
+        @mousedown="startResize([0,1], [1,-1], $event)"
     ></div>
     <div
         class="c-frame-edit__handle c-frame-edit__handle--sw"
-        @mousedown.left="startResize([1,0], [-1,1], $event)"
+        @mousedown="startResize([1,0], [-1,1], $event)"
     ></div>
     <div
         class="c-frame-edit__handle c-frame-edit__handle--se"
-        @mousedown.left="startResize([0,0], [1,1], $event)"
+        @mousedown="startResize([0,0], [1,1], $event)"
     ></div>
 </div>
 </template>

src/plugins/displayLayout/components/EllipseView.vue

@@ -1,122 +0,0 @@
-/*****************************************************************************
-* Open MCT, Copyright (c) 2014-2021, United States Government
-* as represented by the Administrator of the National Aeronautics and Space
-* Administration. All rights reserved.
-*
-* Open MCT 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 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.
-*****************************************************************************/
-
-<template>
-<layout-frame
-    :item="item"
-    :grid-size="gridSize"
-    :is-editing="isEditing"
-    @move="(gridDelta) => $emit('move', gridDelta)"
-    @endMove="() => $emit('endMove')"
->
-    <div
-        class="c-ellipse-view u-style-receiver js-style-receiver"
-        :class="[styleClass]"
-        :style="style"
-    ></div>
-</layout-frame>
-</template>
-
-<script>
-import LayoutFrame from './LayoutFrame.vue';
-import conditionalStylesMixin from '../mixins/objectStyles-mixin';
-
-export default {
-    makeDefinition() {
-        return {
-            fill: '#666666',
-            stroke: '',
-            x: 1,
-            y: 1,
-            width: 10,
-            height: 10
-        };
-    },
-    components: {
-        LayoutFrame
-    },
-    mixins: [conditionalStylesMixin],
-    inject: ['openmct'],
-    props: {
-        item: {
-            type: Object,
-            required: true
-        },
-        gridSize: {
-            type: Array,
-            required: true,
-            validator: (arr) => arr && arr.length === 2
-                    && arr.every(el => typeof el === 'number')
-        },
-        index: {
-            type: Number,
-            required: true
-        },
-        initSelect: Boolean,
-        isEditing: {
-            type: Boolean,
-            required: true
-        }
-    },
-    computed: {
-        style() {
-            if (this.itemStyle) {
-                return this.itemStyle;
-            } else {
-                return {
-                    backgroundColor: this.item.fill,
-                    border: this.item.stroke ? '1px solid ' + this.item.stroke : ''
-                };
-            }
-        }
-    },
-    watch: {
-        index(newIndex) {
-            if (!this.context) {
-                return;
-            }
-
-            this.context.index = newIndex;
-        },
-        item(newItem) {
-            if (!this.context) {
-                return;
-            }
-
-            this.context.layoutItem = newItem;
-        }
-    },
-    mounted() {
-        this.context = {
-            layoutItem: this.item,
-            index: this.index
-        };
-        this.removeSelectable = this.openmct.selection.selectable(
-            this.$el, this.context, this.initSelect);
-    },
-    destroyed() {
-        if (this.removeSelectable) {
-            this.removeSelectable();
-        }
-    }
-};
-</script>

src/plugins/displayLayout/components/LayoutFrame.vue

@@ -33,7 +33,7 @@
     <slot></slot>
     <div
         class="c-frame__move-bar"
-        @mousedown.left="startMove($event)"
+        @mousedown="isEditing ? startMove([1,1], [0,0], $event) : null"
     ></div>
 </div>
 </template>
@@ -93,11 +93,7 @@ export default {
                 return value - this.initialPosition[index];
             }.bind(this));
         },
-        startMove(event, posFactor = [1, 1], dimFactor = [0, 0]) {
-            if (!this.isEditing) {
-                return;
-            }
-
+        startMove(posFactor, dimFactor, event) {
             document.body.addEventListener('mousemove', this.continueMove);
             document.body.addEventListener('mouseup', this.endMove);
             this.dragPosition = {

src/plugins/displayLayout/components/LineView.vue

@@ -45,7 +45,7 @@
 
     <div
         class="c-frame__move-bar"
-        @mousedown.left="startDrag($event)"
+        @mousedown="startDrag($event)"
     ></div>
     <div
         v-if="showFrameEdit"
@@ -96,7 +96,7 @@ export default {
             y: 10,
             x2: 10,
             y2: 5,
-            stroke: '#666666'
+            stroke: '#717171'
         };
     },
     mixins: [conditionalStylesMixin],

src/plugins/displayLayout/components/TelemetryView.vue

@@ -72,7 +72,7 @@
 <script>
 import LayoutFrame from './LayoutFrame.vue';
 import conditionalStylesMixin from "../mixins/objectStyles-mixin";
-import { getDefaultNotebook, getNotebookSectionAndPage } from '@/plugins/notebook/utils/notebook-storage.js';
+import { getDefaultNotebook } from '@/plugins/notebook/utils/notebook-storage.js';
 
 const DEFAULT_TELEMETRY_DIMENSIONS = [10, 5];
 const DEFAULT_POSITION = [1, 1];
@@ -336,15 +336,12 @@ export default {
         },
         async getContextMenuActions() {
             const defaultNotebook = getDefaultNotebook();
+            const domainObject = defaultNotebook && await this.openmct.objects.get(defaultNotebook.notebookMeta.identifier);
 
             let defaultNotebookName;
             if (defaultNotebook) {
-                const domainObject = await this.openmct.objects.get(defaultNotebook.identifier);
-                const { section, page } = getNotebookSectionAndPage(domainObject, defaultNotebook.defaultSectionId, defaultNotebook.defaultPageId);
-                if (section && page) {
-                    const defaultPath = domainObject && `${domainObject.name} - ${section.name} - ${page.name}`;
-                    defaultNotebookName = `Copy to Notebook ${defaultPath}`;
-                }
+                const defaultPath = domainObject && `${domainObject.name} - ${defaultNotebook.section.name} - ${defaultNotebook.page.name}`;
+                defaultNotebookName = `Copy to Notebook ${defaultPath}`;
             }
 
             return CONTEXT_MENU_ACTIONS

src/plugins/displayLayout/components/box-and-line-views.scss

@@ -1,5 +1,4 @@
-.c-box-view,
-.c-ellipse-view {
+.c-box-view {
     border-width: $drawingObjBorderW !important;
     display: flex;
     align-items: stretch;
@@ -9,10 +8,6 @@
     }
 }
 
-.c-ellipse-view {
-    border-radius: 50%;
-}
-
 .c-line-view {
     &.c-frame {
         box-shadow: none !important;

src/plugins/displayLayout/pluginSpec.js

@@ -186,7 +186,7 @@ describe('the plugin', function () {
                 'configuration': {
                     'items': [
                         {
-                            'fill': '#666666',
+                            'fill': '#717171',
                             'stroke': '',
                             'x': 1,
                             'y': 1,
@@ -195,22 +195,12 @@ describe('the plugin', function () {
                             'type': 'box-view',
                             'id': '89b88746-d325-487b-aec4-11b79afff9e8'
                         },
-                        {
-                            'fill': '#666666',
-                            'stroke': '',
-                            'x': 1,
-                            'y': 1,
-                            'width': 10,
-                            'height': 10,
-                            'type': 'ellipse-view',
-                            'id': '19b88746-d325-487b-aec4-11b79afff9z8'
-                        },
                         {
                             'x': 18,
                             'y': 9,
                             'x2': 23,
                             'y2': 4,
-                            'stroke': '#666666',
+                            'stroke': '#717171',
                             'type': 'line-view',
                             'id': '57d49a28-7863-43bd-9593-6570758916f0'
                         },
@@ -351,7 +341,7 @@ describe('the plugin', function () {
         it('provides controls including separators', () => {
             const displayLayoutToolbar = openmct.toolbars.get(selection);
 
-            expect(displayLayoutToolbar.length).toBe(7);
+            expect(displayLayoutToolbar.length).toBe(9);
         });
     });
 });

src/plugins/newFolderAction/pluginSpec.js

@@ -75,16 +75,7 @@ describe("the plugin", () => {
 
             mockDialogService.getUserInput.and.returnValue(mockPromise);
 
-            spyOn(openmct.$injector, 'get');
-            openmct.$injector.get.and.callFake((key) => {
-                return {
-                    'dialogService': mockDialogService,
-                    '$rootScope': {
-                        '$destroy': () => {}
-                    }
-                }[key];
-            });
-
+            spyOn(openmct.$injector, 'get').and.returnValue(mockDialogService);
             spyOn(compositionAPI, 'get').and.returnValue(mockComposition);
             spyOn(openmct.objects, 'save').and.returnValue(Promise.resolve(true));
 

src/plugins/notebook/actions/CopyToNotebookAction.js

@@ -1,4 +1,4 @@
-import { getDefaultNotebook, getNotebookSectionAndPage } from '../utils/notebook-storage';
+import { getDefaultNotebook } from '../utils/notebook-storage';
 import { addNotebookEntry } from '../utils/notebook-entries';
 
 export default class CopyToNotebookAction {
@@ -15,16 +15,11 @@ export default class CopyToNotebookAction {
 
     copyToNotebook(entryText) {
         const notebookStorage = getDefaultNotebook();
-        this.openmct.objects.get(notebookStorage.identifier)
+        this.openmct.objects.get(notebookStorage.notebookMeta.identifier)
             .then(domainObject => {
                 addNotebookEntry(this.openmct, domainObject, notebookStorage, null, entryText);
 
-                const { section, page } = getNotebookSectionAndPage(domainObject, notebookStorage.defaultSectionId, notebookStorage.defaultPageId);
-                if (!section || !page) {
-                    return;
-                }
-
-                const defaultPath = `${domainObject.name} - ${section.name} - ${page.name}`;
+                const defaultPath = `${domainObject.name} - ${notebookStorage.section.name} - ${notebookStorage.page.name}`;
                 const msg = `Saved to Notebook ${defaultPath}`;
                 this.openmct.notifications.info(msg);
             });

src/plugins/notebook/components/Notebook.vue

@@ -43,16 +43,14 @@
                  class="c-notebook__nav c-sidebar c-drawer c-drawer--align-left"
                  :class="[{'is-expanded': showNav}, {'c-drawer--push': !sidebarCoversEntries}, {'c-drawer--overlays': sidebarCoversEntries}]"
                  :default-page-id="defaultPageId"
-                 :selected-page-id="getSelectedPageId()"
+                 :selected-page-id="selectedPageId"
                  :default-section-id="defaultSectionId"
-                 :selected-section-id="getSelectedSectionId()"
+                 :selected-section-id="selectedSectionId"
                  :domain-object="domainObject"
                  :page-title="domainObject.configuration.pageTitle"
                  :section-title="domainObject.configuration.sectionTitle"
                  :sections="sections"
                  :sidebar-covers-entries="sidebarCoversEntries"
-                 @defaultPageDeleted="cleanupDefaultNotebook"
-                 @defaultSectionDeleted="cleanupDefaultNotebook"
                  @pagesChanged="pagesChanged"
                  @selectPage="selectPage"
                  @sectionsChanged="sectionsChanged"
@@ -138,7 +136,7 @@ import NotebookEntry from './NotebookEntry.vue';
 import Search from '@/ui/components/search.vue';
 import SearchResults from './SearchResults.vue';
 import Sidebar from './Sidebar.vue';
-import { clearDefaultNotebook, getDefaultNotebook, setDefaultNotebook, setDefaultNotebookSectionId, setDefaultNotebookPageId } from '../utils/notebook-storage';
+import { clearDefaultNotebook, getDefaultNotebook, setDefaultNotebook, setDefaultNotebookSection, setDefaultNotebookPage } from '../utils/notebook-storage';
 import { addNotebookEntry, createNewEmbed, getEntryPosById, getNotebookEntries, mutateObject } from '../utils/notebook-entries';
 import { NOTEBOOK_VIEW_TYPE } from '../notebook-constants';
 import objectUtils from 'objectUtils';
@@ -166,10 +164,8 @@ export default {
     },
     data() {
         return {
-            defaultPageId: this.getDefaultPageId(),
-            defaultSectionId: this.getDefaultSectionId(),
-            selectedSectionId: this.getSelectedSectionId(),
-            selectedPageId: this.getSelectedPageId(),
+            selectedSectionId: this.getDefaultSectionId(),
+            selectedPageId: this.getDefaultPageId(),
             defaultSort: this.domainObject.configuration.defaultSort,
             focusEntryId: null,
             search: '',
@@ -180,6 +176,12 @@ export default {
         };
     },
     computed: {
+        defaultPageId() {
+            return this.getDefaultPageId();
+        },
+        defaultSectionId() {
+            return this.getDefaultSectionId();
+        },
         filteredAndSortedEntries() {
             const filterTime = Date.now();
             const pageEntries = getNotebookEntries(this.domainObject, this.selectedSection, this.selectedPage) || [];
@@ -201,38 +203,24 @@ export default {
         },
         selectedPage() {
             const pages = this.getPages();
-            if (!pages.length) {
-                return undefined;
-            }
-
             const selectedPage = pages.find(page => page.id === this.selectedPageId);
+
             if (selectedPage) {
                 return selectedPage;
             }
 
-            const defaultPage = pages.find(page => page.id === this.defaultPageId);
-            if (defaultPage) {
-                return defaultPage;
-            }
-
-            return this.pages[0];
-        },
-        selectedSection() {
-            if (!this.sections.length) {
+            if (!selectedPage && !pages.length) {
                 return undefined;
             }
 
-            const selectedSection = this.sections.find(section => section.id === this.selectedSectionId);
-            if (selectedSection) {
-                return selectedSection;
+            return pages[0];
+        },
+        selectedSection() {
+            if (!this.sections.length) {
+                return null;
             }
 
-            const defaultSection = this.sections.find(section => section.id === this.defaultSectionId);
-            if (defaultSection) {
-                return defaultSection;
-            }
-
-            return this.sections[0];
+            return this.sections.find(section => section.id === this.selectedSectionId);
         }
     },
     watch: {
@@ -313,29 +301,26 @@ export default {
             this.sectionsChanged({ sections });
             this.resetSearch();
         },
-        cleanupDefaultNotebook() {
-            this.defaultPageId = undefined;
-            this.defaultSectionId = undefined;
-            this.removeDefaultClass(this.domainObject);
-            clearDefaultNotebook();
-        },
         setSectionAndPageFromUrl() {
-            let sectionId = this.getSectionIdFromUrl() || this.getDefaultSectionId() || this.getSelectedSectionId();
-            let pageId = this.getPageIdFromUrl() || this.getDefaultPageId() || this.getSelectedPageId();
+            let sectionId = this.getSectionIdFromUrl() || this.selectedSectionId;
+            let pageId = this.getPageIdFromUrl() || this.selectedPageId;
 
             this.selectSection(sectionId);
             this.selectPage(pageId);
         },
         createNotebookStorageObject() {
+            const notebookMeta = {
+                name: this.domainObject.name,
+                identifier: this.domainObject.identifier,
+                link: this.getLinktoNotebook()
+            };
             const page = this.selectedPage;
             const section = this.selectedSection;
 
             return {
-                name: this.domainObject.name,
-                identifier: this.domainObject.identifier,
-                link: this.getLinktoNotebook(),
-                defaultSectionId: section.id,
-                defaultPageId: page.id
+                notebookMeta,
+                page,
+                section
             };
         },
         deleteEntry(entryId) {
@@ -434,21 +419,35 @@ export default {
             this.sidebarCoversEntries = sidebarCoversEntries;
         },
         getDefaultPageId() {
-            return this.isDefaultNotebook()
-                ? getDefaultNotebook().defaultPageId
-                : undefined;
+            let defaultPageId;
+
+            if (this.isDefaultNotebook()) {
+                defaultPageId = getDefaultNotebook().page.id;
+            } else {
+                const firstSection = this.getSections()[0];
+                defaultPageId = firstSection && firstSection.pages[0].id;
+            }
+
+            return defaultPageId;
         },
         isDefaultNotebook() {
             const defaultNotebook = getDefaultNotebook();
-            const defaultNotebookIdentifier = defaultNotebook && defaultNotebook.identifier;
+            const defaultNotebookIdentifier = defaultNotebook && defaultNotebook.notebookMeta.identifier;
 
             return defaultNotebookIdentifier !== null
                 && this.openmct.objects.areIdsEqual(defaultNotebookIdentifier, this.domainObject.identifier);
         },
         getDefaultSectionId() {
-            return this.isDefaultNotebook()
-                ? getDefaultNotebook().defaultSectionId
-                : undefined;
+            let defaultSectionId;
+
+            if (this.isDefaultNotebook()) {
+                defaultSectionId = getDefaultNotebook().section.id;
+            } else {
+                const firstSection = this.getSections()[0];
+                defaultSectionId = firstSection && firstSection.id;
+            }
+
+            return defaultSectionId;
         },
         getDefaultNotebookObject() {
             const oldNotebookStorage = getDefaultNotebook();
@@ -456,7 +455,7 @@ export default {
                 return null;
             }
 
-            return this.openmct.objects.get(oldNotebookStorage.identifier);
+            return this.openmct.objects.get(oldNotebookStorage.notebookMeta.identifier);
         },
         getLinktoNotebook() {
             const objectPath = this.openmct.router.path;
@@ -574,22 +573,6 @@ export default {
 
             return selectedSection.pages;
         },
-        getSelectedPageId() {
-            const page = this.selectedPage;
-            if (!page) {
-                return undefined;
-            }
-
-            return page.id;
-        },
-        getSelectedSectionId() {
-            const section = this.selectedSection;
-            if (!section) {
-                return undefined;
-            }
-
-            return section.id;
-        },
         newEntry(embed = null) {
             this.resetSearch();
             const notebookStorage = this.createNotebookStorageObject();
@@ -633,26 +616,51 @@ export default {
         },
         async updateDefaultNotebook(notebookStorage) {
             const defaultNotebookObject = await this.getDefaultNotebookObject();
-            const isSameNotebook = defaultNotebookObject
-                && objectUtils.makeKeyString(defaultNotebookObject.identifier) === objectUtils.makeKeyString(notebookStorage.identifier);
-            if (!isSameNotebook) {
+            if (!defaultNotebookObject) {
+                setDefaultNotebook(this.openmct, notebookStorage, this.domainObject);
+            } else if (objectUtils.makeKeyString(defaultNotebookObject.identifier) !== objectUtils.makeKeyString(notebookStorage.notebookMeta.identifier)) {
                 this.removeDefaultClass(defaultNotebookObject);
-            }
-
-            if (!defaultNotebookObject || !isSameNotebook) {
                 setDefaultNotebook(this.openmct, notebookStorage, this.domainObject);
             }
 
-            if (this.defaultSectionId !== notebookStorage.defaultSectionId) {
-                setDefaultNotebookSectionId(notebookStorage.defaultSectionId);
-                this.defaultSectionId = notebookStorage.defaultSectionId;
+            if (this.defaultSectionId && this.defaultSectionId.length === 0 || this.defaultSectionId !== notebookStorage.section.id) {
+                this.defaultSectionId = notebookStorage.section.id;
+                setDefaultNotebookSection(notebookStorage.section);
             }
 
-            if (this.defaultPageId !== notebookStorage.defaultPageId) {
-                setDefaultNotebookPageId(notebookStorage.defaultPageId);
-                this.defaultPageId = notebookStorage.defaultPageId;
+            if (this.defaultPageId && this.defaultPageId.length === 0 || this.defaultPageId !== notebookStorage.page.id) {
+                this.defaultPageId = notebookStorage.page.id;
+                setDefaultNotebookPage(notebookStorage.page);
             }
         },
+        updateDefaultNotebookPage(pages, id) {
+            if (!id) {
+                return;
+            }
+
+            const notebookStorage = getDefaultNotebook();
+            if (!notebookStorage
+                    || notebookStorage.notebookMeta.identifier.key !== this.domainObject.identifier.key) {
+                return;
+            }
+
+            const defaultNotebookPage = notebookStorage.page;
+            const page = pages.find(p => p.id === id);
+            if (!page && defaultNotebookPage.id === id) {
+                this.defaultSectionId = null;
+                this.defaultPageId = null;
+                this.removeDefaultClass(this.domainObject);
+                clearDefaultNotebook();
+
+                return;
+            }
+
+            if (id !== defaultNotebookPage.id) {
+                return;
+            }
+
+            setDefaultNotebookPage(page);
+        },
         updateDefaultNotebookSection(sections, id) {
             if (!id) {
                 return;
@@ -660,26 +668,26 @@ export default {
 
             const notebookStorage = getDefaultNotebook();
             if (!notebookStorage
-                    || notebookStorage.identifier.key !== this.domainObject.identifier.key) {
+                    || notebookStorage.notebookMeta.identifier.key !== this.domainObject.identifier.key) {
                 return;
             }
 
-            const defaultNotebookSectionId = notebookStorage.defaultSectionId;
-            if (defaultNotebookSectionId === id) {
-                const section = sections.find(s => s.id === id);
-                if (!section) {
-                    this.removeDefaultClass(this.domainObject);
-                    clearDefaultNotebook();
+            const defaultNotebookSection = notebookStorage.section;
+            const section = sections.find(s => s.id === id);
+            if (!section && defaultNotebookSection.id === id) {
+                this.defaultSectionId = null;
+                this.defaultPageId = null;
+                this.removeDefaultClass(this.domainObject);
+                clearDefaultNotebook();
 
-                    return;
-                }
-            }
-
-            if (id !== defaultNotebookSectionId) {
                 return;
             }
 
-            setDefaultNotebookSectionId(defaultNotebookSectionId);
+            if (id !== defaultNotebookSection.id) {
+                return;
+            }
+
+            setDefaultNotebookSection(section);
         },
         updateEntry(entry) {
             const entries = getNotebookEntries(this.domainObject, this.selectedSection, this.selectedPage);
@@ -707,27 +715,19 @@ export default {
                 sectionId: this.selectedSectionId
             });
         },
-        sectionsChanged({ sections, id = undefined }) {
+        sectionsChanged({ sections, id = null }) {
             mutateObject(this.openmct, this.domainObject, 'configuration.sections', sections);
             this.updateDefaultNotebookSection(sections, id);
         },
         selectPage(pageId) {
-            if (!pageId) {
-                return;
-            }
-
             this.selectedPageId = pageId;
             this.syncUrlWithPageAndSection();
         },
         selectSection(sectionId) {
-            if (!sectionId) {
-                return;
-            }
-
             this.selectedSectionId = sectionId;
 
-            const pageId = this.selectedSection.pages[0].id;
-            this.selectPage(pageId);
+            const defaultPageId = this.selectedSection.pages[0].id;
+            this.selectPage(defaultPageId);
 
             this.syncUrlWithPageAndSection();
         }

src/plugins/notebook/components/NotebookMenuSwitcher.vue

@@ -17,7 +17,7 @@
 
 <script>
 import Snapshot from '../snapshot';
-import { getDefaultNotebook, getNotebookSectionAndPage, validateNotebookStorageObject } from '../utils/notebook-storage';
+import { getDefaultNotebook, validateNotebookStorageObject } from '../utils/notebook-storage';
 import { NOTEBOOK_DEFAULT, NOTEBOOK_SNAPSHOT } from '../notebook-constants';
 
 export default {
@@ -56,10 +56,11 @@ export default {
         this.setDefaultNotebookStatus();
     },
     methods: {
-        getDefaultNotebookObject() {
+        async getDefaultNotebookObject() {
             const defaultNotebook = getDefaultNotebook();
+            const defaultNotebookObject = defaultNotebook && await this.openmct.objects.get(defaultNotebook.notebookMeta.identifier);
 
-            return defaultNotebook && this.openmct.objects.get(defaultNotebook.identifier);
+            return defaultNotebookObject;
         },
         async showMenu(event) {
             const notebookTypes = [];
@@ -69,39 +70,36 @@ export default {
 
             const defaultNotebookObject = await this.getDefaultNotebookObject();
             if (defaultNotebookObject) {
-                const defaultNotebook = getDefaultNotebook();
-                const { section, page } = getNotebookSectionAndPage(defaultNotebookObject, defaultNotebook.defaultSectionId, defaultNotebook.defaultPageId);
-                if (section && page) {
-                    const name = defaultNotebookObject.name;
-                    const sectionName = section.name;
-                    const pageName = page.name;
-                    const defaultPath = `${name} - ${sectionName} - ${pageName}`;
+                const name = defaultNotebookObject.name;
 
-                    notebookTypes.push({
-                        cssClass: 'icon-notebook',
-                        name: `Save to Notebook ${defaultPath}`,
-                        onItemClicked: () => {
-                            return this.snapshot(NOTEBOOK_DEFAULT, event.target);
-                        }
-                    });
-                }
+                const defaultNotebook = getDefaultNotebook();
+                const sectionName = defaultNotebook.section.name;
+                const pageName = defaultNotebook.page.name;
+                const defaultPath = `${name} - ${sectionName} - ${pageName}`;
+
+                notebookTypes.push({
+                    cssClass: 'icon-notebook',
+                    name: `Save to Notebook ${defaultPath}`,
+                    onItemClicked: () => {
+                        return this.snapshot(NOTEBOOK_DEFAULT);
+                    }
+                });
             }
 
             notebookTypes.push({
                 cssClass: 'icon-camera',
                 name: 'Save to Notebook Snapshots',
                 onItemClicked: () => {
-                    return this.snapshot(NOTEBOOK_SNAPSHOT, event.target);
+                    return this.snapshot(NOTEBOOK_SNAPSHOT);
                 }
             });
 
             this.openmct.menus.showMenu(x, y, notebookTypes);
         },
-        snapshot(notebookType, target) {
+        snapshot(notebookType) {
             this.$nextTick(() => {
-                const wrapper = target && target.closest('.js-notebook-snapshot-item-wrapper')
-                    || document;
-                const element = wrapper.querySelector('.js-notebook-snapshot-item');
+                const element = document.querySelector('.c-overlay__contents')
+                    || document.getElementsByClassName('l-shell__main-container')[0];
 
                 const bounds = this.openmct.time.bounds();
                 const link = !this.ignoreLink
@@ -121,8 +119,9 @@ export default {
         },
         setDefaultNotebookStatus() {
             let defaultNotebookObject = getDefaultNotebook();
-            if (defaultNotebookObject) {
-                let notebookIdentifier = defaultNotebookObject.identifier;
+
+            if (defaultNotebookObject && defaultNotebookObject.notebookMeta) {
+                let notebookIdentifier = defaultNotebookObject.notebookMeta.identifier;
 
                 this.openmct.status.set(notebookIdentifier, 'notebook-default');
             }

src/plugins/notebook/components/PageCollection.vue

@@ -87,26 +87,22 @@ export default {
 
             const selectedPage = this.pages.find(p => p.isSelected);
             const defaultNotebook = getDefaultNotebook();
-            const defaultPageId = defaultNotebook && defaultNotebook.defaultPageId;
+            const defaultpage = defaultNotebook && defaultNotebook.page;
             const isPageSelected = selectedPage && selectedPage.id === id;
-            const isPageDefault = defaultPageId === id;
+            const isPageDefault = defaultpage && defaultpage.id === id;
             const pages = this.pages.filter(s => s.id !== id);
             let selectedPageId;
 
-            if (isPageSelected && defaultPageId) {
+            if (isPageSelected && defaultpage) {
                 pages.forEach(s => {
                     s.isSelected = false;
-                    if (defaultPageId === s.id) {
+                    if (defaultpage && defaultpage.id === s.id) {
                         selectedPageId = s.id;
                     }
                 });
             }
 
-            if (isPageDefault) {
-                this.$emit('defaultPageDeleted');
-            }
-
-            if (pages.length && isPageSelected && (!defaultPageId || isPageDefault)) {
+            if (pages.length && isPageSelected && (!defaultpage || isPageDefault)) {
                 selectedPageId = pages[0].id;
             }
 

src/plugins/notebook/components/SectionCollection.vue

@@ -75,25 +75,21 @@ export default {
 
             const selectedSection = this.sections.find(s => s.id === this.selectedSectionId);
             const defaultNotebook = getDefaultNotebook();
-            const defaultSectionId = defaultNotebook && defaultNotebook.defaultSectionId;
+            const defaultSection = defaultNotebook && defaultNotebook.section;
             const isSectionSelected = selectedSection && selectedSection.id === id;
-            const isSectionDefault = defaultSectionId === id;
+            const isSectionDefault = defaultSection && defaultSection.id === id;
             const sections = this.sections.filter(s => s.id !== id);
 
-            if (isSectionSelected && defaultSectionId) {
+            if (isSectionSelected && defaultSection) {
                 sections.forEach(s => {
                     s.isSelected = false;
-                    if (defaultSectionId === s.id) {
+                    if (defaultSection && defaultSection.id === s.id) {
                         s.isSelected = true;
                     }
                 });
             }
 
-            if (isSectionDefault) {
-                this.$emit('defaultSectionDeleted');
-            }
-
-            if (sections.length && isSectionSelected && (!defaultSectionId || isSectionDefault)) {
+            if (sections.length && isSectionSelected && (!defaultSection || isSectionDefault)) {
                 sections[0].isSelected = true;
             }
 

src/plugins/notebook/components/Sidebar.vue

@@ -19,7 +19,6 @@
                                :domain-object="domainObject"
                                :sections="sections"
                                :section-title="sectionTitle"
-                               @defaultSectionDeleted="defaultSectionDeleted"
                                @updateSection="sectionsChanged"
                                @selectSection="selectSection"
             />
@@ -51,7 +50,6 @@
                             :sections="sections"
                             :sidebar-covers-entries="sidebarCoversEntries"
                             :page-title="pageTitle"
-                            @defaultPageDeleted="defaultPageDeleted"
                             @toggleNav="toggleNav"
                             @updatePage="pagesChanged"
                             @selectPage="selectPage"
@@ -220,12 +218,6 @@ export default {
                 sectionTitle
             };
         },
-        defaultPageDeleted() {
-            this.$emit('defaultPageDeleted');
-        },
-        defaultSectionDeleted() {
-            this.$emit('defaultSectionDeleted');
-        },
         toggleNav() {
             this.$emit('toggleNav');
         },

src/plugins/notebook/plugin.js

@@ -117,10 +117,6 @@ export default function NotebookPlugin() {
             key: 'notebook-snapshot-indicator'
         };
 
-        openmct.once('destroy', () => {
-            snapshotContainer.destroy();
-        });
-
         openmct.indicators.add(indicator);
 
         openmct.objectViews.addProvider({

src/plugins/notebook/snapshot-container.js

@@ -80,8 +80,4 @@ export default class SnapshotContainer extends EventEmitter {
 
         return this.saveSnapshots(updatedSnapshots);
     }
-
-    destroy() {
-        delete SnapshotContainer.instance;
-    }
 }

src/plugins/notebook/snapshot.js

@@ -1,5 +1,5 @@
 import { addNotebookEntry, createNewEmbed } from './utils/notebook-entries';
-import { getDefaultNotebook, getNotebookSectionAndPage, getDefaultNotebookLink, setDefaultNotebook } from './utils/notebook-storage';
+import { getDefaultNotebook, getDefaultNotebookLink, setDefaultNotebook } from './utils/notebook-storage';
 import { NOTEBOOK_DEFAULT } from '@/plugins/notebook/notebook-constants';
 import { createNotebookImageDomainObject, DEFAULT_SIZE } from './utils/notebook-image';
 
@@ -58,25 +58,20 @@ export default class Snapshot {
      */
     _saveToDefaultNoteBook(embed) {
         const notebookStorage = getDefaultNotebook();
-        this.openmct.objects.get(notebookStorage.identifier)
+        this.openmct.objects.get(notebookStorage.notebookMeta.identifier)
             .then(async (domainObject) => {
                 addNotebookEntry(this.openmct, domainObject, notebookStorage, embed);
 
-                let link = notebookStorage.link;
+                let link = notebookStorage.notebookMeta.link;
 
                 // Backwards compatibility fix (old notebook model without link)
                 if (!link) {
                     link = await getDefaultNotebookLink(this.openmct, domainObject);
-                    notebookStorage.link = link;
+                    notebookStorage.notebookMeta.link = link;
                     setDefaultNotebook(this.openmct, notebookStorage);
                 }
 
-                const { section, page } = getNotebookSectionAndPage(domainObject, notebookStorage.defaultSectionId, notebookStorage.defaultPageId);
-                if (!section || !page) {
-                    return;
-                }
-
-                const defaultPath = `${domainObject.name} - ${section.name} - ${page.name}`;
+                const defaultPath = `${domainObject.name} - ${notebookStorage.section.name} - ${notebookStorage.page.name}`;
                 const msg = `Saved to Notebook ${defaultPath}`;
                 this._showNotification(msg, link);
             });