@push.rocks/smartarchive 5.0.1 → 5.2.0

package/ts/classes.gziptools.ts

@@ -1,138 +0,0 @@
-import * as plugins from './plugins.js';
-import type { TCompressionLevel } from './interfaces.js';
-
-/**
- * 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
-  ): 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);
-    }
-  }
-}
-
-/**
- * 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) => {
-      this.push(Buffer.from(chunk));
-      if (final) {
-        this.push(null);
-      }
-    });
-  }
-
-  _transform(
-    chunk: Buffer,
-    encoding: BufferEncoding,
-    callback: plugins.stream.TransformCallback
-  ): void {
-    try {
-      this.gunzip.push(chunk, false);
-      callback();
-    } catch (err) {
-      callback(err as Error);
-    }
-  }
-
-  _flush(callback: plugins.stream.TransformCallback): void {
-    try {
-      this.gunzip.push(new Uint8Array(0), true);
-      callback();
-    } catch (err) {
-      callback(err as Error);
-    }
-  }
-}
-
-/**
- * GZIP compression and decompression utilities
- */
-export class GzipTools {
-  /**
-   * Get a streaming compression transform
-   */
-  public getCompressionStream(level?: TCompressionLevel): plugins.stream.Transform {
-    return new GzipCompressionTransform(level);
-  }
-
-  /**
-   * Get a streaming decompression transform
-   */
-  public getDecompressionStream(): plugins.stream.Transform {
-    return new GzipDecompressionTransform();
-  }
-
-  /**
-   * 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
-   * Note: Uses sync version for Deno compatibility (fflate async uses Web Workers
-   * which have issues in Deno)
-   */
-  public async compress(data: Buffer, level?: TCompressionLevel): Promise<Buffer> {
-    // Use sync version wrapped in Promise for cross-runtime compatibility
-    return this.compressSync(data, level);
-  }
-
-  /**
-   * Decompress data asynchronously
-   * Note: Uses sync version for Deno compatibility (fflate async uses Web Workers
-   * which have issues in Deno)
-   */
-  public async decompress(data: Buffer): Promise<Buffer> {
-    // Use sync version wrapped in Promise for cross-runtime compatibility
-    return this.decompressSync(data);
-  }
-}

package/ts/classes.ziptools.ts

