- modified UIResourceOps to bubble the delete up to the ProjectFrame which performs the actual delete

- ProjectFrame then sends a message to the ServiceLocator to indicate that a delete occurred so it can hook into it
- Added a timer to TypescriptLanguageService to time the compile time and log to the console
- Respond to deleting a typescript file and delete the corresponding js file as well as clear the cache for that file

Script/AtomicEditor/editor/EditorEvents.ts

@@ -99,6 +99,16 @@ export interface EditResourceEvent {
 
 }
 
+export const DeleteResource = "EditorDeleteResource";
+export interface DeleteResourceEvent {
+
+  // The full path to the resource to edit
+  path: string;
+
+  // the asset to delete
+  asset: ToolCore.Asset;
+}
+
 export const SceneEditStateChange = "SceneEditStateChange";
 export interface SceneEditStateChangeEvent {
 

Script/AtomicEditor/extensionServices/EditorExtensionServices.ts

@@ -6,8 +6,8 @@
 //
 
 import * as EditorEvents from "../editor/EditorEvents";
-import TypescriptLanguageService from "./resourceServices/TypescriptLanguageService";
 import * as EditorUI from "../ui/EditorUI";
+
 /**
  * Base interface for any editor services.
  */
@@ -34,8 +34,8 @@ export interface ResourceService extends EditorService {
     save?(ev: EditorEvents.SaveResourceEvent);
     canSave?(ev: EditorEvents.SaveResourceEvent);
     projectUnloaded?();
-    canDelete?();
-    delete?();
+    canDelete?(ev: EditorEvents.DeleteResourceEvent);
+    delete?(ev: EditorEvents.DeleteResourceEvent);
 }
 
 /**
@@ -57,6 +57,9 @@ class ServiceRegistry<T extends EditorService> {
  * Registry for service extensions that are concerned about Resources
  */
 class ResourceServiceRegistry extends ServiceRegistry<ResourceService> {
+    constructor() {
+        super();
+    }
 
     saveResource(ev: EditorEvents.SaveResourceEvent) {
         // run through and find any services that can handle this.
@@ -76,12 +79,12 @@ class ResourceServiceRegistry extends ServiceRegistry<ResourceService> {
      * Called when a resource is being deleted
      * @return {[type]} [description]
      */
-    deleteResource() {
+    deleteResource(ev: EditorEvents.DeleteResourceEvent) {
         this.registeredServices.forEach((service) => {
             // Verify that the service contains the appropriate methods and that it can save
-            if (service.canDelete && service.delete && service.canDelete()) {
+            if (service.canDelete && service.delete && service.canDelete(ev)) {
                 try {
-                    service.delete();
+                    service.delete(ev);
                 } catch (e) {
                     EditorUI.showModalError("Extension Error", `Error detected in extension ${service.name}\n ${e}\n ${e.stack}`);
                 }
@@ -122,10 +125,4 @@ export class ServiceLocatorType {
     loadService(service: EditorService) {
         service.initialize(this);
     }
-
-    initializeServices() {
-        // first we will load the built in services
-        this.loadService(new TypescriptLanguageService);
-        //TODO: Scan the user folders for services to load
-    }
 }

Script/AtomicEditor/extensionServices/ServiceLocator.ts

@@ -5,9 +5,11 @@
 // license information: https://github.com/AtomicGameEngine/AtomicGameEngine
 //
 import {ServiceLocatorType} from "./EditorExtensionServices";
+import TypescriptLanguageService from "./resourceServices/TypescriptLanguageService";
 
 // Singleton service locator that can be referenced
 const serviceLocator = new ServiceLocatorType();
 export default serviceLocator;
 
-serviceLocator.initializeServices();
+// Load up all the internal services
+serviceLocator.loadService(new TypescriptLanguageService());

Script/AtomicEditor/extensionServices/resourceServices/TypescriptLanguageService.ts

@@ -105,7 +105,7 @@ export default class TypescriptLanguageService implements ExtensionServices.Reso
      * @param  {ts.CompilerOptions} options for the compiler
      */
     compile(files: string[], options: ts.CompilerOptions): void {
-
+        let start = new Date().getTime();
         //scan all the files in the project
         this.refreshProjectFiles(files);
         let errors: ts.Diagnostic[] = [];
@@ -173,6 +173,8 @@ export default class TypescriptLanguageService implements ExtensionServices.Reso
         if (errors.length) {
             this.logErrors(errors);
         }
+
+        console.log(`${this.name}: Compiling complete after ${new Date().getTime() - start} ms`);
     }
 
     /**
@@ -305,4 +307,40 @@ export default class TypescriptLanguageService implements ExtensionServices.Reso
         }
         return false;
     }
+
+    /**
+     * Determine if we care if an asset has been deleted
+     * @param  {EditorEvents.DeleteResourceEvent} ev
+     * @return {boolean}                            true if we care
+     */
+    canDelete(ev: EditorEvents.DeleteResourceEvent): boolean {
+        const ext = Atomic.getExtension(ev.path);
+        if (ext == ".ts") {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Handle the delete.  This should delete the corresponding javascript file
+     * @param  {EditorEvents.DeleteResourceEvent} ev
+     */
+    delete(ev: EditorEvents.DeleteResourceEvent) {
+        console.log(`${this.name}: received a delete resource event`);
+        if (this.versionMap[ev.path]) {
+            delete this.versionMap[ev.path];
+        }
+        let idx = this.projectFiles.indexOf(ev.path);
+        if (idx > -1) {
+            this.projectFiles.splice(idx, 1);
+        }
+
+        // Delete the corresponding js file
+        let jsFile = ev.path.replace(/\.ts$/, ".js");
+        let jsFileAsset = ToolCore.assetDatabase.getAssetByPath(jsFile);
+        if (jsFileAsset) {
+            console.log(`${this.name}: deleting corresponding .js file`);
+            ToolCore.assetDatabase.deleteAsset(jsFileAsset);
+        }
+    }
 }

Script/AtomicEditor/ui/frames/ProjectFrame.ts

@@ -25,6 +25,7 @@ import Editor = require("editor/Editor");
 import EditorEvents = require("editor/EditorEvents");
 import ProjectFrameMenu = require("./menus/ProjectFrameMenu");
 import MenuItemSources = require("./menus/MenuItemSources");
+import ServiceLocator from "../../extensionServices/ServiceLocator";
 
 class ProjectFrame extends ScriptWidget {
 
@@ -68,6 +69,7 @@ class ProjectFrame extends ScriptWidget {
 
         this.subscribeToEvent("ResourceAdded", (ev: ToolCore.ResourceAddedEvent) => this.handleResourceAdded(ev));
         this.subscribeToEvent("ResourceRemoved", (ev: ToolCore.ResourceRemovedEvent) => this.handleResourceRemoved(ev));
+        this.subscribeToEvent(EditorEvents.DeleteResource, (ev: EditorEvents.DeleteResourceEvent) => this.handleDeleteResource(ev));
         this.subscribeToEvent("AssetRenamed", (ev: ToolCore.AssetRenamedEvent) => this.handleAssetRenamed(ev));
         this.subscribeToEvent(EditorEvents.InspectorProjectReference, (ev: EditorEvents.InspectorProjectReferenceEvent) => { this.handleInspectorProjectReferenceHighlight(ev.path) });
 
@@ -103,9 +105,23 @@ class ProjectFrame extends ScriptWidget {
 
     }
 
+    /**
+     * Called when the user deletes a resource
+     * @param  {EditorEvents.DeleteResourceEvent} ev 
+     */
+    handleDeleteResource(ev: EditorEvents.DeleteResourceEvent) {
+        var db = ToolCore.getAssetDatabase();
+        db.deleteAsset(ev.asset);
+        ServiceLocator.resourceServices.deleteResource(ev);
+    }
+
     handleResourceRemoved(ev: ToolCore.ResourceRemovedEvent) {
 
         var folderList = this.folderList;
+        let asset = ToolCore.assetDatabase.getAssetByGUID(ev.guid);
+        if (asset) {
+            ServiceLocator.resourceServices.deleteResource({ path: asset.path, asset: asset });
+        }
         folderList.deleteItemByID(ev.guid);
 
         var container: Atomic.UILayout = <Atomic.UILayout>this.getWidget("contentcontainer");

Script/AtomicEditor/ui/modal/UIResourceOps.ts

@@ -56,8 +56,7 @@ export class ResourceDelete extends ModalWindow {
 
                 this.hide();
 
-                var db = ToolCore.getAssetDatabase();
-                db.deleteAsset(this.asset);
+                this.sendEvent(EditorEvents.DeleteResource, { path: this.asset.path, asset: this.asset });
 
                 return true;
             }