fixed writing and passing FS sync

Author: christianalfoni

packages/app/src/app/overmind/effects/vscode/sandboxFsSync/index.ts

@@ -145,9 +145,10 @@ class SandboxFsSync {
   }
 
   public writeFile(fs: SandboxFs, module: Module) {
-    writeFile(fs, json(module));
+    const copy = json(module);
 
-    this.send('write-file', module);
+    writeFile(fs, copy);
+    this.send('write-file', copy);
 
     if (module.title === 'package.json') {
       this.syncDependencyTypings();
@@ -163,52 +164,30 @@ class SandboxFsSync {
   }
 
   public rmdir(fs: SandboxFs, directory: Directory) {
-    rmdir(fs, directory);
-    global.postMessage(
-      {
-        $broadcast: true,
-        $type: 'rmdir',
-        $data: directory,
-      },
-      protocolAndHost()
-    );
+    const copy = json(directory);
+
+    rmdir(fs, copy);
+    this.send('rmdir', copy);
   }
 
   public unlink(fs: SandboxFs, module: Module) {
-    unlink(fs, module);
-    global.postMessage(
-      {
-        $broadcast: true,
-        $type: 'unlink',
-        $data: module,
-      },
-      protocolAndHost()
-    );
+    const copy = json(module);
+
+    unlink(fs, copy);
+    this.send('unlink', copy);
   }
 
   public mkdir(fs: SandboxFs, directory: Directory) {
-    mkdir(fs, json(directory));
-    global.postMessage(
-      {
-        $broadcast: true,
-        $type: 'mkdir',
-        $data: directory,
-      },
-      protocolAndHost()
-    );
+    const copy = json(directory);
+
+    mkdir(fs, copy);
+    this.send('mkdir', copy);
   }
 
   private syncSandbox() {
     // eslint-disable-next-line
     console.log('## SYNCING SANDBOX AND TYPINGS WITH WORKERS');
-    global.postMessage(
-      {
-        $broadcast: true,
-        $type: 'sandbox-fs',
-        $data: json(this.options.getSandboxFs()),
-      },
-      protocolAndHost()
-    );
+    this.send('sandbox-fs', json(this.options.getSandboxFs()));
   }
 
   private async sync() {
@@ -229,7 +208,7 @@ class SandboxFsSync {
       {
         $broadcast: true,
         $type: type,
-        $data: json(data),
+        $data: data,
       },
       protocolAndHost()
     );
@@ -292,14 +271,7 @@ class SandboxFsSync {
   }
 
   private sendTypes() {
-    global.postMessage(
-      {
-        $broadcast: true,
-        $type: 'typings-sync',
-        $data: this.types,
-      },
-      protocolAndHost()
-    );
+    this.send('typings-sync', this.types);
   }
 
   /**

packages/app/src/app/overmind/namespaces/files/actions.ts

@@ -217,12 +217,14 @@ export const directoryDeleted: AsyncAction<{
       1
     )[0];
 
-    state.editor.currentModuleShortid = state.editor.mainModule.shortid;
-
-    // we need to recreate everything, as you might have deleted any number
+    // We need to recreate everything, as you might have deleted any number
     // of nested directories or files
     state.editor.modulesByPath = effects.vscode.fs.create(sandbox);
-    effects.vscode.openModule(state.editor.currentModule);
+
+    // We open the main module as we do not really know if you had opened
+    // any nested file of this directory. It would require complex logic
+    // to figure that out. This concept is soon removed anyways
+    effects.vscode.openModule(state.editor.mainModule);
     actions.editor.internal.updatePreviewCode();
     try {
       await effects.api.deleteDirectory(sandbox.id, directoryShortid);

packages/app/src/app/overmind/namespaces/live/liveMessageOperators.ts

@@ -201,14 +201,27 @@ export const onModuleDeleted: Operator<
   LiveMessage<{
     moduleShortid: string;
   }>
-> = mutate(({ actions }, { _isOwnMessage, data }) => {
+> = mutate(({ state, effects, actions }, { _isOwnMessage, data }) => {
   if (_isOwnMessage) {
     return;
   }
-  // Do not think this really works? Cause this would fork the sandbox
-  actions.files.moduleDeleted({
-    moduleShortid: data.moduleShortid,
-  });
+  const removedModule = state.editor.currentSandbox.modules.find(
+    directory => directory.shortid === data.moduleShortid
+  );
+  const moduleIndex = state.editor.currentSandbox.modules.indexOf(
+    removedModule
+  );
+  const wasCurrentModule =
+    state.editor.currentModuleShortid === data.moduleShortid;
+
+  state.editor.currentSandbox.modules.splice(moduleIndex, 1);
+  effects.vscode.fs.unlink(state.editor.modulesByPath, removedModule);
+
+  if (wasCurrentModule) {
+    actions.editor.internal.setCurrentModule(state.editor.mainModule);
+  }
+
+  actions.editor.internal.updatePreviewCode();
 });
 
 export const onDirectoryCreated: Operator<
@@ -248,15 +261,33 @@ export const onDirectoryDeleted: Operator<
   LiveMessage<{
     directoryShortid: string;
   }>
-> = mutate(({ state, actions }, { _isOwnMessage, data }) => {
+> = mutate(({ state, effects, actions }, { _isOwnMessage, data }) => {
   if (_isOwnMessage) {
     return;
   }
-  state.editor.currentModuleShortid = state.editor.mainModule.shortid;
-  // Again, this does not work very well?
-  actions.files.directoryDeleted({
-    directoryShortid: data.directoryShortid,
-  });
+  const sandbox = state.editor.currentSandbox;
+  const directory = sandbox.directories.find(
+    directoryItem => directoryItem.shortid === data.directoryShortid
+  );
+
+  if (!directory) {
+    return;
+  }
+
+  const removedDirectory = sandbox.directories.splice(
+    sandbox.directories.indexOf(directory),
+    1
+  )[0];
+
+  // We need to recreate everything, as you might have deleted any number
+  // of nested directories or files
+  state.editor.modulesByPath = effects.vscode.fs.create(sandbox);
+
+  // We open the main module as we do not really know if you had opened
+  // any nested file of this directory. It would require complex logic
+  // to figure that out. This concept is soon removed anyways
+  effects.vscode.openModule(state.editor.mainModule);
+  actions.editor.internal.updatePreviewCode();
 });
 
 export const onUserSelection: Operator<