@push.rocks/smartarchive 5.0.1 → 5.2.0

package/{ts → ts_shared}/bzip2/index.ts

@@ -8,16 +8,16 @@ import { bitIterator } from './bititerator.js';
 /**
  * Creates a streaming BZIP2 decompression transform
  */
-export function unbzip2Stream(): plugins.smartstream.SmartDuplex<Buffer, Buffer> {
+export function unbzip2Stream(): plugins.smartstream.SmartDuplex<Uint8Array, Uint8Array> {
   const bzip2Instance = new Bzip2();
-  const bufferQueue: Buffer[] = [];
+  const bufferQueue: Uint8Array[] = [];
   let hasBytes = 0;
   let blockSize = 0;
   let broken = false;
   let bitReader: IBitReader | null = null;
   let streamCRC: number | null = null;
 
-  function decompressBlock(): Buffer | undefined {
+  function decompressBlock(): Uint8Array | undefined {
     if (!blockSize) {
       blockSize = bzip2Instance.header(bitReader!);
       streamCRC = 0;
@@ -40,12 +40,12 @@ export function unbzip2Stream(): plugins.smartstream.SmartDuplex<Buffer, Buffer>
       return undefined;
     }
 
-    return Buffer.from(chunk);
+    return new Uint8Array(chunk);
   }
 
   let outlength = 0;
 
-  const decompressAndPush = async (): Promise<Buffer | undefined> => {
+  const decompressAndPush = async (): Promise<Uint8Array | undefined> => {
     if (broken) return undefined;
 
     try {
@@ -63,7 +63,7 @@ export function unbzip2Stream(): plugins.smartstream.SmartDuplex<Buffer, Buffer>
     }
   };
 
-  return new plugins.smartstream.SmartDuplex<Buffer, Buffer>({
+  return new plugins.smartstream.SmartDuplex<Uint8Array, Uint8Array>({
     objectMode: true,
     name: 'bzip2',
     highWaterMark: 1,

package/ts_shared/classes.bzip2tools.ts

@@ -0,0 +1,14 @@
+import * as plugins from './plugins.js';
+import { unbzip2Stream } from './bzip2/index.js';
+
+/**
+ * BZIP2 decompression utilities (browser-compatible)
+ */
+export class Bzip2Tools {
+  /**
+   * Get a streaming decompression transform
+   */
+  getDecompressionStream(): plugins.smartstream.SmartDuplex<Uint8Array, Uint8Array> {
+    return unbzip2Stream();
+  }
+}

package/ts_shared/classes.gziptools.ts

@@ -0,0 +1,42 @@
+import * as plugins from './plugins.js';
+import type { TCompressionLevel } from './interfaces.js';
+
+/**
+ * GZIP compression and decompression utilities (browser-compatible)
+ */
+export class GzipTools {
+  /**
+   * Compress data synchronously
+   */
+  public compressSync(data: Uint8Array, level?: TCompressionLevel): Uint8Array {
+    const options = level !== undefined ? { level } : undefined;
+    return plugins.fflate.gzipSync(data, options);
+  }
+
+  /**
+   * Decompress data synchronously
+   */
+  public decompressSync(data: Uint8Array): Uint8Array {
+    return 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: Uint8Array, level?: TCompressionLevel): Promise<Uint8Array> {
+    // 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: Uint8Array): Promise<Uint8Array> {
+    // Use sync version wrapped in Promise for cross-runtime compatibility
+    return this.decompressSync(data);
+  }
+}

package/ts_shared/classes.tartools.ts

@@ -0,0 +1,89 @@
+import * as plugins from './plugins.js';
+import type { IArchiveEntry, ITarEntry, TCompressionLevel } from './interfaces.js';
+import { GzipTools } from './classes.gziptools.js';
+
+/**
+ * TAR archive creation and extraction utilities using modern-tar (browser-compatible)
+ */
+export class TarTools {
+  /**
+   * Pack files into a TAR buffer
+   */
+  public async packFiles(files: IArchiveEntry[]): Promise<Uint8Array> {
+    const entries: ITarEntry[] = [];
+
+    for (const file of files) {
+      let data: Uint8Array;
+
+      if (typeof file.content === 'string') {
+        data = new TextEncoder().encode(file.content);
+      } else if (file.content instanceof Uint8Array) {
+        data = file.content;
+      } else if (file.content instanceof plugins.smartfile.SmartFile) {
+        data = new Uint8Array(file.content.contents);
+      } else if (file.content instanceof plugins.smartfile.StreamFile) {
+        const buffer = await file.content.getContentAsBuffer();
+        data = new Uint8Array(buffer);
+      } else {
+        throw new Error('Unsupported content type for TAR entry');
+      }
+
+      entries.push({
+        header: {
+          name: file.archivePath,
+          size: data.length,
+          type: 'file',
+          mode: file.mode,
+          mtime: file.mtime,
+        },
+        body: data,
+      });
+    }
+
+    return plugins.modernTar.packTar(entries);
+  }
+
+  /**
+   * Extract a TAR buffer to an array of entries
+   */
+  public async extractTar(data: Uint8Array): Promise<Array<{ path: string; content: Uint8Array; isDirectory: boolean }>> {
+    const entries = await plugins.modernTar.unpackTar(data);
+    const result: Array<{ path: string; content: Uint8Array; isDirectory: boolean }> = [];
+
+    for (const entry of entries) {
+      const isDirectory = entry.header.type === 'directory' || entry.header.name.endsWith('/');
+
+      // modern-tar uses 'data' property, not 'body'
+      const content = entry.data ?? new Uint8Array(0);
+
+      result.push({
+        path: entry.header.name,
+        content,
+        isDirectory,
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Pack files into a TAR.GZ buffer
+   */
+  public async packFilesToTarGz(
+    files: IArchiveEntry[],
+    compressionLevel?: TCompressionLevel
+  ): Promise<Uint8Array> {
+    const tarBuffer = await this.packFiles(files);
+    const gzipTools = new GzipTools();
+    return gzipTools.compress(tarBuffer, compressionLevel);
+  }
+
+  /**
+   * Extract a TAR.GZ buffer to an array of entries
+   */
+  public async extractTarGz(data: Uint8Array): Promise<Array<{ path: string; content: Uint8Array; isDirectory: boolean }>> {
+    const gzipTools = new GzipTools();
+    const tarBuffer = await gzipTools.decompress(data);
+    return this.extractTar(tarBuffer);
+  }
+}

package/ts_shared/classes.ziptools.ts

@@ -0,0 +1,107 @@
+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<Uint8Array, plugins.smartfile.StreamFile> {
+  private streamtools!: plugins.smartstream.IStreamTools;
+  private unzipper = new plugins.fflate.Unzip(async (fileArg) => {
+    let resultBuffer: Uint8Array;
+    fileArg.ondata = async (_flateError, dat, final) => {
+      if (resultBuffer) {
+        const combined = new Uint8Array(resultBuffer.length + dat.length);
+        combined.set(resultBuffer);
+        combined.set(dat, resultBuffer.length);
+        resultBuffer = combined;
+      } else {
+        resultBuffer = new Uint8Array(dat);
+      }
+      if (final) {
+        const streamFile = plugins.smartfile.StreamFile.fromBuffer(Buffer.from(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);
+        const chunk = chunkArg instanceof Uint8Array ? chunkArg : new Uint8Array(chunkArg);
+        this.unzipper.push(chunk, false);
+        return null;
+      },
+      finalFunction: async () => {
+        this.unzipper.push(new Uint8Array(0), true);
+        await plugins.smartdelay.delayFor(0);
+        await this.streamtools.push(null);
+        return null;
+      },
+    });
+    this.unzipper.register(plugins.fflate.UnzipInflate);
+  }
+}
+
+/**
+ * ZIP compression and decompression utilities
+ */
+export class ZipTools {
+  /**
+   * 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<Uint8Array> {
+    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 (entry.content instanceof Uint8Array) {
+        data = 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 {
+        throw new Error('Unsupported content type for ZIP entry');
+      }
+
+      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 result;
+  }
+
+  /**
+   * Extract a ZIP buffer to an array of entries
+   */
+  public async extractZip(data: Uint8Array): Promise<Array<{ path: string; content: Uint8Array }>> {
+    // Use sync version for Deno compatibility (fflate async uses Web Workers)
+    const result = plugins.fflate.unzipSync(data);
+    const entries: Array<{ path: string; content: Uint8Array }> = [];
+    for (const [path, content] of Object.entries(result)) {
+      entries.push({ path, content });
+    }
+    return entries;
+  }
+}

package/ts_shared/index.ts

@@ -0,0 +1,17 @@
+// ts_shared - Browser-compatible shared code
+
+// Interfaces and types
+export * from './interfaces.js';
+
+// Error classes
+export * from './errors.js';
+
+// Tool classes
+export { ZipTools, ZipDecompressionTransform } from './classes.ziptools.js';
+export { GzipTools } from './classes.gziptools.js';
+export { TarTools } from './classes.tartools.js';
+export { Bzip2Tools } from './classes.bzip2tools.js';
+
+// BZIP2 internals (for advanced usage)
+export { unbzip2Stream } from './bzip2/index.js';
+export { Bzip2 } from './bzip2/bzip2.js';

package/{ts → ts_shared}/interfaces.ts

@@ -1,4 +1,3 @@
-import type * as stream from 'node:stream';
 import type { SmartFile, StreamFile } from '@push.rocks/smartfile';
 
 /**
@@ -22,13 +21,13 @@ export type TSupportedMime =
   | undefined;
 
 /**
- * Entry to add to an archive during creation
+ * Entry to add to an archive during creation (browser-compatible)
  */
 export interface IArchiveEntry {
   /** Path within the archive */
   archivePath: string;
-  /** Content: string, Buffer, Readable stream, SmartFile, or StreamFile */
-  content: string | Buffer | stream.Readable | SmartFile | StreamFile;
+  /** Content: string, Buffer/Uint8Array, SmartFile, or StreamFile */
+  content: string | Uint8Array | SmartFile | StreamFile;
   /** Optional size hint for streams (improves performance) */
   size?: number;
   /** Optional file mode/permissions */
@@ -104,11 +103,9 @@ export interface IAddFileOptions {
   /** Filename within the archive */
   fileName?: string;
   /** File content */
-  content?: string | Buffer | stream.Readable | SmartFile | StreamFile;
+  content?: string | Uint8Array | SmartFile | StreamFile;
   /** Size in bytes (required for streams) */
   byteLength?: number;
-  /** Path to file on disk (alternative to content) */
-  filePath?: string;
 }
 
 /**
@@ -134,3 +131,17 @@ export interface IHuffmanGroup {
  * Entry filter predicate for fluent API
  */
 export type TEntryFilter = (entry: IArchiveEntryInfo) => boolean;
+
+/**
+ * TAR entry for modern-tar compatibility
+ */
+export interface ITarEntry {
+  header: {
+    name: string;
+    size: number;
+    type?: 'file' | 'directory';
+    mode?: number;
+    mtime?: Date;
+  };
+  body: string | Uint8Array;
+}

package/ts_shared/plugins.ts

@@ -0,0 +1,22 @@
+// Browser-compatible plugins for ts_shared
+// NO Node.js imports allowed here
+
+// @push.rocks scope (browser-compatible)
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartstream from '@push.rocks/smartstream';
+import * as smartfile from '@push.rocks/smartfile';
+
+export {
+  smartdelay,
+  smartpromise,
+  smartstream,
+  smartfile,
+};
+
+// third party scope (browser-compatible)
+import * as fileType from 'file-type';
+import * as fflate from 'fflate';
+import * as modernTar from 'modern-tar';
+
+export { fileType, fflate, modernTar };

package/ts_web/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartarchive',
+  version: '5.2.0',
+  description: 'A library for working with archive files, providing utilities for compressing and decompressing data.'
+}

package/ts_web/index.ts

@@ -0,0 +1,4 @@
+// ts_web - Browser-compatible entry point
+// Re-exports everything from ts_shared
+
+export * from '../ts_shared/index.js';

package/ts_web/plugins.ts

@@ -0,0 +1,3 @@
+// Browser-compatible plugins for ts_web
+// Re-export from ts_shared
+export * from '../ts_shared/plugins.js';

package/dist_ts/bzip2/bititerator.js

@@ -1,50 +0,0 @@
-const BITMASK = [0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff];
-/**
- * Creates a bit reader function for BZIP2 decompression.
- * Takes a buffer iterator as input and returns a function that reads bits.
- */
-export function bitIterator(nextBuffer) {
-    let bit = 0;
-    let byte = 0;
-    let bytes = nextBuffer();
-    let _bytesRead = 0;
-    const reader = function (n) {
-        if (n === null && bit !== 0) {
-            // align to byte boundary
-            bit = 0;
-            byte++;
-            return;
-        }
-        let result = 0;
-        let remaining = n;
-        while (remaining > 0) {
-            if (byte >= bytes.length) {
-                byte = 0;
-                bytes = nextBuffer();
-            }
-            const left = 8 - bit;
-            if (bit === 0 && remaining > 0) {
-                _bytesRead++;
-            }
-            if (remaining >= left) {
-                result <<= left;
-                result |= BITMASK[left] & bytes[byte++];
-                bit = 0;
-                remaining -= left;
-            }
-            else {
-                result <<= remaining;
-                result |= (bytes[byte] & (BITMASK[remaining] << (8 - remaining - bit))) >> (8 - remaining - bit);
-                bit += remaining;
-                remaining = 0;
-            }
-        }
-        return result;
-    };
-    Object.defineProperty(reader, 'bytesRead', {
-        get: () => _bytesRead,
-        enumerable: true,
-    });
-    return reader;
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/bzip2/index.js

@@ -1,92 +0,0 @@
-import * as plugins from '../plugins.js';
-import { Bzip2Error, BZIP2_ERROR_CODES } from '../errors.js';
-import { Bzip2 } from './bzip2.js';
-import { bitIterator } from './bititerator.js';
-/**
- * Creates a streaming BZIP2 decompression transform
- */
-export function unbzip2Stream() {
-    const bzip2Instance = new Bzip2();
-    const bufferQueue = [];
-    let hasBytes = 0;
-    let blockSize = 0;
-    let broken = false;
-    let bitReader = null;
-    let streamCRC = null;
-    function decompressBlock() {
-        if (!blockSize) {
-            blockSize = bzip2Instance.header(bitReader);
-            streamCRC = 0;
-            return undefined;
-        }
-        const bufsize = 100000 * blockSize;
-        const buf = new Int32Array(bufsize);
-        const chunk = [];
-        const outputFunc = (b) => {
-            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);
-    }
-    let outlength = 0;
-    const decompressAndPush = async () => {
-        if (broken)
-            return undefined;
-        try {
-            const resultChunk = decompressBlock();
-            if (resultChunk) {
-                outlength += resultChunk.length;
-            }
-            return resultChunk;
-        }
-        catch (e) {
-            broken = true;
-            if (e instanceof Error) {
-                throw new Bzip2Error(`Decompression failed: ${e.message}`, BZIP2_ERROR_CODES.INVALID_BLOCK_DATA);
-            }
-            throw e;
-        }
-    };
-    return new plugins.smartstream.SmartDuplex({
-        objectMode: true,
-        name: 'bzip2',
-        highWaterMark: 1,
-        writeFunction: async function (data, streamTools) {
-            bufferQueue.push(data);
-            hasBytes += data.length;
-            if (bitReader === null) {
-                bitReader = bitIterator(function () {
-                    return bufferQueue.shift();
-                });
-            }
-            const threshold = 25000 + 100000 * blockSize || 4;
-            while (!broken && hasBytes - bitReader.bytesRead + 1 >= threshold) {
-                const result = await decompressAndPush();
-                if (!result) {
-                    continue;
-                }
-                await streamTools.push(result);
-            }
-            return null;
-        },
-        finalFunction: async function (streamTools) {
-            while (!broken && bitReader && hasBytes > bitReader.bytesRead) {
-                const result = await decompressAndPush();
-                if (!result) {
-                    continue;
-                }
-                await streamTools.push(result);
-            }
-            if (!broken && streamCRC !== null) {
-                this.emit('error', new Bzip2Error('Input stream ended prematurely', BZIP2_ERROR_CODES.PREMATURE_END));
-            }
-            return null;
-        },
-    });
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.bzip2tools.d.ts

@@ -1,7 +0,0 @@
-import type { SmartArchive } from './classes.smartarchive.js';
-import * as plugins from './plugins.js';
-export declare class Bzip2Tools {
-    smartArchiveRef: SmartArchive;
-    constructor(smartArchiveRefArg: SmartArchive);
-    getDecompressionStream(): plugins.smartstream.SmartDuplex<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
-}

package/dist_ts/classes.bzip2tools.js

@@ -1,11 +0,0 @@
-import * as plugins from './plugins.js';
-import { unbzip2Stream } from './bzip2/index.js';
-export class Bzip2Tools {
-    constructor(smartArchiveRefArg) {
-        this.smartArchiveRef = smartArchiveRefArg;
-    }
-    getDecompressionStream() {
-        return unbzip2Stream();
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5iemlwMnRvb2xzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY2xhc3Nlcy5iemlwMnRvb2xzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBRXhDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVqRCxNQUFNLE9BQU8sVUFBVTtJQUdyQixZQUFZLGtCQUFnQztRQUMxQyxJQUFJLENBQUMsZUFBZSxHQUFHLGtCQUFrQixDQUFDO0lBQzVDLENBQUM7SUFFRCxzQkFBc0I7UUFDcEIsT0FBTyxhQUFhLEVBQUUsQ0FBQztJQUN6QixDQUFDO0NBQ0YifQ==

package/dist_ts/classes.gziptools.d.ts

@@ -1,53 +0,0 @@
-import * as plugins from './plugins.js';
-import type { TCompressionLevel } from './interfaces.js';
-/**
- * Transform stream for GZIP compression using fflate
- */
-export declare class GzipCompressionTransform extends plugins.stream.Transform {
-    private gzip;
-    constructor(level?: TCompressionLevel);
-    _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback): void;
-    _flush(callback: plugins.stream.TransformCallback): void;
-}
-/**
- * Transform stream for GZIP decompression using fflate
- */
-export declare class GzipDecompressionTransform extends plugins.stream.Transform {
-    private gunzip;
-    constructor();
-    _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback): void;
-    _flush(callback: plugins.stream.TransformCallback): void;
-}
-/**
- * GZIP compression and decompression utilities
- */
-export declare class GzipTools {
-    /**
-     * Get a streaming compression transform
-     */
-    getCompressionStream(level?: TCompressionLevel): plugins.stream.Transform;
-    /**
-     * Get a streaming decompression transform
-     */
-    getDecompressionStream(): plugins.stream.Transform;
-    /**
-     * Compress data synchronously
-     */
-    compressSync(data: Buffer, level?: TCompressionLevel): Buffer;
-    /**
-     * Decompress data synchronously
-     */
-    decompressSync(data: Buffer): Buffer;
-    /**
-     * Compress data asynchronously
-     * Note: Uses sync version for Deno compatibility (fflate async uses Web Workers
-     * which have issues in Deno)
-     */
-    compress(data: Buffer, level?: TCompressionLevel): Promise<Buffer>;
-    /**
-     * Decompress data asynchronously
-     * Note: Uses sync version for Deno compatibility (fflate async uses Web Workers
-     * which have issues in Deno)
-     */
-    decompress(data: Buffer): Promise<Buffer>;
-}