TypeScript monterey-pal.FS类代码示例

  installNPMDependencies(project, deps = [], estimation = 'This could take minutes to complete') {
    let task = {
      title: `npm install of '${project.name}'`,
      estimation: estimation,
      logs: [],
      promise: null
    };

    let promise = NPM.install(deps, {
      npmOptions: {
        workingDirectory: FS.getFolderPath(project.packageJSONPath)
      },
      logCallback: (message) => {
        if (message.level === 'custom' || message.level === 'warning' || message.level === 'error') {
          this.taskManager.addTaskLog(task, message.message);
        }
      }
    });

    task.promise = promise;

    this.taskManager.addTask(task);

    return task;
  }

    async tryInstallLauncherFromRemote(platform, launcherPath) {
        try {
            let result = await this.getLauncher(platform, launcherPath);

            let root = FS.getRootDir();
            let file = await FS.downloadFile(result.remoteImagePath, root + "/images/app-launcher/" + platform + "/" + launcherPath + ".png");

            result.data.img = root + "/images/app-launcher/" + platform + "/" + launcherPath + ".png";
            result.data.enabled = true;

            this.state.appLaunchers.push(result);
        }
        catch(err) {
            throw new Error(`Failed to install ${platform}/${launcherPath} launcher: ${err.message}`);
        }
    }

 getJspm016Path(project, packageJSON) {
   let baseURL = '.';
   if (packageJSON.jspm.directories && packageJSON.jspm.directories.baseURL) {
     baseURL = packageJSON.jspm.directories.baseURL;
   }
   return FS.join(project.path, baseURL, 'config.js');
 }

 getJspm017Path(project, packageJSON) {
   // TODO: implement reading JSPM 0.17.x configuration
   let baseURL = '';
   if (packageJSON.jspm.directories && packageJSON.jspm.directories.baseURL) {
     baseURL = packageJSON.jspm.directories.baseURL;
   }
   return FS.join(project.path, baseURL, 'jspm.config.js');
 }

  async findJspmConfig(project) {
    let packageJSON = JSON.parse(await FS.readFile(project.packageJSONPath));
    let isUsingJSPM = false;
    let configJs = null;

    if (packageJSON.jspm) {

      await this.findJspmVersion(project, packageJSON);

      let jspm016Path = this.getJspm016Path(project, packageJSON);
      let jspm017Path = this.getJspm017Path(project, packageJSON);

      // we were unable to find JSPM in the devDependencies section of package.json
      // so we're just going to look for a config.js or a jspm.config.js
      // in order to try and determine what JSPM version is being used
      if (!project.jspmVersion) {
        if (await FS.fileExists(jspm016Path)) {
          project.configJsPath = jspm016Path;
          project.jspmVersion = '^0.16.0';
          project.jspmDefinition = '^0.16.0';
        } else if (await FS.fileExists(jspm017Path)) {
          project.configJsPath = jspm016Path;
          project.jspmVersion = '^0.17.0';
          project.jspmDefinition = '^0.17.0';
        }
      } else {
        let major = parseInt(project.jspmVersion.split('.')[0], 10);
        let minor = parseInt(project.jspmVersion.split('.')[1], 10);
        if (major === 0) {
          if (minor < 17) {
            project.configJsPath = jspm016Path;
          } else {
            project.configJsPath = jspm017Path;
          }
        }
      }

      if (project.configJsPath && project.jspmVersion) {
        isUsingJSPM = true;
      }
    }

    project.isUsingJSPM = isUsingJSPM;
  }

  /**
  * Opens a folder dialog and adds the selected folder as a project
  */
  async openDialog() {
    let projectFolder = await FS.showOpenDialog({
      title: 'Select a project folder',
      properties: ['openDirectory']
    });

    if (projectFolder && projectFolder.length > 0) {
      return this.projectManager.addProjectByPath(projectFolder[0]);
    }

    return false;
  }

  async tryLocatePackageJSON(project, p) {
    if (await FS.fileExists(p)) {
      project.packageJSONPath = FS.normalize(p);

      let packageJSON = await this.getPackageJSON(project);

      // if the project already has a name then it has just been scaffolded
      if (project.name) {
        // check if the name of the project is equal to the name mentioned in package.json
        if (packageJSON.name !== project.name) {
          // if not, update package.json to use the project name and persist this to the filesystem
          packageJSON.name = project.name;
          await FS.writeFile(project.packageJSONPath, JSON.stringify(packageJSON, null, 4));
        }
      }

      project.name = packageJSON.name;
      return true;
    }

    return false;
  }

  async manuallyLocatePackageJSON(project) {
    alert('Unable to find package.json, please point Monterey to package.json');
    let paths = await FS.showOpenDialog({
      title: 'Please select your package.JSON file',
      properties: ['openFile'],
      defaultPath: project.path,
      filters: [
        {name: 'package', extensions: ['json']}
      ]
    });

    if (paths && paths.length > 0) {
      return await this.tryLocatePackageJSON(project, paths[0]);
    }

    return false;
  }

  async openDialog(): Promise<Array<Project> | boolean> {
    let projectFolders: Array<string> = await FS.showOpenDialog({
      title: 'Select a project folder',
      properties: ['openDirectory', 'multiSelections']
    });

    if (projectFolders) {
      let projects = [];
      for (let x = 0; x < projectFolders.length; x++) {
        projects.push(await this.projectManager.addProjectByPath(projectFolders[x]));
      }

      return projects;
    }

    return false;
  }

  async analyze(project) {
    let packageJSON = JSON.parse(await FS.readFile(project.packageJSONPath));
    let deps = Object.assign({}, packageJSON.dependencies, packageJSON.devDependencies);
    let topLevelDependencies = [];

    // normalize data for the grid
    let keys = Object.keys(deps);
    for (let i = 0; i < keys.length; i++) {
      let key = keys[i];
      let dep = deps[key];

      topLevelDependencies.push({
        name: key,
        range: deps[key]
      });
    }

    return topLevelDependencies;
  }