@push.rocks/smartarchive 4.2.4 → 5.0.0

package/ts/bzip2/index.ts

@@ -1,51 +1,53 @@
 import * as plugins from '../plugins.js';
+import { Bzip2Error, BZIP2_ERROR_CODES } from '../errors.js';
+import type { IBitReader } from '../interfaces.js';
 
 import { Bzip2 } from './bzip2.js';
 import { bitIterator } from './bititerator.js';
 
-export function unbzip2Stream() {
+/**
+ * Creates a streaming BZIP2 decompression transform
+ */
+export function unbzip2Stream(): plugins.smartstream.SmartDuplex<Buffer, Buffer> {
   const bzip2Instance = new Bzip2();
-  var bufferQueue = [];
-  var hasBytes = 0;
-  var blockSize = 0;
-  var broken = false;
-  var done = false;
-  var bitReader = null;
-  var streamCRC = null;
+  const bufferQueue: Buffer[] = [];
+  let hasBytes = 0;
+  let blockSize = 0;
+  let broken = false;
+  let bitReader: IBitReader | null = null;
+  let streamCRC: number | null = null;
 
-  function decompressBlock() {
+  function decompressBlock(): Buffer | undefined {
     if (!blockSize) {
-      blockSize = bzip2Instance.header(bitReader);
+      blockSize = bzip2Instance.header(bitReader!);
       streamCRC = 0;
-    } else {
-      var bufsize = 100000 * blockSize;
-      var buf = new Int32Array(bufsize);
+      return undefined;
+    }
 
-      var chunk = [];
-      var f = function (b) {
-        chunk.push(b);
-      };
+    const bufsize = 100000 * blockSize;
+    const buf = new Int32Array(bufsize);
+    const chunk: number[] = [];
 
-      streamCRC = bzip2Instance.decompress(
-        bitReader,
-        f,
-        buf,
-        bufsize,
-        streamCRC,
-      );
-      if (streamCRC === null) {
-        // reset for next bzip2 header
-        blockSize = 0;
-        return;
-      } else {
-        return Buffer.from(chunk);
-      }
+    const outputFunc = (b: number): void => {
+      chunk.push(b);
+    };
+
+    streamCRC = bzip2Instance.decompress(bitReader!, outputFunc, buf, bufsize, streamCRC);
+
+    if (streamCRC === null) {
+      // Reset for next bzip2 header
+      blockSize = 0;
+      return undefined;
     }
+
+    return Buffer.from(chunk);
   }
 
-  var outlength = 0;
-  const decompressAndPush = async () => {
-    if (broken) return;
+  let outlength = 0;
+
+  const decompressAndPush = async (): Promise<Buffer | undefined> => {
+    if (broken) return undefined;
+
     try {
       const resultChunk = decompressBlock();
       if (resultChunk) {
@@ -53,40 +55,39 @@ export function unbzip2Stream() {
       }
       return resultChunk;
     } catch (e) {
-      console.error(e);
       broken = true;
+      if (e instanceof Error) {
+        throw new Bzip2Error(`Decompression failed: ${e.message}`, BZIP2_ERROR_CODES.INVALID_BLOCK_DATA);
+      }
+      throw e;
     }
   };
-  let counter = 0;
-  return new plugins.smartstream.SmartDuplex({
+
+  return new plugins.smartstream.SmartDuplex<Buffer, Buffer>({
     objectMode: true,
     name: 'bzip2',
-    debug: false,
     highWaterMark: 1,
     writeFunction: async function (data, streamTools) {
-      // console.log(`got chunk ${counter++}`)
       bufferQueue.push(data);
       hasBytes += data.length;
+
       if (bitReader === null) {
         bitReader = bitIterator(function () {
-          return bufferQueue.shift();
+          return bufferQueue.shift()!;
         });
       }
-      while (
-        !broken &&
-        hasBytes - bitReader.bytesRead + 1 >= (25000 + 100000 * blockSize || 4)
-      ) {
-        //console.error('decompressing with', hasBytes - bitReader.bytesRead + 1, 'bytes in buffer');
+
+      const threshold = 25000 + 100000 * blockSize || 4;
+      while (!broken && hasBytes - bitReader.bytesRead + 1 >= threshold) {
         const result = await decompressAndPush();
         if (!result) {
           continue;
         }
-        // console.log(result.toString());
         await streamTools.push(result);
       }
+      return null;
     },
     finalFunction: async function (streamTools) {
-      //console.error(x,'last compressing with', hasBytes, 'bytes in buffer');
       while (!broken && bitReader && hasBytes > bitReader.bytesRead) {
         const result = await decompressAndPush();
         if (!result) {
@@ -94,10 +95,11 @@ export function unbzip2Stream() {
         }
         await streamTools.push(result);
       }
-      if (!broken) {
-        if (streamCRC !== null)
-          this.emit('error', new Error('input stream ended prematurely'));
+
+      if (!broken && streamCRC !== null) {
+        this.emit('error', new Bzip2Error('Input stream ended prematurely', BZIP2_ERROR_CODES.PREMATURE_END));
       }
+      return null;
     },
   });
 }

package/ts/classes.archiveanalyzer.ts

@@ -1,24 +1,41 @@
 import type { SmartArchive } from './classes.smartarchive.js';
+import type { TSupportedMime } from './interfaces.js';
 import * as plugins from './plugins.js';
 
+/**
+ * Type for decompression streams
+ */
+export type TDecompressionStream =
+  | plugins.stream.Transform
+  | plugins.stream.Duplex
+  | plugins.tarStream.Extract;
+
+/**
+ * Result of archive analysis
+ */
 export interface IAnalyzedResult {
-  fileType: plugins.fileType.FileTypeResult;
+  fileType: plugins.fileType.FileTypeResult | undefined;
   isArchive: boolean;
-  resultStream: plugins.smartstream.SmartDuplex;
-  decompressionStream:
-    | plugins.stream.Transform
-    | plugins.stream.Duplex
-    | plugins.tarStream.Extract;
+  resultStream: plugins.smartstream.SmartDuplex<Buffer, Buffer>;
+  decompressionStream: TDecompressionStream;
 }
 
+/**
+ * Analyzes archive streams to detect format and provide decompression
+ */
 export class ArchiveAnalyzer {
-  smartArchiveRef: SmartArchive;
+  private smartArchiveRef: SmartArchive;
 
   constructor(smartArchiveRefArg: SmartArchive) {
     this.smartArchiveRef = smartArchiveRefArg;
   }
 
-  private async mimeTypeIsArchive(mimeType: string): Promise<boolean> {
+  /**
+   * Check if a MIME type represents an archive format
+   */
+  private async mimeTypeIsArchive(mimeType: string | undefined): Promise<boolean> {
+    if (!mimeType) return false;
+
     const archiveMimeTypes: Set<string> = new Set([
       'application/zip',
       'application/x-rar-compressed',
@@ -26,50 +43,46 @@ export class ArchiveAnalyzer {
       'application/gzip',
       'application/x-7z-compressed',
       'application/x-bzip2',
-      // Add other archive mime types here
     ]);
 
     return archiveMimeTypes.has(mimeType);
   }
 
-  private async getDecompressionStream(
-    mimeTypeArg: plugins.fileType.FileTypeResult['mime'],
-  ): Promise<
-    plugins.stream.Transform | plugins.stream.Duplex | plugins.tarStream.Extract
-  > {
+  /**
+   * Get the appropriate decompression stream for a MIME type
+   */
+  private async getDecompressionStream(mimeTypeArg: TSupportedMime): Promise<TDecompressionStream> {
     switch (mimeTypeArg) {
       case 'application/gzip':
         return this.smartArchiveRef.gzipTools.getDecompressionStream();
       case 'application/zip':
         return this.smartArchiveRef.zipTools.getDecompressionStream();
       case 'application/x-bzip2':
-        return await this.smartArchiveRef.bzip2Tools.getDecompressionStream(); // replace with your own bzip2 decompression stream
+        return this.smartArchiveRef.bzip2Tools.getDecompressionStream();
       case 'application/x-tar':
-        return this.smartArchiveRef.tarTools.getDecompressionStream(); // replace with your own tar decompression stream
+        return this.smartArchiveRef.tarTools.getDecompressionStream();
       default:
         // Handle unsupported formats or no decompression needed
         return plugins.smartstream.createPassThrough();
     }
   }
 
-  public getAnalyzedStream() {
+  /**
+   * Create an analyzed stream that detects archive type and provides decompression
+   * Emits a single IAnalyzedResult object
+   */
+  public getAnalyzedStream(): plugins.smartstream.SmartDuplex<Buffer, IAnalyzedResult> {
     let firstRun = true;
     const resultStream = plugins.smartstream.createPassThrough();
-    const analyzerstream = new plugins.smartstream.SmartDuplex<
-      Buffer,
-      IAnalyzedResult
-    >({
+
+    const analyzerstream = new plugins.smartstream.SmartDuplex<Buffer, IAnalyzedResult>({
       readableObjectMode: true,
       writeFunction: async (chunkArg: Buffer, streamtools) => {
         if (firstRun) {
           firstRun = false;
           const fileType = await plugins.fileType.fileTypeFromBuffer(chunkArg);
-          const decompressionStream = await this.getDecompressionStream(
-            fileType?.mime as any,
-          );
-          /**
-           * analyzed stream emits once with this object
-           */
+          const decompressionStream = await this.getDecompressionStream(fileType?.mime as TSupportedMime);
+
           const result: IAnalyzedResult = {
             fileType,
             isArchive: await this.mimeTypeIsArchive(fileType?.mime),
@@ -81,11 +94,12 @@ export class ArchiveAnalyzer {
         await resultStream.backpressuredPush(chunkArg);
         return null;
       },
-      finalFunction: async (tools) => {
+      finalFunction: async () => {
         resultStream.push(null);
         return null;
       },
     });
+
     return analyzerstream;
   }
 }

package/ts/classes.gziptools.ts

@@ -1,42 +1,60 @@
-import type { SmartArchive } from './classes.smartarchive.js';
 import * as plugins from './plugins.js';
+import type { TCompressionLevel } from './interfaces.js';
 
-// This class wraps fflate's gunzip in a Node.js Transform stream
-export class CompressGunzipTransform extends plugins.stream.Transform {
-  constructor() {
+/**
+ * Transform stream for GZIP compression using fflate
+ */
+export class GzipCompressionTransform extends plugins.stream.Transform {
+  private gzip: plugins.fflate.Gzip;
+
+  constructor(level: TCompressionLevel = 6) {
     super();
+
+    // Create a streaming Gzip compressor
+    this.gzip = new plugins.fflate.Gzip({ level }, (chunk, final) => {
+      this.push(Buffer.from(chunk));
+      if (final) {
+        this.push(null);
+      }
+    });
   }
 
   _transform(
     chunk: Buffer,
     encoding: BufferEncoding,
-    callback: plugins.stream.TransformCallback,
-  ) {
-    plugins.fflate.gunzip(chunk, (err, decompressed) => {
-      if (err) {
-        callback(err);
-      } else {
-        this.push(decompressed);
-        callback();
-      }
-    });
+    callback: plugins.stream.TransformCallback
+  ): void {
+    try {
+      this.gzip.push(chunk, false);
+      callback();
+    } catch (err) {
+      callback(err as Error);
+    }
+  }
+
+  _flush(callback: plugins.stream.TransformCallback): void {
+    try {
+      this.gzip.push(new Uint8Array(0), true);
+      callback();
+    } catch (err) {
+      callback(err as Error);
+    }
   }
 }
 
-// DecompressGunzipTransform class that extends the Node.js Transform stream to
-// create a stream that decompresses GZip-compressed data using fflate's gunzip function
-export class DecompressGunzipTransform extends plugins.stream.Transform {
-  private gunzip: any; // fflate.Gunzip instance
-  
+/**
+ * Transform stream for GZIP decompression using fflate
+ */
+export class GzipDecompressionTransform extends plugins.stream.Transform {
+  private gunzip: plugins.fflate.Gunzip;
+
   constructor() {
     super();
-    
+
     // Create a streaming Gunzip decompressor
     this.gunzip = new plugins.fflate.Gunzip((chunk, final) => {
-      // Push decompressed chunks to the output stream
       this.push(Buffer.from(chunk));
       if (final) {
-        // Signal end of stream when decompression is complete
         this.push(null);
       }
     });
@@ -45,20 +63,18 @@ export class DecompressGunzipTransform extends plugins.stream.Transform {
   _transform(
     chunk: Buffer,
     encoding: BufferEncoding,
-    callback: plugins.stream.TransformCallback,
-  ) {
+    callback: plugins.stream.TransformCallback
+  ): void {
     try {
-      // Feed chunks to the gunzip stream
       this.gunzip.push(chunk, false);
       callback();
     } catch (err) {
       callback(err as Error);
     }
   }
-  
-  _flush(callback: plugins.stream.TransformCallback) {
+
+  _flush(callback: plugins.stream.TransformCallback): void {
     try {
-      // Signal end of input to gunzip
       this.gunzip.push(new Uint8Array(0), true);
       callback();
     } catch (err) {
@@ -67,14 +83,61 @@ export class DecompressGunzipTransform extends plugins.stream.Transform {
   }
 }
 
+/**
+ * GZIP compression and decompression utilities
+ */
 export class GzipTools {
-  constructor() {}
+  /**
+   * Get a streaming compression transform
+   */
+  public getCompressionStream(level?: TCompressionLevel): plugins.stream.Transform {
+    return new GzipCompressionTransform(level);
+  }
 
-  public getCompressionStream() {
-    return new CompressGunzipTransform();
+  /**
+   * Get a streaming decompression transform
+   */
+  public getDecompressionStream(): plugins.stream.Transform {
+    return new GzipDecompressionTransform();
   }
 
-  public getDecompressionStream() {
-    return new DecompressGunzipTransform();
+  /**
+   * Compress data synchronously
+   */
+  public compressSync(data: Buffer, level?: TCompressionLevel): Buffer {
+    const options = level !== undefined ? { level } : undefined;
+    return Buffer.from(plugins.fflate.gzipSync(data, options));
+  }
+
+  /**
+   * Decompress data synchronously
+   */
+  public decompressSync(data: Buffer): Buffer {
+    return Buffer.from(plugins.fflate.gunzipSync(data));
+  }
+
+  /**
+   * Compress data asynchronously
+   */
+  public async compress(data: Buffer, level?: TCompressionLevel): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      const options = level !== undefined ? { level } : undefined;
+      plugins.fflate.gzip(data, options as plugins.fflate.AsyncGzipOptions, (err, result) => {
+        if (err) reject(err);
+        else resolve(Buffer.from(result));
+      });
+    });
+  }
+
+  /**
+   * Decompress data asynchronously
+   */
+  public async decompress(data: Buffer): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      plugins.fflate.gunzip(data, (err, result) => {
+        if (err) reject(err);
+        else resolve(Buffer.from(result));
+      });
+    });
   }
 }