@aj-shadow/z-abs-complayer-codeeditor-client 0.0.0-aj-beta.221

package/project/client/stores/code-editor-store.js

@@ -0,0 +1,1044 @@
+
+'use strict';
+
+import { DataActionCodeEditorWorkspaceGet, DataActionCodeEditorWorkspaceNew, DataActionCodeEditorWorkspaceSearch } from '../actions/data-action-code-editor-workspace';
+import { DataActionCodeEditorProjectUpdate, DataActionCodeEditorProjectToggle } from '../actions/data-action-code-editor-project';
+import { DataActionCodeEditorFileGet, DataActionCodeEditorFileNew, DataActionCodeEditorFileRename, DataActionCodeEditorFileUpdate, DataActionCodeEditorFileDelete } from '../actions/data-action-code-editor-file';
+import { DataActionCodeEditorFolderGet, DataActionCodeEditorFolderNew, DataActionCodeEditorFolderUpdate, DataActionCodeEditorFolderDelete } from '../actions/data-action-code-editor-folder';
+import { ActionCodeEditorFileGet } from '../actions/action-code-editor-file';
+import { ActionCodeEditorFolderGet } from '../actions/action-code-editor-folder';
+import { ActionCodeEditorWorkspaceSearch } from '../actions/action-code-editor-workspace';
+import { ActionModalDialogResult } from 'z-abs-complayer-modaldialog-client/client/actions/action-modal-dialog';
+import StoreBaseRealtime from 'z-abs-corelayer-client/client/store/store-base-realtime';
+import GuidGenerator from 'z-abs-corelayer-cs/clientServer/guid-generator';
+import Project from 'z-abs-corelayer-cs/clientServer/project';
+
+
+class CodeEditorStore extends StoreBaseRealtime {
+  static showWorkspace = false;
+  static START_PATH = '/start';
+  static START_PATH_LENGTH = CodeEditorStore.START_PATH.length;
+  static CODE_EDITOR_PATH = '/code-editor';
+  static CODE_EDITOR_PATH_LENGTH = CodeEditorStore.CODE_EDITOR_PATH.length;
+  static IS_FILE = 0;
+  static IS_FOLDER = 1;
+  static IS_SEARCH = 2;
+  static SEARCH_FILES = 'SearchLines';
+  static LOG_FILES = 'LogLines';
+  static TYPE_FOLDER = 'folder';
+  static TYPE_FILE = 'file';
+  static TYPE_SEARCH = 'search';
+  
+  constructor() {
+    super({
+      project: new Project(),
+      projects: new Map(),
+      selectedProjectId: '',
+      files: new Map(),
+      searchLines: new Map([
+        [CodeEditorStore.SEARCH_FILES, new Map()],
+        [CodeEditorStore.LOG_FILES, new Map()]
+      ]),
+      current: {
+        file: null,
+        folder: null,
+        type: '',
+        url: {
+          pathname: '',
+          query: {},
+          line: 1,
+          css: undefined
+        }
+      },
+      build: {
+        errors: []
+      },
+      persistentData: {
+        darkMode: false,
+        emptyLine: true
+      },
+      eol: '\n'
+    });
+  }
+  
+  _getAppName() {
+    return this.state.current.url.query?.workspace ? this.state.current.url.query.workspace : window.actorJsReleaseData.appName;
+  }
+  
+  _getWorkspaceName() {
+    return this.state.current.url.query?.workspace ? this.state.current.url.query.workspace : window.actorJsReleaseData.appName;
+  }
+  
+  onInit() {
+    const url = this._parseUrl(location.pathname, location.search);
+    const appName = url.query.workspace ? url.query.workspace : window.actorJsReleaseData.appName;
+    const workspaceName = url.query.workspace ? url.query.workspace : window.actorJsReleaseData.appName;
+    this.sendDataAction(new DataActionCodeEditorWorkspaceGet(appName, workspaceName, true));
+  }
+  
+  onActionCodeEditorWorkspaceGet(action) {
+    const appName = action.appName ? action.appName : this._getAppName();
+    const workspaceName = action.workspaceName ? action.workspaceName : this._getWorkspaceName();
+    this.sendDataAction(new DataActionCodeEditorWorkspaceGet(appName, workspaceName, false));
+  }
+  
+  onActionCodeEditorPersistentDataUpdate(action) {
+    const persistentData = this.deepCopy(this.state.persistentData);
+    const parent = action.parentName ? persistentData[action.parentName] : persistentData;
+    parent[action.name] = action.value;
+    this.updateState({persistentData: {$set: parent}});
+  }
+  
+  onActionCodeEditorWorkspaceNew(action) {
+    this.sendDataAction(new DataActionCodeEditorWorkspaceNew(action.appName, action.workspaceName));
+  }
+  
+  onActionCodeEditorWorkspaceSearch(action) {
+    this.sendDataAction(new DataActionCodeEditorWorkspaceSearch(action));
+  }
+  
+  onActionCodeEditorWorkspaceSearchSet(action) {
+    this._setCurrentSearch(action.key);
+  }
+  
+  onActionCodeEditorFileSet(action) {
+    const node = this._getNode(action.url);
+    if(node) {
+      this.updateState({searchLines: (searchLine) => {
+        const search = searchLine.get(action.name);
+        if(search) {
+          const line = {
+            line: action.line,
+            type: action.type
+          };
+          const lines = search.get(action.url);
+          if(lines) {
+            if(!lines.some(obj => obj.line === line.line)) {
+              lines.push(line);
+            }
+          }
+          else {
+            search.set(action.url, [line]);
+          }
+        }
+      }});
+      const project = this._getProject(node.projectId);
+      this.onActionCodeEditorFileGet(new ActionCodeEditorFileGet(node.projectId, node.node.key, node.node.title, node.node.data.path, node.node.data.type, project.plugin, project.workspaceName));
+    }
+  }
+  
+  onActionCodeEditorFileGet(action) {
+    const file = this.state.files.get(action.key);
+    if(!file) {
+      const project = this._getProject(action.projectId);
+      this.sendDataAction(new DataActionCodeEditorFileGet(`${action.path}/${action.title}`, action.projectId, action.key, action.title, action.path, action.type, project.type, project.plugin, project.workspaceName));
+    }
+    else {
+      this._setCurrentFile(file, null, file.valid);
+    }
+  }
+  
+  onActionCodeEditorFileNew(action) {
+    const project = this._getProject(action.projectId);
+    this.sendDataAction(new DataActionCodeEditorFileNew(action, project.type, project.plugin, project.workspaceName));
+  }
+  
+  onActionCodeEditorFileAdd(action) {
+    let node = null;
+    let projectType = null;
+    let projectPlugin = null;
+    let projectWorkspaceName = null;
+    this._updateProject(action.projectId, (project, app) => {
+      node = project.addFile(action.title, action.path, action.type);
+      project.sortParent(node);
+      if(!app) {
+        projectType = project.type;
+        projectPlugin = project.plugin;
+      }
+      else {
+        projectWorkspaceName = project.workspaceName;
+      }
+    });
+    this.sendDataAction(new DataActionCodeEditorFileGet(`${node.data.path}/${node.title}`, action.projectId, node.key, node.title, node.data.path, node.data.type, projectType, projectPlugin, projectWorkspaceName));
+  }
+  
+  onActionCodeEditorFileRename(action) {
+    const project = this._getProject(action.projectId);
+    this.sendDataAction(new DataActionCodeEditorFileRename(`${action.path}/${action.title}`, `${action.path}/${action.newTitle}`, project.type, project.plugin, action, project.workspaceName));
+  }
+  
+  onActionCodeEditorFileUpdate(action) {
+    const file = this.state.files.get(action.key);
+    const project = this._getProject(file.projectId);
+    this.sendDataAction(new DataActionCodeEditorFileUpdate(action.key, file.title, file.path, file.content, project.type, project.plugin, project.workspaceName));
+  }
+  
+  onActionCodeEditorFileUpdateAll(action) {
+    action.keys.forEach((key) => {
+      const file = this.state.files.get(key);
+      const project = this._getProject(file.projectId);
+      this.sendDataAction(new DataActionCodeEditorFileUpdate(key, file.title, file.path, file.content, project.type, project.plugin, project.workspaceName));
+    });
+  }
+    
+  onActionCodeEditorFileEdit(action) {
+    const file = this.state.files.get(action.key);
+    this.updateState({current: {file: { content: {$set: action.content}}}});
+    this.updateState({current: {file: { codeChanged: {$set: action.content !== file.contentOriginal}}}});
+    this.updateState({files: (files) => {
+      files.set(action.key, this.state.current.file);
+    }});
+  }
+  
+  onActionCodeEditorFileClose(action) {
+    const file = this.state.files.get(action.key);
+    const nextFile = this._getNextFile(file);
+    this.updateState({files: (files) => {
+      files.delete(action.key);
+    }});
+    this._setCurrentFile(nextFile, file, true);
+  }
+  
+  onActionCodeEditorFileRemove(action) {
+    const file = this.state.files.get(action.key) || this.state.current.file;
+    const nextFile = this._getNextFile(file);
+    this.updateState({files: (files) => {
+      files.delete(action.key);
+    }});
+    this._updateProject(action.projectId, (project, app) => {
+      project.removeNode(file.path, file.key);
+    });
+    if(nextFile) {
+      this._setCurrentFile(nextFile, file, true);
+    }
+    else {
+      this._setCurrentFile(null, null, false);
+      const node = this._getNode(file.path);
+      const folder = this._createFolder(node.projectId, node.node);
+      this._setCurrentFolder(folder, true);
+    }
+  }
+  
+  onActionCodeEditorFileDelete(action) {
+    const file = this.state.files.get(action.key);
+    const project = this._getProject(action.projectId);
+    this.sendDataAction(new DataActionCodeEditorFileDelete(`${file.path}/${file.title}`, project.type, project.plugin, action, project.workspaceName));
+  }
+  
+  onActionCodeEditorFolderGet(action) {
+    const project = this._getProject(action.projectId);
+    this.sendDataAction(new DataActionCodeEditorFolderGet(action, project.type, project.plugin, project.workspaceName));
+  }
+  
+  onActionCodeEditorFolderNew(action) {
+    const project = this._getProject(action.projectId);
+    this.sendDataAction(new DataActionCodeEditorFolderNew(action, project.type, project.plugin, project.workspaceName));
+  }
+   
+  onActionCodeEditorFolderAdd(action) {
+    let node = null;
+    let currentProject = null;
+    this._updateProject(action.projectId, (project, app) => {
+      currentProject = project;
+      node = project.addFolder(action.title, action.data);
+      project.sortParent(node);
+    });
+    const folder = this._createFolder(currentProject.projectId, node);
+    this._setCurrentFolder(folder, true);
+  }
+  
+  onActionCodeEditorFolderUpdate(action) {
+    const project = this._getProject(action.projectId);
+    this.sendDataAction(new DataActionCodeEditorFolderUpdate(`${action.data.path}/${action.title}`, `${action.data.path}/${action.newTitle}`, action, project.type, project.plugin, project.workspaceName));
+  }
+  
+  onActionCodeEditorFolderRemove(action) {
+    const node = this._getNode(`${action.data.path}/${action.title}`);
+    const children = this.state.project.getAllFileChildren(node.node);
+    
+    children.forEach((child) => {
+      const file = this.state.files.get(child.key);
+      if(file) {
+        this.onActionCodeEditorFileClose({key: child.key});
+      }
+    });
+    const nodeParent = this._getNode(node.node.data.path);
+    const folder = this._createFolder(nodeParent.projectId, nodeParent.node);
+    this._updateProject(action.projectId, (project, app) => {
+      project.removeNode(action.data.path, action.key);
+    });
+    this._setCurrentFolder(folder, true);
+  }
+  
+  onActionCodeEditorFolderDelete(action) {
+    const project = this._getProject(action.projectId);
+    this.sendDataAction(new DataActionCodeEditorFolderDelete(action, project.type, project.plugin, project.workspaceName));
+  }
+  
+  onActionCodeEditorFileMove(action) {
+    let found = false;
+    let foundFromKey = false;
+    let foundToKey = false;
+    let newMap = new Map();
+    let fromFile = null;
+    this.state.files.forEach((file, key) => {
+      if(!found) {
+        if(action.fromKey === key) {
+          foundFromKey = true;
+          found = true;
+        }
+        else if(action.toKey === key) {
+          fromFile = this.state.files.get(action.fromKey);
+          newMap.set(action.fromKey, fromFile);
+          newMap.set(action.toKey, file);
+          foundToKey = true;
+          found = true;
+        }
+        else {
+          newMap.set(key, file);
+        }
+      }
+      else {
+        if(foundFromKey) {
+          if(action.toKey === key) {
+            newMap.set(action.toKey, file);
+            fromFile = this.state.files.get(action.fromKey);
+            newMap.set(action.fromKey, fromFile);
+          }
+          else if(action.fromKey !== key) {
+            newMap.set(key, file);
+          }
+        }
+        else if(foundToKey) {
+           if(action.fromKey !== key) {
+            newMap.set(key, file);
+          }
+        }
+      }
+    });
+    this.updateState({files: {$set: newMap}});
+    this._setCurrentFile(fromFile, null, true);
+  }
+  
+  onActionCodeEditorProjectUpdateAll(action) {
+    action.projectIds.forEach((projectId) => {
+      const project = this._getProject(projectId);
+      if(!project.type) {
+        this.sendDataAction(new DataActionCodeEditorProjectUpdate(project.projectId, project.source, this._getAppName()));
+      }
+      else {
+        this.sendDataAction(new DataActionCodeEditorProjectUpdate(project.projectId, project.source, project.source[0].title, project.type, project.plugin));
+      }
+    });
+  }
+  
+  onActionCodeEditorProjectToggle(action) {
+    let isApp = true;
+    this._updateProject(action.projectId, (project, app) => {
+      isApp = app;
+      project.toggle(action.key, action.expanded);
+    });
+    const project = this._getProject(action.projectId);
+    if(isApp) {
+      this.sendDataAction(new DataActionCodeEditorProjectToggle(action, this.state.project.source, this._getAppName()));
+    }
+    else {
+      this.sendDataAction(new DataActionCodeEditorProjectToggle(action, project.source, project.source[0].title, project.type));
+    }
+  }
+  
+  onActionActorEditorBuild(action) {
+    this.sendDataAction(new DataActionCodeEditorBuild(this.state.current.file.content, this.state.current.file.path, this.state.current.file.title));
+  }
+  
+  onDataActionCodeEditorWorkspaceGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      if(Array.isArray(response.data)) {
+        this.updateState({project: (project) => {
+          project.set(response.data[0], null, action.workspaceName);
+        }});
+        this.updateState({eol: {$set: response.data[2]}});
+        this.updateState({projects: (projects) => {
+          projects.clear();
+          const projectsExternal = response.data[1];
+          projectsExternal.sort((a, b) => {
+            if(a.source[0].title < b.source[0].title) {
+              return -1;  
+            }
+            else if(a.source[0].title > b.source[0].title) {
+              return 1;
+            }
+            else {
+              return 0;
+            }
+          });
+          this.updateState({files: (files) => {
+            if(0 !== files.size) {
+              files.clear();
+            }
+          }});
+          for(let i = 0; i < projectsExternal.length; ++i) {
+            const projectData = projectsExternal[i];
+            const project = new Project(projectData.source, projectData.type, projectData.plugin);
+            projects.set(project.projectId, project);
+          }
+        }});
+      }
+      const url = this._parseUrl(location.pathname, location.search);
+      this.updateState({current: {url: {$set: url}}});
+      if(action.open) {
+        // TODO: LINE
+        const filesData = {
+          file: url.query.file ? `.${url.query.file}` : null,
+          folder: url.query.folder ? `.${url.query.folder}` : null,
+          search: url.query.search,
+          filesToLoad: [],
+          filesNotLoaded: 0,
+          filesLoaded: new Map(),
+          searchesToLoad: [],
+          searchesNotLoaded: 0,
+          searchesLoaded: new Map()
+        };
+        if(url.query.files) {
+          filesData.filesToLoad = url.query.files.split(',');
+          filesData.filesNotLoaded = filesData.filesToLoad.length;
+          const filesNotToLoad = [];
+          filesData.filesToLoad.forEach((fileToLoad) => {
+            const fileToLoadParam = fileToLoad.split(';');
+            const currentUrl = `.${fileToLoadParam[1]}`;
+            const node = this._getNode(currentUrl);
+            if(node) {
+              const project = this._getProject(node.projectId);
+              this.sendDataAction(new DataActionCodeEditorFileGet(currentUrl, node.projectId, node.node.key, node.node.title, node.node.data.path, node.node.data.type, project.type, project.plugin, project.workspaceName, filesData));
+            }
+            else {
+              filesNotToLoad.push(fileToLoad);
+            }
+          });
+          if(0 !== filesNotToLoad.length) {
+            filesData.filesNotLoaded -= filesNotToLoad.length;
+            filesNotToLoad.forEach((fileNotToLoad) => {
+              const index = filesData.filesToLoad.indexOf(fileNotToLoad);
+              if(-1 !== index) {
+                filesData.filesToLoad.splice(index, 1);
+              }
+            });
+          }
+        }
+        if(url.query.searches) {
+          filesData.searchesToLoad = url.query.searches.split(',');
+          filesData.searchesNotLoaded = filesData.searchesToLoad.length;
+          filesData.searchesToLoad.forEach((searchToLoad) => {
+            const params = searchToLoad.split(';');
+            this.onActionCodeEditorWorkspaceSearch(new ActionCodeEditorWorkspaceSearch(params[1], params[2], params[0], filesData));
+          });
+        }
+        if(url.query.folder) {
+          const node = this._getNode(`.${url.query.folder}`);
+          if(node) {
+            const project = this._getProject(node.projectId);
+            this.sendDataAction(new DataActionCodeEditorFolderGet(new ActionCodeEditorFolderGet(node.projectId, node.node.key, node.node.title, node.node.data, project.workspaceNam), project.type, project.plugin, project.workspaceName));
+          }
+        }
+      }
+      else {
+        if(query?.workspace !== action.appName) {
+          this.updateState({current: {url: {query: {workspace: {$set: action.appName}}}}});
+          this._setCurrentFile(null, null, false);
+        }
+        else {
+          
+        }
+      }
+    }
+  }
+  
+  onDataActionCodeEditorWorkspaceNew(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      //this.updateState({current: {workspace: {$set: new Map(response.data)}}});
+    }
+  }
+  
+  _filesDataLoaded(action) {
+    const pathname = action.filesData.file;
+    const filesToLoad = action.filesData.filesToLoad;
+    const searchesToLoad = action.filesData.searchesToLoad;
+    let currentFile = null;
+    let currentSearchKey = null;
+    let currentFileValid = false;
+    const loadOrder = new Map();
+    filesToLoad.forEach((fileToLoad) => {
+      const fileToLoadParams = fileToLoad.split(';');
+      loadOrder.set(Number.parseInt(fileToLoadParams[0]), {
+        type: CodeEditorStore.IS_FILE,
+        params: fileToLoadParams
+      });
+    });
+    searchesToLoad.forEach((searchToLoad) => {
+      const searchToLoadParams = searchToLoad.split(';');
+      loadOrder.set(Number.parseInt(searchToLoadParams[0]), {
+        type: CodeEditorStore.IS_SEARCH,
+        params: searchToLoadParams
+      });
+    });
+    const length = loadOrder.size;
+    for(let i = 0; i < length; ++i) {
+      const loadData = loadOrder.get(i);
+      if(CodeEditorStore.IS_FILE === loadData.type) {
+        const fileLoaded = action.filesData.filesLoaded.get(`.${loadData.params[1]}`);
+        if(action.filesData.file === `${fileLoaded.file.path}/${fileLoaded.file.title}`) {
+          currentFile = fileLoaded.file;
+          currentFileValid = fileLoaded.valid;
+        }
+        this.updateState({files: (files) => { 
+          files.set(fileLoaded.file.key, fileLoaded.file);
+        }});
+      }
+      else if(CodeEditorStore.IS_SEARCH === loadData.type) {
+        const searchLoaded = action.filesData.searchesLoaded.get(loadData.params[0]);
+        if(action.filesData.search === `${searchLoaded.search};${searchLoaded.rules}`) {
+          currentSearchKey = searchLoaded.key;
+        }
+        this.updateState({files: (files) => {
+          files.set(searchLoaded.key, searchLoaded);
+        }});
+      }
+    }    
+    if(currentFile) {
+      this._setCurrentFile(currentFile, null, currentFileValid);
+    }
+    if(currentSearchKey) {
+      this._setCurrentSearch(currentSearchKey);
+    }
+    if(action.filesData.folder) {
+      const node = this._getNode(action.filesData.folder);
+      if(node) {
+        const project = this._getProject(node.projectId);
+        this.sendDataAction(new DataActionCodeEditorFolderGet(new ActionCodeEditorFolderGet(node.projectId, node.node.key, node.node.title, node.node.data, project.workspaceNam), project.type, project.plugin, project.workspaceName));
+      }
+    }
+  }
+  
+  onDataActionCodeEditorWorkspaceSearch(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      const data = {
+        key: GuidGenerator.create(),
+        tabType: CodeEditorStore.TYPE_SEARCH,
+        title: ` ${action.search.length <= 23 ? action.search : action.search.substring(0, 20) + '...'}`,
+        search: action.search,
+        rules: action.rules,
+        data: response.data
+      };
+      if(!action.filesData) {
+        this.updateState({files: (files) => {
+          files.set(data.key, data); 
+        }});
+        this._setCurrentSearch(data.key);
+      }
+      else {
+        action.filesData.searchesLoaded.set(action.index, data);
+        if(0 === --action.filesData.searchesNotLoaded && 0 === action.filesData.filesNotLoaded) {
+          this._filesDataLoaded(action);
+        }
+      }
+    }
+  }
+  
+  onDataActionCodeEditorFileGet(action) {
+    const response = action.getResponse();
+    const isSuccess = response.isSuccess();
+    const file = isSuccess ? {
+      key: action.key,
+      tabType: CodeEditorStore.TYPE_FILE,
+      projectId: action.projectId,
+      title: action.title,
+      path: action.path,
+      type: action.type,
+      plugin: action.plugin,
+      workspaceName: action.workspaceName,
+      content: response.data,
+      contentOriginal: response.data,
+      codeChanged: false,
+      codeBuilt: false,
+      valid: true
+    } : {
+      key: action.key,
+      tabType: CodeEditorStore.TYPE_FILE,
+      projectId: action.projectId,
+      title: action.title,
+      path: action.path,
+      type: action.type,
+      plugin: action.plugin,
+      workspaceName: action.workspaceName,
+      content: '',
+      contentOriginal: '',
+      codeChanged: false,
+      codeBuilt: false,
+      valid: false
+    };
+    this._updateProject(file.projectId, (project, app) => {
+      const node = project.findNode(`${file.path}/${file.title}`);
+      node.data.valid = isSuccess;
+    });
+    if(!action.filesData) {
+      this.updateState({files: (files) => { files.set(file.key, file); }});
+      this._setCurrentFile(file, null, isSuccess);
+    }
+    else {
+      action.filesData.filesLoaded.set(`${file.path}/${file.title}`, {
+        file,
+        valid: isSuccess
+      });
+      if(0 === --action.filesData.filesNotLoaded && 0 === action.filesData.searchesNotLoaded) {
+        this._filesDataLoaded(action);
+      }
+    }
+  }
+  
+  onDataActionCodeEditorFileNew(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      let node;
+      let projectType;
+      let projectPlugin;
+      let projectWorkspaceName;
+      this._updateProject(action.projectId, (project, app) => {
+        node = project.addFile(response.data, action.path, action.type);
+        project.sortParent(node);
+        if(!app) {
+          projectType = project.type;
+          projectPlugin= project.plugin;
+        }
+        else {
+          projectWorkspaceName = project.workspaceName;
+        }
+      });
+      this.sendDataAction(new DataActionCodeEditorFileGet(`${node.data.path}/${node.title}`, action.projectId, node.key, node.title, node.data.path, node.data.type, projectType, projectPlugin, projectWorkspaceName));
+    }
+  }
+  
+  onDataActionCodeEditorFileRename(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      let node = this._getNode(`${action.path}/${action.title}`);
+      this._updateProject(action.projectId, (project, app) => {
+        project.renameFile(node.node, action.newTitle);
+      });
+      let file = this.state.files.get(node.node.key);
+      const updatedFile = this.shallowCopy(file);
+      updatedFile.title = action.newTitle;
+      this.updateState({files: (files) => {
+        file = files.set(node.node.key, updatedFile);
+      }});
+      this._setCurrentFile(updatedFile, null, true);
+    }
+  }
+  
+  onDataActionCodeEditorFileUpdate(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      let file = this.state.files.get(action.key);
+      if(file) {
+        let updatedFile = this.shallowCopy(file);
+        updatedFile.codeChanged = false;
+        updatedFile.contentOriginal = action.content;
+        this.updateState({files: (files) => {
+          files.set(action.key, updatedFile);
+        }});
+        if(this.state.current.file.key === action.key) {
+          this.updateState({current: {file: {$set: updatedFile}}});
+        }
+      }
+    }
+  }
+  
+  onDataActionCodeEditorFileDelete(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this.onActionCodeEditorFileRemove(action);
+    }
+  }
+  
+  onDataActionCodeEditorFolderGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      const project = this._getProject(action.projectId);
+      if(project) {
+        const node = project.findNode(`${action.data.path}/${action.title}`);
+        if(node) {
+          const folder = this._createFolder(action.projectId, node);
+          this._setCurrentFolder(folder, response.data);
+        }
+      }
+    }
+  }
+  
+  onDataActionCodeEditorFolderNew(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      let node = null;
+      let currentProject = null;
+      this._updateProject(action.projectId, (project, app) => {
+        currentProject = project;
+        node = project.addFolder(action.title, action.data);
+        project.sortParent(node);
+      });
+      const folder = this._createFolder(currentProject.projectId, node);
+      this._setCurrentFolder(folder, true);
+    }
+  }
+  
+  onDataActionCodeEditorFolderUpdate(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      let node = this._getNode(`${action.data.path}/${action.title}`);
+      const children = this.state.project.getAllFileChildren(node.node);
+      this._updateProject(action.projectId, (project, app) => {
+        project.renamePathRecursive(node.node, action.newTitle);
+      });
+      node = this._getNode(`${action.data.path}/${action.newTitle}`);
+      const folder = this._createFolder(node.projectId, node.node);
+      this._setCurrentFolder(folder, true);
+      children.forEach((child) => {
+        let file;
+        this.updateState({files: (files) => {
+          file = files.get(child.key);
+          if(file) {
+            file = this.shallowCopy(file);
+            file.path = child.data.path;
+            files.set(child.key, file);
+          }
+        }});
+        /*if(this.state.current.file && this.state.current.file.key === child.key) {
+          this.updateState({current: {file: {$set: file}}});
+        }*/
+      });
+    }
+  }
+  
+  onDataActionCodeEditorFolderDelete(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this.onActionCodeEditorFolderRemove(action);
+    }
+  }
+    
+  onDataActionCodeEditorProjectUpdate(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this._updateProject(action.projectId, (project, app) => {
+        project.setSaved();
+      });
+    }
+  }
+  
+  onDataActionCodeEditorProjectToggle(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+    }
+  }
+  
+  _getNextFile(file) {
+    let next;
+    let mapIter = this.state.files.values();
+    let iter = mapIter.next();
+    while(!iter.done) {
+      if(iter.value.key === file.key) {
+        if(next) {
+          return next;
+        }
+        else {
+          return mapIter.next().value;
+        }  
+      }
+      next = iter.value;
+      iter = mapIter.next();
+    }
+  }
+  
+  _getProject(projectId) {
+    if(projectId === this.state.project.projectId) {
+      return this.state.project;
+    }
+    else {
+      return this.state.projects.get(projectId);
+    }
+  }
+    
+  _updateProject(projectId, cb) {
+    if(projectId === this.state.project.projectId) {
+      this.updateState({project: (project) => cb(project, true)});
+    }
+    else {
+      this.updateState({projects: (projects) => {
+        const project = projects.get(projectId);
+        if(project) {
+          const clonedProject = project.clone();
+          cb(clonedProject, false);
+          projects.set(projectId, clonedProject); // MUST update projectObject to trigger React.
+        }
+      }});
+    }
+  }
+  
+  _setSelectedProject(projectId) {
+    if(projectId !== this.state.selectedProjectId) {
+      if(this.state.selectedProjectId) {
+        this._updateProject(this.state.selectedProjectId, (project, app) => {
+          project.unSelect();
+        });
+      }
+      this.updateState({selectedProjectId: {$set: projectId}});
+    }
+  }
+  
+  _getNode(file) {
+    const node = this.state.project.findNode(file);
+    if(node) {
+      return {
+        projectId: this.state.project.projectId,
+        node: node
+      };
+    }
+    else {
+      for(let projectItem of this.state.projects) {
+        const project = projectItem[1];
+        const node = project.findNode(file);
+        if(node) {
+          return {
+            projectId: project.projectId,
+            node: node
+          };
+        }
+      }
+    }
+  }
+  
+  _createFolder(projectId, node) {
+    return {
+      projectId: projectId,
+      key: node.key,
+      title: node.title,
+      data: node.data
+    };
+  }
+  
+  _setCurrentFile(fileAdd, fileRemove, valid) {
+    this.updateState({current: {file: {$set: fileAdd}}});
+    this.updateState({current: {folder: {$set: null}}});
+    if(fileRemove) {
+      if("search" === fileRemove.tabType) {
+        this._updateSearch();
+      }
+      else {
+        const url = this._removeUrl(fileRemove.path, fileRemove.title, true);
+        const parsedUrl = this._parseUrl(url);
+        this.updateState({current: {url: {$set: parsedUrl}}});
+        this.history(url, {replace: true, noSlash:true});
+      }
+    }
+    if(fileAdd) {
+      if("search" === fileAdd.tabType) {
+        this._setCurrentSearch(fileAdd.key);
+      }
+      else {
+        this._updateProject(fileAdd.projectId, (project, app) => {
+          project.select(fileAdd.key, true);
+          const node = project.findNode(`${fileAdd.path}/${fileAdd.title}`);
+          if(node) {
+            node.data.valid = valid;
+          }
+        });
+        this._setSelectedProject(fileAdd.projectId);
+        this.updateState({current: {type: {$set: CodeEditorStore.TYPE_FILE}}});
+        const url = this._addUrl(fileAdd.path, fileAdd.title, true);
+        const parsedUrl = this._parseUrl(url);
+        this.updateState({current: {url: {$set: parsedUrl}}});
+        this.history(url, {replace: true, noSlash:true});
+      }
+    }
+    else {
+      if(this.state.selectedProjectId) {
+        this._updateProject(this.state.selectedProjectId, (project, app) => {
+          project.unSelect();
+        });
+      }
+      this.updateState({current: {type: {$set: ''}}});
+      const url = this._addUrl(null, null, true);
+      const parsedUrl = this._parseUrl(url);
+      this.updateState({current: {url: {$set: parsedUrl}}});
+      this.history(url, {replace: true, noSlash:true});
+    }
+  }
+  
+  _setCurrentFolder(folder, valid) {
+    this._updateProject(folder.projectId, (project, app) => {
+      project.select(folder.key, true);
+      const node = project.findNode(`${folder.data.path}/${folder.title}`);
+      if(node) {
+        node.data.valid = valid;
+      }
+    });
+    this._setSelectedProject(folder.projectId);
+    this.updateState({current: {folder: {$set: folder}}});
+    this.updateState({current: {type: {$set: CodeEditorStore.TYPE_FOLDER}}});
+    const url = this._addUrl(folder.data.path, folder.title, false);
+    const parsedUrl = this._parseUrl(url);
+    this.updateState({current: {url: {$set: parsedUrl}}});
+    this.history(url, {replace: true, noSlash:true});
+  }
+  
+  _setCurrentSearch(key) {
+    const data = this.state.files.get(key);
+    this.updateState({current: {file: {$set: data}}});
+    this.updateState({current: {type: {$set: CodeEditorStore.TYPE_SEARCH}}});
+    const url = this._updateSearch(`${data.search};${data.rules}`);
+    const parsedUrl = this._parseUrl(url);
+    this.updateState({current: {url: {$set: parsedUrl}}});
+    this.history(url, {replace: true, noSlash:true});
+  }
+  
+  _parseUrl(pathname, search) {
+    if(!search) {
+      const index = pathname.indexOf('?');
+      if(-1 !== index) {
+        search = pathname.substring(index);
+        pathname = pathname.substring(0, index);
+      }
+    }
+    let currentPathname = '';
+    if(-1 !== pathname.indexOf(CodeEditorStore.START_PATH)) {
+      currentPathname = `.${pathname.substring(CodeEditorStore.START_PATH_LENGTH)}`;
+    }
+    else if(-1 !== pathname.indexOf(CodeEditorStore.CODE_EDITOR_PATH)) {
+      currentPathname = `.${pathname.substring(CodeEditorStore.CODE_EDITOR_PATH_LENGTH)}`;
+    }
+    else {
+      currentPathname = `.${pathname}`;
+    }
+    const url = {
+      pathname: currentPathname,
+      query: {}
+    };
+    if(search && search.length > 1) {
+      const searchs = search.substring(1).split('&');
+      if(searchs && searchs.length >= 1) {
+        searchs.forEach((searchPart) => {
+          const queryParam = searchPart.split('=');
+          if(2 === queryParam.length) {
+            url.query[queryParam[0]] = queryParam[1];
+            if('files' === queryParam[0]) {
+              let filesQuery = ''
+              const filesParam = queryParam[1].split(',');
+              filesParam.forEach((fileParam) => {
+                const params = fileParam.split(';');
+                filesQuery += `${params[0]};${params[1]},`;
+                if(params[2] && params[3]) {
+                  this.updateContext(() => {
+                    this.updateState({searchLines: (searchLine) => {
+                      const logFiles = searchLine.get(CodeEditorStore.LOG_FILES);
+                      if(logFiles) {
+                        const lines = logFiles.get(params[1]);
+                        const line = {
+                          line: params[2],
+                          type: params[3]
+                        };
+                        if(lines) {
+                          if(!lines.some(obj => obj.line === params[2])) {
+                            lines.push(line);
+                          }
+                        }
+                        else {
+                          logFiles.set(params[1], [line]);
+                        }
+                      }
+                    }});
+                  });
+                }
+              });
+              url.query[queryParam[0]] = filesQuery.substring(0, filesQuery.length - 1);
+            }
+          }
+        });
+      }
+    }
+    return url;
+  }
+  
+  _addUrlSearch(resultingUrl, name, param) {
+    if(param) {
+      if(resultingUrl.p) {
+        resultingUrl.p += '&';
+      }
+      resultingUrl.p += `${name}=${param}`;
+    }
+  }
+  
+  _generateQuery(url, type) {
+    const query = this.state.current.url.query;
+    let file = CodeEditorStore.IS_FILE === type ? (url ? url : '') : (CodeEditorStore.IS_FOLDER === type ? query.file : '');
+    let folder = CodeEditorStore.IS_FOLDER === type ? url : '';
+    let search = CodeEditorStore.IS_SEARCH === type ? url : '';
+    let files = [];
+    let searches = [];
+    let index = -1;
+    this.state.files.forEach((file) => {
+      if("search" === file.tabType) {
+        searches.push(`${++index};${file.search};${file.rules}`);
+      }
+      else {
+        files.push(`${++index};${file.path.substring(1)}/${file.title}`);
+      }
+    });
+    const resultingUrl = {
+      p: ''
+    };
+    this._addUrlSearch(resultingUrl, 'file', file);
+    this._addUrlSearch(resultingUrl, 'folder', folder);
+    this._addUrlSearch(resultingUrl, 'search', search);
+    this._addUrlSearch(resultingUrl, 'files', files.join(','));
+    this._addUrlSearch(resultingUrl, 'searches', searches.join(','));
+    if(resultingUrl.p) {
+      resultingUrl.p = `?${resultingUrl.p}`;
+    }
+    return resultingUrl.p;
+  }
+  
+  _addUrl(path, title, isFile) {
+    const query = this.state.current.url.query;
+    if(CodeEditorStore.showWorkspace) {
+      if(path && title) {
+        const url = `${path.substring(1)}/${title}`
+        return `${url}?workspace=${query.workspace}`;
+      }
+      else {
+        return `?workspace=${query.workspace}`;
+      }
+    }
+    else {
+      const url = (path && title) ? `${path.substring(1)}/${title}` : null;
+      return this._generateQuery(url, isFile ? CodeEditorStore.IS_FILE : CodeEditorStore.IS_FOLDER);
+    }
+  }
+  
+  _removeUrl(path, title, isFile) {
+    const query = this.state.current.url.query;
+    if(CodeEditorStore.showWorkspace) {
+      
+    }
+    else {
+      const url = `${path.substring(1)}/${title}`
+      return this._generateQuery(url, isFile ? CodeEditorStore.IS_FILE : CodeEditorStore.IS_FOLDER);
+    }
+  }
+  
+  _updateSearch(search) {
+    return this._generateQuery(search, CodeEditorStore.IS_SEARCH);
+  }
+}
+
+
+module.exports = CodeEditorStore.export(CodeEditorStore);