279 lines
8.9 KiB
TypeScript
279 lines
8.9 KiB
TypeScript
// Based on https://github.com/jimmywarting/StreamSaver.js/blob/master/examples/zip-stream.js
|
|
|
|
/* global ReadableStream */
|
|
|
|
type TypedArray =
|
|
| Int8Array
|
|
| Uint8Array
|
|
| Int16Array
|
|
| Uint16Array
|
|
| Int32Array
|
|
| Uint32Array
|
|
| Uint8ClampedArray
|
|
| Float32Array
|
|
| Float64Array;
|
|
|
|
/**
|
|
* 32-bit cyclic redundancy check, or CRC-32 - checksum
|
|
*/
|
|
class Crc32 {
|
|
crc: number;
|
|
table: any;
|
|
constructor() {
|
|
this.crc = -1;
|
|
this.table = (() => {
|
|
let i;
|
|
let j;
|
|
let t;
|
|
const table = [];
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
t = i;
|
|
for (j = 0; j < 8; j++) {
|
|
t = (t & 1)
|
|
? (t >>> 1) ^ 0xEDB88320
|
|
: t >>> 1;
|
|
}
|
|
table[i] = t;
|
|
}
|
|
return table;
|
|
})();
|
|
}
|
|
|
|
append(data: TypedArray) {
|
|
let crc = this.crc | 0;
|
|
const table = this.table;
|
|
for (let offset = 0, len = data.length | 0; offset < len; offset++) {
|
|
crc = (crc >>> 8) ^ table[(crc ^ data[offset]) & 0xFF];
|
|
}
|
|
this.crc = crc;
|
|
}
|
|
|
|
get() {
|
|
return ~this.crc;
|
|
}
|
|
}
|
|
|
|
type DataHelper = {
|
|
array: Uint8Array,
|
|
view: DataView,
|
|
};
|
|
|
|
const getDataHelper = (byteLength: number): DataHelper => {
|
|
const uint8 = new Uint8Array(byteLength);
|
|
return {
|
|
array: uint8,
|
|
view: new DataView(uint8.buffer),
|
|
};
|
|
};
|
|
|
|
type FileLike = File & {
|
|
directory: string,
|
|
comment: string,
|
|
stream(): ReadableStream,
|
|
};
|
|
|
|
type ZipObj = {
|
|
crc?: Crc32,
|
|
uncompressedLength: number,
|
|
compressedLength: number,
|
|
ctrl: ReadableStreamDefaultController,
|
|
writeFooter: Function,
|
|
writeHeader: Function,
|
|
reader?: ReadableStreamDefaultReader,
|
|
offset: number
|
|
header?: DataHelper,
|
|
fileLike: FileLike,
|
|
level: number,
|
|
directory: boolean,
|
|
};
|
|
|
|
const pump = (zipObj: ZipObj) => zipObj.reader ? zipObj.reader.read().then(chunk => {
|
|
if (zipObj.crc) {
|
|
if (chunk.done) return zipObj.writeFooter();
|
|
const outputData = chunk.value;
|
|
zipObj.crc.append(outputData);
|
|
zipObj.uncompressedLength += outputData.length;
|
|
zipObj.compressedLength += outputData.length;
|
|
zipObj.ctrl.enqueue(outputData);
|
|
} else {
|
|
throw new Error('Missing zipObj.crc');
|
|
}
|
|
}) : undefined;
|
|
|
|
export default function streamToZIP(underlyingSource: UnderlyingSource) {
|
|
const files = Object.create(null);
|
|
const filenames: string[] = [];
|
|
const encoder = new TextEncoder();
|
|
let offset = 0;
|
|
let activeZipIndex = 0;
|
|
let ctrl: ReadableStreamDefaultController;
|
|
let activeZipObject: ZipObj;
|
|
let closed: boolean;
|
|
|
|
function next() {
|
|
activeZipIndex++;
|
|
activeZipObject = files[filenames[activeZipIndex]];
|
|
if (activeZipObject) processNextChunk();
|
|
else if (closed) closeZip();
|
|
}
|
|
|
|
const zipWriter: ReadableStreamDefaultController = {
|
|
desiredSize: null,
|
|
|
|
error(err) {
|
|
console.error(err);
|
|
},
|
|
|
|
enqueue(fileLike: FileLike) {
|
|
if (closed) {
|
|
throw new TypeError(
|
|
"Cannot enqueue a chunk into a readable stream that is closed or has been requested to be closed",
|
|
);
|
|
}
|
|
|
|
let name = fileLike.name.trim();
|
|
const date = new Date(typeof fileLike.lastModified === 'undefined' ? Date.now() : fileLike.lastModified);
|
|
|
|
if (fileLike.directory && !name.endsWith('/')) name += '/';
|
|
// if file already exists, do not enqueue
|
|
if (files[name]) return;
|
|
|
|
const nameBuf = encoder.encode(name);
|
|
filenames.push(name);
|
|
|
|
const zipObject: ZipObj = files[name] = {
|
|
level: 0,
|
|
ctrl,
|
|
directory: !!fileLike.directory,
|
|
nameBuf,
|
|
comment: encoder.encode(fileLike.comment || ''),
|
|
compressedLength: 0,
|
|
uncompressedLength: 0,
|
|
offset,
|
|
|
|
writeHeader() {
|
|
const header = getDataHelper(26);
|
|
const data = getDataHelper(30 + nameBuf.length);
|
|
|
|
zipObject.offset = offset;
|
|
zipObject.header = header;
|
|
|
|
if (zipObject.level !== 0 && !zipObject.directory) {
|
|
header.view.setUint16(4, 0x0800);
|
|
}
|
|
|
|
header.view.setUint32(0, 0x14000808);
|
|
header.view.setUint16(
|
|
6,
|
|
(((date.getHours() << 6) | date.getMinutes()) << 5) | (date.getSeconds() / 2),
|
|
true,
|
|
);
|
|
header.view.setUint16(
|
|
8,
|
|
((((date.getFullYear() - 1980) << 4) | (date.getMonth() + 1)) << 5) |
|
|
date.getDate(),
|
|
true,
|
|
);
|
|
header.view.setUint16(22, nameBuf.length, true);
|
|
data.view.setUint32(0, 0x504b0304);
|
|
data.array.set(header.array, 4);
|
|
data.array.set(nameBuf, 30);
|
|
offset += data.array.length;
|
|
ctrl.enqueue(data.array);
|
|
},
|
|
|
|
writeFooter() {
|
|
const footer = getDataHelper(16);
|
|
footer.view.setUint32(0, 0x504b0708);
|
|
|
|
if (zipObject.crc && zipObject.header) {
|
|
zipObject.header.view.setUint32(10, zipObject.crc.get(), true);
|
|
zipObject.header.view.setUint32(14, zipObject.compressedLength, true);
|
|
zipObject.header.view.setUint32(18, zipObject.uncompressedLength, true);
|
|
footer.view.setUint32(4, zipObject.crc.get(), true);
|
|
footer.view.setUint32(8, zipObject.compressedLength, true);
|
|
footer.view.setUint32(12, zipObject.uncompressedLength, true);
|
|
}
|
|
|
|
ctrl.enqueue(footer.array);
|
|
offset += zipObject.compressedLength + 16;
|
|
next();
|
|
},
|
|
fileLike,
|
|
};
|
|
|
|
if (!activeZipObject) {
|
|
activeZipObject = zipObject;
|
|
processNextChunk();
|
|
}
|
|
},
|
|
|
|
close() {
|
|
if (closed) {
|
|
throw new TypeError(
|
|
"Cannot close a readable stream that has already been requested to be closed",
|
|
);
|
|
}
|
|
if (!activeZipObject) closeZip();
|
|
closed = true;
|
|
},
|
|
};
|
|
|
|
function closeZip() {
|
|
let length = 0;
|
|
let index = 0;
|
|
let indexFilename;
|
|
let file;
|
|
|
|
for (indexFilename = 0; indexFilename < filenames.length; indexFilename++) {
|
|
file = files[filenames[indexFilename]];
|
|
length += 46 + file.nameBuf.length + file.comment.length;
|
|
}
|
|
const data = getDataHelper(length + 22);
|
|
for (indexFilename = 0; indexFilename < filenames.length; indexFilename++) {
|
|
file = files[filenames[indexFilename]];
|
|
data.view.setUint32(index, 0x504b0102);
|
|
data.view.setUint16(index + 4, 0x1400);
|
|
data.array.set(file.header.array, index + 6);
|
|
data.view.setUint16(index + 32, file.comment.length, true);
|
|
if (file.directory) {
|
|
data.view.setUint8(index + 38, 0x10);
|
|
}
|
|
data.view.setUint32(index + 42, file.offset, true);
|
|
data.array.set(file.nameBuf, index + 46);
|
|
data.array.set(file.comment, index + 46 + file.nameBuf.length);
|
|
index += 46 + file.nameBuf.length + file.comment.length;
|
|
}
|
|
data.view.setUint32(index, 0x504b0506);
|
|
data.view.setUint16(index + 8, filenames.length, true);
|
|
data.view.setUint16(index + 10, filenames.length, true);
|
|
data.view.setUint32(index + 12, length, true);
|
|
data.view.setUint32(index + 16, offset, true);
|
|
ctrl.enqueue(data.array);
|
|
ctrl.close();
|
|
}
|
|
|
|
function processNextChunk() {
|
|
if (!activeZipObject) return;
|
|
if (activeZipObject.reader) return pump(activeZipObject);
|
|
if (activeZipObject.fileLike.stream) {
|
|
activeZipObject.crc = new Crc32();
|
|
activeZipObject.reader = activeZipObject.fileLike.stream().getReader();
|
|
activeZipObject.writeHeader();
|
|
} else next();
|
|
}
|
|
|
|
return new ReadableStream({
|
|
start: c => {
|
|
ctrl = c;
|
|
underlyingSource.start && Promise.resolve(underlyingSource.start(zipWriter));
|
|
},
|
|
pull() {
|
|
return processNextChunk() || (
|
|
underlyingSource.pull &&
|
|
Promise.resolve(underlyingSource.pull(zipWriter))
|
|
);
|
|
},
|
|
});
|
|
}
|