@push.rocks/smartarchive 5.0.0 → 5.1.0

package/ts/classes.tartools.ts

@@ -1,208 +1,51 @@
 import * as plugins from './plugins.js';
-import type { IArchiveEntry, TCompressionLevel } from './interfaces.js';
-import { GzipTools } from './classes.gziptools.js';
+import type { IArchiveEntry, TCompressionLevel } from '../ts_shared/interfaces.js';
+import { TarTools as SharedTarTools } from '../ts_shared/classes.tartools.js';
+import { GzipTools } from '../ts_shared/classes.gziptools.js';
 
 /**
- * TAR archive creation and extraction utilities
+ * Extended TAR archive utilities with Node.js filesystem support
  */
-export class TarTools {
+export class TarTools extends SharedTarTools {
   /**
-   * Add a file to a TAR pack stream
+   * Pack a directory into a TAR buffer (Node.js only)
    */
-  public async addFileToPack(
-    pack: plugins.tarStream.Pack,
-    optionsArg: {
-      fileName?: string;
-      content?:
-        | string
-        | Buffer
-        | plugins.stream.Readable
-        | plugins.smartfile.SmartFile
-        | plugins.smartfile.StreamFile;
-      byteLength?: number;
-      filePath?: string;
-    }
-  ): Promise<void> {
-    return new Promise<void>(async (resolve, reject) => {
-      let fileName: string | null = null;
-
-      if (optionsArg.fileName) {
-        fileName = optionsArg.fileName;
-      } else if (optionsArg.content instanceof plugins.smartfile.SmartFile) {
-        fileName = optionsArg.content.relative;
-      } else if (optionsArg.content instanceof plugins.smartfile.StreamFile) {
-        fileName = optionsArg.content.relativeFilePath;
-      } else if (optionsArg.filePath) {
-        fileName = optionsArg.filePath;
-      }
-
-      if (!fileName) {
-        reject(new Error('No filename specified for TAR entry'));
-        return;
-      }
-
-      // Determine content byte length
-      let contentByteLength: number | undefined;
-      if (optionsArg.byteLength) {
-        contentByteLength = optionsArg.byteLength;
-      } else if (typeof optionsArg.content === 'string') {
-        contentByteLength = Buffer.byteLength(optionsArg.content, 'utf8');
-      } else if (Buffer.isBuffer(optionsArg.content)) {
-        contentByteLength = optionsArg.content.length;
-      } else if (optionsArg.content instanceof plugins.smartfile.SmartFile) {
-        contentByteLength = await optionsArg.content.getSize();
-      } else if (optionsArg.content instanceof plugins.smartfile.StreamFile) {
-        contentByteLength = await optionsArg.content.getSize();
-      } else if (optionsArg.filePath) {
-        const fileStat = await plugins.fsPromises.stat(optionsArg.filePath);
-        contentByteLength = fileStat.size;
-      }
-
-      // Convert all content types to Readable stream
-      let content: plugins.stream.Readable;
-      if (Buffer.isBuffer(optionsArg.content)) {
-        content = plugins.stream.Readable.from(optionsArg.content);
-      } else if (typeof optionsArg.content === 'string') {
-        content = plugins.stream.Readable.from(Buffer.from(optionsArg.content));
-      } else if (optionsArg.content instanceof plugins.smartfile.SmartFile) {
-        content = plugins.stream.Readable.from(optionsArg.content.contents);
-      } else if (optionsArg.content instanceof plugins.smartfile.StreamFile) {
-        content = await optionsArg.content.createReadStream();
-      } else if (optionsArg.content instanceof plugins.stream.Readable) {
-        content = optionsArg.content;
-      } else if (optionsArg.filePath) {
-        content = plugins.fs.createReadStream(optionsArg.filePath);
-      } else {
-        reject(new Error('No content or filePath specified for TAR entry'));
-        return;
-      }
-
-      const entry = pack.entry(
-        {
-          name: fileName,
-          ...(contentByteLength !== undefined ? { size: contentByteLength } : {}),
-        },
-        (err: Error | null) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve();
-          }
-        }
-      );
-
-      content.pipe(entry);
-      // Note: resolve() is called in the callback above when pipe completes
-    });
-  }
-
-  /**
-   * Pack a directory into a TAR stream
-   */
-  public async packDirectory(directoryPath: string): Promise<plugins.tarStream.Pack> {
+  public async packDirectory(directoryPath: string): Promise<Uint8Array> {
     const fileTree = await plugins.listFileTree(directoryPath, '**/*');
-    const pack = await this.getPackStream();
+    const entries: IArchiveEntry[] = [];
 
     for (const filePath of fileTree) {
       const absolutePath = plugins.path.join(directoryPath, filePath);
-      const fileStat = await plugins.fsPromises.stat(absolutePath);
-      await this.addFileToPack(pack, {
-        byteLength: fileStat.size,
-        filePath: absolutePath,
-        fileName: filePath,
-        content: plugins.fs.createReadStream(absolutePath),
+      const content = await plugins.fsPromises.readFile(absolutePath);
+      entries.push({
+        archivePath: filePath,
+        content: new Uint8Array(content),
       });
     }
 
-    return pack;
+    return this.packFiles(entries);
   }
 
   /**
-   * Get a new TAR pack stream
-   */
-  public async getPackStream(): Promise<plugins.tarStream.Pack> {
-    return plugins.tarStream.pack();
-  }
-
-  /**
-   * Get a TAR extraction stream
-   */
-  public getDecompressionStream(): plugins.tarStream.Extract {
-    return plugins.tarStream.extract();
-  }
-
-  /**
-   * Pack files into a TAR buffer
-   */
-  public async packFiles(files: IArchiveEntry[]): Promise<Buffer> {
-    const pack = await this.getPackStream();
-
-    for (const file of files) {
-      await this.addFileToPack(pack, {
-        fileName: file.archivePath,
-        content: file.content as string | Buffer | plugins.stream.Readable | plugins.smartfile.SmartFile | plugins.smartfile.StreamFile,
-        byteLength: file.size,
-      });
-    }
-
-    pack.finalize();
-
-    const chunks: Buffer[] = [];
-    return new Promise((resolve, reject) => {
-      pack.on('data', (chunk: Buffer) => chunks.push(chunk));
-      pack.on('end', () => resolve(Buffer.concat(chunks)));
-      pack.on('error', reject);
-    });
-  }
-
-  /**
-   * Pack a directory into a TAR.GZ buffer
+   * Pack a directory into a TAR.GZ buffer (Node.js only)
    */
   public async packDirectoryToTarGz(
     directoryPath: string,
     compressionLevel?: TCompressionLevel
-  ): Promise<Buffer> {
-    const pack = await this.packDirectory(directoryPath);
-    pack.finalize();
-
+  ): Promise<Uint8Array> {
+    const tarBuffer = await this.packDirectory(directoryPath);
     const gzipTools = new GzipTools();
-    const gzipStream = gzipTools.getCompressionStream(compressionLevel);
-
-    const chunks: Buffer[] = [];
-    return new Promise((resolve, reject) => {
-      pack
-        .pipe(gzipStream)
-        .on('data', (chunk: Buffer) => chunks.push(chunk))
-        .on('end', () => resolve(Buffer.concat(chunks)))
-        .on('error', reject);
-    });
+    return gzipTools.compress(tarBuffer, compressionLevel);
   }
 
   /**
-   * Pack a directory into a TAR.GZ stream
+   * Pack a directory into a TAR.GZ stream (Node.js only)
    */
   public async packDirectoryToTarGzStream(
     directoryPath: string,
     compressionLevel?: TCompressionLevel
   ): Promise<plugins.stream.Readable> {
-    const pack = await this.packDirectory(directoryPath);
-    pack.finalize();
-
-    const gzipTools = new GzipTools();
-    const gzipStream = gzipTools.getCompressionStream(compressionLevel);
-
-    return pack.pipe(gzipStream);
-  }
-
-  /**
-   * Pack files into a TAR.GZ buffer
-   */
-  public async packFilesToTarGz(
-    files: IArchiveEntry[],
-    compressionLevel?: TCompressionLevel
-  ): Promise<Buffer> {
-    const tarBuffer = await this.packFiles(files);
-    const gzipTools = new GzipTools();
-    return gzipTools.compress(tarBuffer, compressionLevel);
+    const buffer = await this.packDirectoryToTarGz(directoryPath, compressionLevel);
+    return plugins.stream.Readable.from(buffer);
   }
 }

package/ts/index.ts

@@ -1,15 +1,11 @@
-// Core types and errors
-export * from './interfaces.js';
-export * from './errors.js';
+// Re-export everything from ts_shared (browser-compatible)
+export * from '../ts_shared/index.js';
 
-// Main archive class
+// Node.js-specific: Main archive class with filesystem support
 export * from './classes.smartarchive.js';
 
-// Format-specific tools
-export * from './classes.tartools.js';
-export * from './classes.ziptools.js';
-export * from './classes.gziptools.js';
-export * from './classes.bzip2tools.js';
-
-// Archive analysis
+// Node.js-specific: Archive analysis with SmartArchive integration
 export * from './classes.archiveanalyzer.js';
+
+// Node.js-specific: Extended TarTools with filesystem support (overrides shared TarTools)
+export { TarTools } from './classes.tartools.js';

package/ts/plugins.ts

@@ -1,4 +1,4 @@
-// node native scope
+// Node.js native scope
 import * as path from 'node:path';
 import * as stream from 'node:stream';
 import * as fs from 'node:fs';
@@ -30,32 +30,20 @@ export async function listFileTree(dirPath: string, _pattern: string = '**/*'):
   return results;
 }
 
-// @pushrocks scope
-import * as smartfile from '@push.rocks/smartfile';
-import * as smartdelay from '@push.rocks/smartdelay';
+// Re-export browser-compatible plugins from ts_shared
+export * from '../ts_shared/plugins.js';
+
+// Additional Node.js-specific @pushrocks packages
 import * as smartpath from '@push.rocks/smartpath';
-import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrequest from '@push.rocks/smartrequest';
 import * as smartunique from '@push.rocks/smartunique';
-import * as smartstream from '@push.rocks/smartstream';
 import * as smartrx from '@push.rocks/smartrx';
 import * as smarturl from '@push.rocks/smarturl';
 
 export {
-  smartfile,
-  smartdelay,
   smartpath,
-  smartpromise,
   smartrequest,
   smartunique,
-  smartstream,
   smartrx,
   smarturl,
 };
-
-// third party scope
-import * as fileType from 'file-type';
-import * as fflate from 'fflate';
-import tarStream from 'tar-stream';
-
-export { fileType, fflate, tarStream };

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

@@ -6,7 +6,7 @@ const BITMASK = [0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff] as const;
  * 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: () => Buffer): IBitReader {
+export function bitIterator(nextBuffer: () => Uint8Array): IBitReader {
   let bit = 0;
   let byte = 0;
   let bytes = nextBuffer();

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

@@ -71,7 +71,7 @@ export class Bzip2 {
   /**
    * Create a bit reader from a byte array
    */
-  array(bytes: Uint8Array | Buffer): (n: number) => number {
+  array(bytes: Uint8Array): (n: number) => number {
     let bit = 0;
     let byte = 0;
     const BITMASK = [0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff];
@@ -99,7 +99,7 @@ export class Bzip2 {
   /**
    * Simple decompression from a buffer
    */
-  simple(srcbuffer: Uint8Array | Buffer, stream: (byte: number) => void): void {
+  simple(srcbuffer: Uint8Array, stream: (byte: number) => void): void {
     const bits = this.array(srcbuffer);
     const size = this.header(bits as IBitReader);
     let ret: number | null = 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';