How to use extract-zip - 9 common examples

it('handles an error in the zip file', async () => {
      const eDownload = require('electron-download');
      eDownload.mockImplementationOnce((_p: any, c: any) => c(undefined, '/fake/path'));

      const mockZip = require('extract-zip');
      mockZip.mockImplementationOnce((_a: any, _b: any, c: any) => c(new Error('bwap-bwap')));

      await binaryManager.setup('v3.0.0');
    });
  });

return new Promise((resolve, reject) => {
    let name = path.basename(zipPath).replace(zipRE, '')
    extract(zipPath, { dir: `${zips}` }, zipError => {
      if (zipError) {
        console.error(zipError)
        reject(zipError)
      } else {
        console.log(`done extracting ${name} ensuring content is not read only`)
        console.log(`done ensuring not read only for ${name}`)
        resolve()
      }
    })
  })
}

return new Promise((resolve, reject) => {
        extract(zipPath, { dir }, e => {
            if (e) {
                reject(e);
                return;
            }
            resolve();
        });
    });
}

return new Promise((resolve) => {
        extract(template, { dir: tmp }, (error) => {
            if (error) {
                log.error(`Failed to extract template from "${template}"`, error);
            }
            const files = fs.readdirSync(tmp);
            if (files.length !== 1) {
                log.error(`The template seems no to be structured correctly "${template}"`);
            }

            resolve(path.join(tmp, files[0]));
        });
    });
}

await new Promise((resolve, reject) => {
      extractZip(overlayFilePath, { dir: assetsPath }, err => {
        if (err) {
          reject(err);
        } else {
          resolve();
        }
      });
    });

return new Promise((resolve, reject) => {
        extract(zipPath, { dir }, e => {
            if (e) {
                reject(e);
                return;
            }
            resolve();
        });
    });
}

const extract = (path: string, opts: extractZip.Options) => new Promise((resolve, reject) => extractZip(path, opts, err => { if (err) reject(err); else resolve() }))

const archiveName: string = Path.basename(url.pathname);
    const archiveType: string = ((Path.extname(archiveName) == '.zip') ? 'zip' : 'tar.gz');
    const tmpDirPath: string = Fs.mkdtempSync(Path.join(this._context.extensionPath, 'tmp-'));
    const archivePath: string = Path.join(tmpDirPath, archiveName);
    codeProgress.finishTask();

    codeProgress.startTask(0.8, i18n('downloading', name));
    Logger.log(i18n('downloadingFromTo', name, urlStr, archivePath));
    await Dependencies.downloadFile(urlStr, archivePath, codeProgress);
    codeProgress.finishTask();

    codeProgress.startTask(0.1, i18n('extracting', name));
    Logger.log(i18n('extractingTo', archivePath, tmpDirPath));

    if (archiveType == 'zip') {
      await extractZip(archivePath, {dir: tmpDirPath});
    } else {
      await Tar.extract({file: archivePath, cwd: tmpDirPath});
    }

    codeProgress.updateTask(0.8);

    const fileNames: string[] = Fs.readdirSync(tmpDirPath);
    let extractedDirPath: string | null = null;
    Logger.log(i18n('searchingForDirectory', tmpDirPath));

    for (let i: number = 0; i < fileNames.length; i++) {
      const filePath: string = Path.join(tmpDirPath, fileNames[i]);
      const stats: Fs.Stats = Fs.lstatSync(filePath);

      if (stats.isDirectory()) {
        if (extractedDirPath == null) {