Update TS types

Author: codedread

tests/archive-compress.spec.js

@@ -22,19 +22,17 @@ describe('bitjs.archive.compress', () => {
   let inputFileInfos = new Map();
   let decompressedFileSize = 0;
 
-  before(() => {
-    for (const fileName of INPUT_FILENAMES) {
-      const fullFilename = `${PATH}${fileName}`;
-      const fd = fs.openSync(fullFilename, 'r');
-      const lastModTime = fs.fstatSync(fd).mtimeMs;
-      const nodeBuf = fs.readFileSync(fullFilename);
-      const fileData = new Uint8Array(
-          nodeBuf.buffer.slice(nodeBuf.byteOffset, nodeBuf.byteOffset + nodeBuf.length));
-      inputFileInfos.set(fileName, {fileName, lastModTime, fileData});
-      decompressedFileSize += fileData.byteLength;
-      fs.closeSync(fd);
-    }
-  });
+  for (const fileName of INPUT_FILENAMES) {
+    const fullFilename = `${PATH}${fileName}`;
+    const fd = fs.openSync(fullFilename, 'r');
+    const lastModTime = fs.fstatSync(fd).mtimeMs;
+    const nodeBuf = fs.readFileSync(fullFilename);
+    const fileData = new Uint8Array(
+        nodeBuf.buffer.slice(nodeBuf.byteOffset, nodeBuf.byteOffset + nodeBuf.length));
+    inputFileInfos.set(fileName, {fileName, lastModTime, fileData});
+    decompressedFileSize += fileData.byteLength;
+    fs.closeSync(fd);
+  }
 
   it('zipper throws for invalid compression method', async () => {
     expect(() => new Zipper({zipCompressionMethod: 42})).throws();

tests/archive-decompress.spec.js

@@ -29,13 +29,11 @@ describe('bitjs.archive.decompress', () => {
   /** @type {Map<string, ArrayBuffer>} */
   let inputArrayBuffers = new Map();
 
-  before(() => {
-    for (const inputFile of INPUT_FILES) {
-      const nodeBuf = fs.readFileSync(`${PATH}${inputFile}`);
-      const ab = nodeBuf.buffer.slice(nodeBuf.byteOffset, nodeBuf.byteOffset + nodeBuf.length);
-      inputArrayBuffers.set(inputFile, ab);
-    }
-  });
+  for (const inputFile of INPUT_FILES) {
+    const nodeBuf = fs.readFileSync(`${PATH}${inputFile}`);
+    const ab = nodeBuf.buffer.slice(nodeBuf.byteOffset, nodeBuf.byteOffset + nodeBuf.length);
+    inputArrayBuffers.set(inputFile, ab);
+  }
 
   for (const outFile of ARCHIVE_FILES) {
     it(outFile, async () => {
@@ -71,7 +69,7 @@ describe('bitjs.archive.decompress', () => {
   }
 
   describe('gunzip', () => {
-    it('can unzip a file', async () => {
+    it('can gunzip a file', async () => {
       const bufs = new Map(inputArrayBuffers);
       const nodeBuf = fs.readFileSync(`${PATH}sample-1-slowest.txt.gz`);
       const ab = nodeBuf.buffer.slice(nodeBuf.byteOffset, nodeBuf.byteOffset + nodeBuf.length);

types/archive/decompress.d.ts

@@ -155,6 +155,25 @@ export class Untarrer extends Unarchiver {
      */
     constructor(ab: ArrayBuffer, options?: UnarchiverOptions);
 }
+/**
+ * IMPORTANT NOTES for Gunzipper:
+ * 1) A Gunzipper will only ever emit one EXTRACT event, because a gzipped file only ever contains
+ *    a single file.
+ * 2) If the gzipped file does not include the original filename as a FNAME block, then the
+ *    UnarchivedFile in the UnarchiveExtractEvent will not include a filename. It will be up to the
+ *    client to re-assemble the filename (if needed).
+ * 3) update() is not supported on a Gunzipper, since the current implementation relies on runtime
+ *    support for DecompressionStream('gzip') which can throw hard-to-detect errors reading only
+ *    only part of a file.
+ * 4) PROGRESS events are not yet supported in Gunzipper.
+ */
+export class Gunzipper extends Unarchiver {
+    /**
+     * @param {ArrayBuffer} ab
+     * @param {UnarchiverOptions} options
+     */
+    constructor(ab: ArrayBuffer, options?: UnarchiverOptions);
+}
 export type UnarchivedFile = {
     filename: string;
     fileData: Uint8Array;

types/archive/decompress.d.ts.map

@@ -6,7 +6,7 @@
  *
  * Bit reading always proceeds from the first byte in the buffer, to the
  * second byte, and so on. The MTL flag controls which bit is considered
- * first *inside* the byte.
+ * first *inside* the byte. The default is least-to-most direction.
  *
  * An Example for how Most-To-Least vs Least-to-Most mode works:
  *

types/io/bitstream.d.ts

@@ -12,10 +12,16 @@ export class ByteBuffer {
      */
     public data: Uint8Array;
     /**
+     * Points to the byte that will next be written.
      * @type {number}
      * @public
      */
     public ptr: number;
+    /**
+     * Returns an exact copy of all the data that has been written to the ByteBuffer.
+     * @returns {Uint8Array}
+     */
+    getData(): Uint8Array;
     /**
      * @param {number} b The byte to insert.
      */

types/io/bytebuffer.d.ts

@@ -42,15 +42,15 @@ export class ByteStream {
      * @private
      */
     private littleEndian_;
-    /** @returns {boolean} Whether the stream is little-endian. */
+    /** @returns {boolean} Whether the stream is little-endian (least significant byte is first). */
     isLittleEndian(): boolean;
     /**
-     * Big-Endian is sometimes called Motorola-style.
+     * Big-Endian means the most significant byte is first. it is sometimes called Motorola-style.
      * @param {boolean=} val The value to set. If not present, the stream is set to big-endian.
      */
     setBigEndian(val?: boolean | undefined): void;
     /**
-     * Little-Endian is sometimes called Intel-style.
+     * Little-Endian means the least significant byte is ifrst. is sometimes called Intel-style.
      * @param {boolean=} val The value to set. If not present, the stream is set to little-endian.
      */
     setLittleEndian(val?: boolean | undefined): void;