fixes #619

Author: joaomoreno

src/zip.ts

@@ -1,70 +1,65 @@
-import { Entry, open, ZipFile } from 'yauzl';
+import { Entry, open, Options, ZipFile } from 'yauzl';
 import { Manifest } from './manifest';
 import { parseXmlManifest, XMLManifest } from './xml';
+import { promisify } from 'util';
+import { Readable } from 'stream';
 
-function readEntryString(zipfile: ZipFile, entry: Entry, cb: (err: Error, result?: string) => void): void {
-	zipfile.openReadStream(entry, (err, stream) => {
-		if (err) {
-			return cb(err);
-		}
-
+async function bufferStream(stream: Readable): Promise<Buffer> {
+	return await new Promise((c, e) => {
 		const buffers = [];
 		stream.on('data', buffer => buffers.push(buffer));
-		stream.once('error', cb);
-		stream.once('end', () => {
-			try {
-				cb(null, Buffer.concat(buffers).toString('utf8'));
-			} catch (err) {
-				cb(err);
-			}
-		});
+		stream.once('error', e);
+		stream.once('end', () => c(Buffer.concat(buffers)));
 	});
 }
 
-export function readVSIXPackage(packagePath: string): Promise<{ manifest: Manifest; xmlManifest: XMLManifest }> {
-	return new Promise<{ manifest: Manifest; xmlManifest: XMLManifest }>((c, e) => {
-		open(packagePath, (err, zipfile) => {
-			if (err) {
-				return e(err);
-			}
+export async function readZip(packagePath: string, filter: (name: string) => boolean): Promise<Map<string, Buffer>> {
+	const zipfile = await promisify<string, Options, ZipFile>(open)(packagePath, { lazyEntries: true });
 
-			let manifest: Manifest | undefined;
-			let xmlManifest: XMLManifest | undefined;
+	return await new Promise((c, e) => {
+		const result = new Map<string, Buffer>();
 
-			zipfile.once('close', () => {
-				if (!manifest) {
-					e(new Error('Manifest not found'));
-				} else if (!xmlManifest) {
-					e(new Error('VSIX manifest not found'));
-				} else {
-					c({ manifest, xmlManifest });
-				}
-			});
+		zipfile.once('close', () => c(result));
 
-			zipfile.on('entry', (entry: Entry) => {
-				switch (entry.fileName.toLowerCase()) {
-					case 'extension/package.json': {
-						return readEntryString(zipfile, entry, (err, result) => {
-							if (err) {
-								zipfile.close();
-								return e(err);
-							}
+		zipfile.readEntry();
+		zipfile.on('entry', (entry: Entry) => {
+			const name = entry.fileName.toLowerCase();
 
-							manifest = JSON.parse(result);
-						});
+			if (filter(name)) {
+				zipfile.openReadStream(entry, (err, stream) => {
+					if (err) {
+						zipfile.close();
+						return e(err);
 					}
-					case 'extension.vsixmanifest': {
-						return readEntryString(zipfile, entry, (err, result) => {
-							if (err) {
-								zipfile.close();
-								return e(err);
-							}
 
-							parseXmlManifest(result).then(r => (xmlManifest = r));
-						});
-					}
-				}
-			});
+					bufferStream(stream).then(buffer => {
+						result.set(name, buffer);
+						zipfile.readEntry();
+					});
+				});
+			} else {
+				zipfile.readEntry();
+			}
 		});
 	});
 }
+
+export async function readVSIXPackage(packagePath: string): Promise<{ manifest: Manifest; xmlManifest: XMLManifest }> {
+	const map = await readZip(packagePath, name => /^extension\/package\.json$|^extension\.vsixmanifest$/i.test(name));
+	const rawManifest = map.get('extension/package.json');
+
+	if (!rawManifest) {
+		throw new Error('Manifest not found');
+	}
+
+	const rawXmlManifest = map.get('extension.vsixmanifest');
+
+	if (!rawXmlManifest) {
+		throw new Error('VSIX manifest not found');
+	}
+
+	return {
+		manifest: JSON.parse(rawManifest.toString('utf8')),
+		xmlManifest: await parseXmlManifest(rawXmlManifest.toString('utf8')),
+	};
+}