TypeScript jsonfile.writeFileSync函數代碼示例

gulp.task('!manifest', function () {
  const meta = util.currentPackage();
  const copyInst = util.getCopyInstruction(meta);

  const pkgDest = Path.join(copyInst.to, 'package.json');
  const pkgJson = jsonfile.readFileSync(util.root('package.json'));

  const localPackageJsonPath = util.root(util.FS_REF.SRC_CONTAINER, meta.dir, 'package.json');
  if (fs.existsSync(localPackageJsonPath)) {
    Object.assign(
      pkgJson,
      jsonfile.readFileSync(localPackageJsonPath)
    )
  }

  PKGJSON_KEYS_TO_DELETE.forEach( k => { delete pkgJson[k] });

  pkgJson.name = meta.dir;
  pkgJson.main = `${util.FS_REF.BUNDLE_DIR}/${meta.umd}.rollup.umd.js`;
  pkgJson.module = `${util.FS_REF.BUNDLE_DIR}/${meta.umd}.es5.js`;
  pkgJson.es2015 = `${util.FS_REF.BUNDLE_DIR}/${meta.umd}.js`;
  pkgJson.typings = `${util.FS_REF.SRC_CONTAINER}/${util.getMainOutputFileName(meta)}.d.ts`;

  util.tryRunHook(meta.dir, 'packageJSON', pkgJson);

  jsonfile.writeFileSync(pkgDest, pkgJson, {spaces: 2});
});

        let prepareFunction = () => {
            if (pluginBinding.options.shrinkWrap) {
                pluginBinding.shellExecuteNpm(packagePath, [ "shrinkwrap" ]);

                //
                // Filter out any 'resolved' fields

                let shrinkWrapFilePath = path.join(packagePath, "npm-shrinkwrap.json");
                let shrinkwrap = require(shrinkWrapFilePath);

                function replacer(key, val) {
                    if (key === "resolved" && this.from && this.version) {
                        return undefined;
                    }

                    return val;
                }

                fs.writeFileSync(shrinkWrapFilePath, JSON.stringify(shrinkwrap, replacer, 2));
            }

            let versionBump = pluginBinding.options.versionBump;

            if (versionBump) {
                packageDescriptor = bumpVersion(packageDescriptor, packagePath, versionBump);

                jsonFile.writeFileSync(path.join(packagePath, "package.json"), packageDescriptor, { spaces: 4 });

                file.contents = new Buffer(JSON.stringify(packageDescriptor));
            }
        };

  @util.GulpClass.Task({
    name: 'misc:syncConfig',
    desc: `Sync the main tsconfig file (tsconfig.json) and JEST configuration file with paths information.
This is required after each change to a package configuration that results in a file structure change.  
This includes adding, removing or changing a package name. Changing the top-level scope, etc..`
  })
  syncConfig() {
    const tsConfig = jsonfile.readFileSync(util.root('tsconfig.json'));
    tsConfig.compilerOptions.paths = util.tsConfigPaths();
    util.tryRunHook('./', 'tsconfig', tsConfig);
    jsonfile.writeFileSync(util.root('tsconfig.json'), tsConfig, {spaces: 2});

    const jestConfig = jsonfile.readFileSync(util.root('jest.library.config.json'));
    jestConfig.moduleNameMapper = util.jestAlias();
    util.tryRunHook('./', 'jestConfig', jestConfig);
    jsonfile.writeFileSync(util.root('jest.library.config.json'), jestConfig, {spaces: 2});
  }

      .then( () => {
        const p = util.root(util.currentPackage().tsConfigObj.compilerOptions.outDir);
        del.sync(p);

        const tsConfig = jsonfile.readFileSync(util.root(util.FS_REF.TS_CONFIG_TMP));
        tsConfig.compilerOptions.target = 'es5';
        jsonfile.writeFileSync(util.root(util.FS_REF.TS_CONFIG_TMP), tsConfig, {spaces: 2});

        return new Promise( (resolve, reject) => webpack(config).run((err, stats) => err ? reject(err) : resolve(stats)) );
      })

export function jsonPatch<T>(readPath: string): { update: (handler: (data: T) => (T | null | void)) => { save: (savePath: string) => void } } {
  return {
    update(handler: (data: T) => T): any {
      const tsconfig = jsonfile.readFileSync(readPath);
      const data = handler(tsconfig);
      return {
        save(savePath: string): void {
          if (data !== null) {
            jsonfile.writeFileSync(savePath, data || tsconfig, {spaces: 2});
          }
        }
      };
    }
  };
}

var saveJSON = function (obj:any, filename: string){
  var jsonfile = require('jsonfile');
  jsonfile.writeFileSync(filename, obj)
}

    err;
});

// $ExpectType void
jsonfile.writeFile(file, obj, { spaces: 2 }, err => {
    // $ExpectType ErrnoException
    err;
});

// $ExpectType void
jsonfile.writeFile(file, obj, { spaces: 2, EOL: '\r\n' }, err => {
    // $ExpectType ErrnoException
    err;
});

// $ExpectType void
jsonfile.writeFile(file, obj, { flag: 'a' }, err => {
    // $ExpectType ErrnoException
    err;
});

// $ExpectType Promise<void>
jsonfile.writeFile(file, obj);
// $ExpectType Promise<void>
jsonfile.writeFile(file, obj, { flag: 'a' });

jsonfile.writeFileSync(file, obj);
jsonfile.writeFileSync(file, obj, { spaces: 2 });
jsonfile.writeFileSync(file, obj, { spaces: 2, EOL: '\r\n' });
jsonfile.writeFileSync(file, obj, { flag: 'a' });

 writeFileSync(filename: string, obj: any, options?: any): any {
   return jsonfile.writeFileSync(filename, obj, options);
 }