How to use get-folder-size - 8 common examples

archive.open(() => {

    // read the archive metafiles
    readManifest(archive, done())
    readVFile(archive, done())

    // calculate the size on disk
    var sizeCb = done()
    getFolderSize(ARCHIVE_FILEPATH(archive), (err, size) => {
      sizeCb(null, size)
    })

    done((err, manifest, vfile, size) => {
      manifest = manifest || {}
      var { name, description, author, homepage_url } = manifest
      var version = (vfile) ? vfile.current : false
      var mtime = Date.now() // use our local update time
      size = size || 0

      // write the record
      var update = { name, description, author, homepage_url, version, mtime, size }
      log('[DAT] Writing meta', update)
      archiveMetaDb.put(key, update, err => {
        if (err)
          log('[DAT] Error while writing archive meta', key, err)

archive.open(() => {
    // read the archive metafiles
    pda.readManifest(archive, done())

    // calculate the size on disk
    var sizeCb = done()
    getFolderSize(archivesDb.getArchiveFilesPath(archive), (_, size) => {
      sizeCb(null, size)
    })

    done((_, manifest, size) => {
      manifest = manifest || {}
      var { title, description, author, version, forkOf, createdBy } = manifest
      var mtime = Date.now() // use our local update time
      var isOwner = archive.owner
      size = size || 0

      // write the record
      var update = { title, description, author, version, forkOf, createdBy, mtime, size, isOwner }
      debug('Writing meta', update)
      archivesDb.setArchiveMeta(key, update).then(
        () => {
          update.key = key

new Promise((resolve, reject) => {
    getSize(dirPath, (err, size) => {
      err ? reject(err) : resolve(size)
    })
  })

return new Promise((resolve, reject) => {
    getSize(subTask.source, (err, size) => {
      if (err) {
        reject(err);
        return;
      }
      fullSize = size;
      ncp(subTask.source, subTask.destination, ncpOptions, errList => {
        if (errList) {
          reject(errList[0]);
          return;
        }
        resolve();
      });
    });
  });
}

const buffer = Buffer.alloc(arrayBuffer.byteLength);
                  const view = new Uint8Array(arrayBuffer);
                  for (let i = 0; i < arrayBuffer.byteLength; ++i) {
                    buffer[i] = view[i];
                  }
                  outputFile(filePath, buffer);
                }
              };
              reader.readAsArrayBuffer(blob);
            });
        }
      };
      if (maxSize == 0) {
        downloadImage();
      } else {
        getFolderSize(cachePath, (err: string, size: number) => {
          if (err) {
            throw err;
          }

          const mbSize = (size / 1024 / 1024);
          if (mbSize < maxSize) {
            downloadImage();
          }
        });
      }
    }
  }
}

return new Promise((resolve, reject) => {
    getFolderSize(repoPath, (err, size) => {
      if (err) {
        reject(err)
      } else {
        const humanReadableSize = byteSize(size)
        resolve(humanReadableSize)
      }
    })
  })
}

        ? new Promise((resolve, reject) => { getFolderSize(path, (err, total) => err ? reject(err) : resolve(total)) })
        : Promise.resolve(stat.size)

calculateCacheSize() {
    if (this.props.config.caching.maxSize != 0) {
      const cachePath = getCachePath(null, this.props.config);
      if (existsSync(cachePath)) {
        getFolderSize(getCachePath(null, this.props.config), (err: string, size: number) => {
          if (err) { throw err; }
          const mbSize = (size / 1024 / 1024);
          this.setState({cacheSize: mbSize.toFixed(2) + "MB"});
        });
      }
    }
  }