@@ -1,196 +0,0 @@
-import * as plugins from './plugins.js';
-import type { IArchiveEntry, TCompressionLevel } from './interfaces.js';
-
-/**
- * Transform stream for ZIP decompression using fflate
- * Emits StreamFile objects for each file in the archive
- */
-export class ZipDecompressionTransform extends plugins.smartstream.SmartDuplex<Buffer, plugins.smartfile.StreamFile> {
-  private streamtools!: plugins.smartstream.IStreamTools;
-  private unzipper = new plugins.fflate.Unzip(async (fileArg) => {
-    let resultBuffer: Buffer;
-    fileArg.ondata = async (_flateError, dat, final) => {
-      resultBuffer
-        ? (resultBuffer = Buffer.concat([resultBuffer, Buffer.from(dat)]))
-        : (resultBuffer = Buffer.from(dat));
-      if (final) {
-        const streamFile = plugins.smartfile.StreamFile.fromBuffer(resultBuffer);
-        streamFile.relativeFilePath = fileArg.name;
-        this.streamtools.push(streamFile);
-      }
-    };
-    fileArg.start();
-  });
-
-  constructor() {
-    super({
-      objectMode: true,
-      writeFunction: async (chunkArg, streamtoolsArg) => {
-        this.streamtools ? null : (this.streamtools = streamtoolsArg);
-        this.unzipper.push(
-          Buffer.isBuffer(chunkArg) ? chunkArg : Buffer.from(chunkArg as unknown as ArrayBuffer),
-          false
-        );
-        return null;
-      },
-      finalFunction: async () => {
-        this.unzipper.push(Buffer.from(''), true);
-        await plugins.smartdelay.delayFor(0);
-        await this.streamtools.push(null);
-        return null;
-      },
-    });
-    this.unzipper.register(plugins.fflate.UnzipInflate);
-  }
-}
-
-/**
- * Streaming ZIP compression using fflate
- * Allows adding multiple entries before finalizing
- */
-export class ZipCompressionStream extends plugins.stream.Duplex {
-  private files: Map<string, { data: Uint8Array; options?: plugins.fflate.ZipOptions }> = new Map();
-  private finalized = false;
-
-  constructor() {
-    super();
-  }
-
-  /**
-   * Add a file entry to the ZIP archive
-   */
-  public async addEntry(
-    fileName: string,
-    content: Buffer | plugins.stream.Readable,
-    options?: { compressionLevel?: TCompressionLevel }
-  ): Promise<void> {
-    if (this.finalized) {
-      throw new Error('Cannot add entries to a finalized ZIP archive');
-    }
-
-    let data: Buffer;
-    if (Buffer.isBuffer(content)) {
-      data = content;
-    } else {
-      // Collect stream to buffer
-      const chunks: Buffer[] = [];
-      for await (const chunk of content) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-      }
-      data = Buffer.concat(chunks);
-    }
-
-    this.files.set(fileName, {
-      data: new Uint8Array(data),
-      options: options?.compressionLevel !== undefined ? { level: options.compressionLevel } : undefined,
-    });
-  }
-
-  /**
-   * Finalize the ZIP archive and emit the compressed data
-   */
-  public async finalize(): Promise<void> {
-    if (this.finalized) {
-      return;
-    }
-    this.finalized = true;
-
-    const filesObj: plugins.fflate.Zippable = {};
-    for (const [name, { data, options }] of this.files) {
-      filesObj[name] = options ? [data, options] : data;
-    }
-
-    // Use sync version for Deno compatibility (fflate async uses Web Workers)
-    try {
-      const result = plugins.fflate.zipSync(filesObj);
-      this.push(Buffer.from(result));
-      this.push(null);
-    } catch (err) {
-      throw err;
-    }
-  }
-
-  _read(): void {
-    // No-op: data is pushed when finalize() is called
-  }
-
-  _write(
-    _chunk: Buffer,
-    _encoding: BufferEncoding,
-    callback: (error?: Error | null) => void
-  ): void {
-    // Not used for ZIP creation - use addEntry() instead
-    callback(new Error('Use addEntry() to add files to the ZIP archive'));
-  }
-}
-
-/**
- * ZIP compression and decompression utilities
- */
-export class ZipTools {
-  /**
-   * Get a streaming compression object for creating ZIP archives
-   */
-  public getCompressionStream(): ZipCompressionStream {
-    return new ZipCompressionStream();
-  }
-
-  /**
-   * Get a streaming decompression transform for extracting ZIP archives
-   */
-  public getDecompressionStream(): ZipDecompressionTransform {
-    return new ZipDecompressionTransform();
-  }
-
-  /**
-   * Create a ZIP archive from an array of entries
-   */
-  public async createZip(entries: IArchiveEntry[], compressionLevel?: TCompressionLevel): Promise<Buffer> {
-    const filesObj: plugins.fflate.Zippable = {};
-
-    for (const entry of entries) {
-      let data: Uint8Array;
-
-      if (typeof entry.content === 'string') {
-        data = new TextEncoder().encode(entry.content);
-      } else if (Buffer.isBuffer(entry.content)) {
-        data = new Uint8Array(entry.content);
-      } else if (entry.content instanceof plugins.smartfile.SmartFile) {
-        data = new Uint8Array(entry.content.contents);
-      } else if (entry.content instanceof plugins.smartfile.StreamFile) {
-        const buffer = await entry.content.getContentAsBuffer();
-        data = new Uint8Array(buffer);
-      } else {
-        // Readable stream
-        const chunks: Buffer[] = [];
-        for await (const chunk of entry.content as plugins.stream.Readable) {
-          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-        }
-        data = new Uint8Array(Buffer.concat(chunks));
-      }
-
-      if (compressionLevel !== undefined) {
-        filesObj[entry.archivePath] = [data, { level: compressionLevel }];
-      } else {
-        filesObj[entry.archivePath] = data;
-      }
-    }
-
-    // Use sync version for Deno compatibility (fflate async uses Web Workers)
-    const result = plugins.fflate.zipSync(filesObj);
-    return Buffer.from(result);
-  }
-
-  /**
-   * Extract a ZIP buffer to an array of entries
-   */
-  public async extractZip(data: Buffer): Promise<Array<{ path: string; content: Buffer }>> {
-    // Use sync version for Deno compatibility (fflate async uses Web Workers)
-    const result = plugins.fflate.unzipSync(data);
-    const entries: Array<{ path: string; content: Buffer }> = [];
-    for (const [path, content] of Object.entries(result)) {
-      entries.push({ path, content: Buffer.from(content) });
-    }
-    return entries;
-  }
-}