@push.rocks/smartarchive 4.2.4 → 5.0.0

package/dist_ts/classes.smartarchive.js

@@ -1,43 +1,220 @@
 import * as plugins from './plugins.js';
-import * as paths from './paths.js';
 import { Bzip2Tools } from './classes.bzip2tools.js';
 import { GzipTools } from './classes.gziptools.js';
 import { TarTools } from './classes.tartools.js';
 import { ZipTools } from './classes.ziptools.js';
-import { ArchiveAnalyzer, } from './classes.archiveanalyzer.js';
+import { ArchiveAnalyzer } from './classes.archiveanalyzer.js';
+/**
+ * Main class for archive manipulation
+ * Supports TAR, ZIP, GZIP, and BZIP2 formats
+ */
 export class SmartArchive {
-    // STATIC
-    static async fromArchiveUrl(urlArg) {
+    // ============================================
+    // STATIC FACTORY METHODS - EXTRACTION
+    // ============================================
+    /**
+     * Create SmartArchive from a URL
+     */
+    static async fromUrl(urlArg) {
         const smartArchiveInstance = new SmartArchive();
         smartArchiveInstance.sourceUrl = urlArg;
         return smartArchiveInstance;
     }
-    static async fromArchiveFile(filePathArg) {
+    /**
+     * Create SmartArchive from a local file path
+     */
+    static async fromFile(filePathArg) {
         const smartArchiveInstance = new SmartArchive();
         smartArchiveInstance.sourceFilePath = filePathArg;
         return smartArchiveInstance;
     }
-    static async fromArchiveStream(streamArg) {
+    /**
+     * Create SmartArchive from a readable stream
+     */
+    static async fromStream(streamArg) {
         const smartArchiveInstance = new SmartArchive();
         smartArchiveInstance.sourceStream = streamArg;
         return smartArchiveInstance;
     }
+    /**
+     * Create SmartArchive from an in-memory buffer
+     */
+    static async fromBuffer(buffer) {
+        const smartArchiveInstance = new SmartArchive();
+        smartArchiveInstance.sourceStream = plugins.stream.Readable.from(buffer);
+        return smartArchiveInstance;
+    }
+    // ============================================
+    // STATIC FACTORY METHODS - CREATION
+    // ============================================
+    /**
+     * Create a new archive from a directory
+     */
+    static async fromDirectory(directoryPath, options) {
+        const smartArchiveInstance = new SmartArchive();
+        smartArchiveInstance.creationOptions = options;
+        const tarTools = new TarTools();
+        if (options.format === 'tar' || options.format === 'tar.gz' || options.format === 'tgz') {
+            if (options.format === 'tar') {
+                const pack = await tarTools.packDirectory(directoryPath);
+                pack.finalize();
+                smartArchiveInstance.archiveBuffer = await SmartArchive.streamToBuffer(pack);
+            }
+            else {
+                smartArchiveInstance.archiveBuffer = await tarTools.packDirectoryToTarGz(directoryPath, options.compressionLevel);
+            }
+        }
+        else if (options.format === 'zip') {
+            const zipTools = new ZipTools();
+            const fileTree = await plugins.listFileTree(directoryPath, '**/*');
+            const entries = [];
+            for (const filePath of fileTree) {
+                const absolutePath = plugins.path.join(directoryPath, filePath);
+                const content = await plugins.fsPromises.readFile(absolutePath);
+                entries.push({
+                    archivePath: filePath,
+                    content,
+                });
+            }
+            smartArchiveInstance.archiveBuffer = await zipTools.createZip(entries, options.compressionLevel);
+        }
+        else {
+            throw new Error(`Unsupported format for directory packing: ${options.format}`);
+        }
+        return smartArchiveInstance;
+    }
+    /**
+     * Create a new archive from an array of entries
+     */
+    static async fromFiles(files, options) {
+        const smartArchiveInstance = new SmartArchive();
+        smartArchiveInstance.creationOptions = options;
+        if (options.format === 'tar' || options.format === 'tar.gz' || options.format === 'tgz') {
+            const tarTools = new TarTools();
+            if (options.format === 'tar') {
+                smartArchiveInstance.archiveBuffer = await tarTools.packFiles(files);
+            }
+            else {
+                smartArchiveInstance.archiveBuffer = await tarTools.packFilesToTarGz(files, options.compressionLevel);
+            }
+        }
+        else if (options.format === 'zip') {
+            const zipTools = new ZipTools();
+            smartArchiveInstance.archiveBuffer = await zipTools.createZip(files, options.compressionLevel);
+        }
+        else if (options.format === 'gz') {
+            if (files.length !== 1) {
+                throw new Error('GZIP format only supports a single file');
+            }
+            const gzipTools = new GzipTools();
+            let content;
+            if (typeof files[0].content === 'string') {
+                content = Buffer.from(files[0].content);
+            }
+            else if (Buffer.isBuffer(files[0].content)) {
+                content = files[0].content;
+            }
+            else {
+                throw new Error('GZIP format requires string or Buffer content');
+            }
+            smartArchiveInstance.archiveBuffer = await gzipTools.compress(content, options.compressionLevel);
+        }
+        else {
+            throw new Error(`Unsupported format: ${options.format}`);
+        }
+        return smartArchiveInstance;
+    }
+    /**
+     * Start building an archive incrementally using a builder pattern
+     */
+    static create(options) {
+        const smartArchiveInstance = new SmartArchive();
+        smartArchiveInstance.creationOptions = options;
+        smartArchiveInstance.pendingEntries = [];
+        return smartArchiveInstance;
+    }
+    /**
+     * Helper to convert a stream to buffer
+     */
+    static async streamToBuffer(stream) {
+        const chunks = [];
+        return new Promise((resolve, reject) => {
+            stream.on('data', (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+            stream.on('end', () => resolve(Buffer.concat(chunks)));
+            stream.on('error', reject);
+        });
+    }
     constructor() {
-        // INSTANCE
+        // ============================================
+        // INSTANCE PROPERTIES
+        // ============================================
         this.tarTools = new TarTools();
         this.zipTools = new ZipTools();
         this.gzipTools = new GzipTools();
         this.bzip2Tools = new Bzip2Tools(this);
         this.archiveAnalyzer = new ArchiveAnalyzer(this);
-        this.singleFileMode = false;
-        this.addedDirectories = [];
-        this.addedFiles = [];
-        this.addedUrls = [];
+    }
+    // ============================================
+    // BUILDER METHODS (for incremental creation)
+    // ============================================
+    /**
+     * Add a file to the archive (builder pattern)
+     */
+    addFile(archivePath, content) {
+        if (!this.pendingEntries) {
+            throw new Error('addFile can only be called on archives created with SmartArchive.create()');
+        }
+        this.pendingEntries.push({ archivePath, content });
+        return this;
+    }
+    /**
+     * Add a SmartFile to the archive (builder pattern)
+     */
+    addSmartFile(file, archivePath) {
+        if (!this.pendingEntries) {
+            throw new Error('addSmartFile can only be called on archives created with SmartArchive.create()');
+        }
+        this.pendingEntries.push({
+            archivePath: archivePath || file.relative,
+            content: file,
+        });
+        return this;
+    }
+    /**
+     * Add a StreamFile to the archive (builder pattern)
+     */
+    addStreamFile(file, archivePath) {
+        if (!this.pendingEntries) {
+            throw new Error('addStreamFile can only be called on archives created with SmartArchive.create()');
+        }
+        this.pendingEntries.push({
+            archivePath: archivePath || file.relativeFilePath,
+            content: file,
+        });
+        return this;
     }
     /**
-     * gets the original archive stream
+     * Build the archive from pending entries
      */
-    async getArchiveStream() {
+    async build() {
+        if (!this.pendingEntries || !this.creationOptions) {
+            throw new Error('build can only be called on archives created with SmartArchive.create()');
+        }
+        const built = await SmartArchive.fromFiles(this.pendingEntries, this.creationOptions);
+        this.archiveBuffer = built.archiveBuffer;
+        this.pendingEntries = undefined;
+        return this;
+    }
+    // ============================================
+    // EXTRACTION METHODS
+    // ============================================
+    /**
+     * Get the original archive stream
+     */
+    async toStream() {
+        if (this.archiveBuffer) {
+            return plugins.stream.Readable.from(this.archiveBuffer);
+        }
         if (this.sourceStream) {
             return this.sourceStream;
         }
@@ -46,42 +223,75 @@ export class SmartArchive {
                 .url(this.sourceUrl)
                 .get();
             const webStream = response.stream();
-            // @ts-ignore - Web stream to Node.js stream conversion
-            const urlStream = plugins.stream.Readable.fromWeb(webStream);
-            return urlStream;
+            return plugins.stream.Readable.fromWeb(webStream);
         }
         if (this.sourceFilePath) {
-            const fileStream = plugins.fs.createReadStream(this.sourceFilePath);
-            return fileStream;
+            return plugins.fs.createReadStream(this.sourceFilePath);
         }
+        throw new Error('No archive source configured');
     }
-    async exportToTarGzStream() {
-        const tarPackStream = await this.tarTools.getPackStream();
-        const gzipStream = await this.gzipTools.getCompressionStream();
-        // const archiveStream = tarPackStream.pipe(gzipStream);
-        // return archiveStream;
+    /**
+     * Get archive as a Buffer
+     */
+    async toBuffer() {
+        if (this.archiveBuffer) {
+            return this.archiveBuffer;
+        }
+        const stream = await this.toStream();
+        return SmartArchive.streamToBuffer(stream);
     }
-    async exportToFs(targetDir, fileNameArg) {
+    /**
+     * Write archive to a file
+     */
+    async toFile(filePath) {
+        const buffer = await this.toBuffer();
+        await plugins.fsPromises.mkdir(plugins.path.dirname(filePath), { recursive: true });
+        await plugins.fsPromises.writeFile(filePath, buffer);
+    }
+    /**
+     * Extract archive to filesystem
+     */
+    async extractToDirectory(targetDir, options) {
         const done = plugins.smartpromise.defer();
-        const streamFileStream = await this.exportToStreamOfStreamFiles();
+        const streamFileStream = await this.extractToStream();
         streamFileStream.pipe(new plugins.smartstream.SmartDuplex({
             objectMode: true,
-            writeFunction: async (streamFileArg, streamtools) => {
-                const done = plugins.smartpromise.defer();
-                console.log(streamFileArg.relativeFilePath
-                    ? streamFileArg.relativeFilePath
-                    : 'no relative path');
+            writeFunction: async (streamFileArg) => {
+                const innerDone = plugins.smartpromise.defer();
                 const streamFile = streamFileArg;
+                let relativePath = streamFile.relativeFilePath || options?.fileName || 'extracted_file';
+                // Apply stripComponents if specified
+                if (options?.stripComponents && options.stripComponents > 0) {
+                    const parts = relativePath.split('/');
+                    relativePath = parts.slice(options.stripComponents).join('/');
+                    if (!relativePath) {
+                        innerDone.resolve();
+                        return;
+                    }
+                }
+                // Apply filter if specified
+                if (options?.filter) {
+                    const entryInfo = {
+                        path: relativePath,
+                        size: 0,
+                        isDirectory: false,
+                        isFile: true,
+                    };
+                    if (!options.filter(entryInfo)) {
+                        innerDone.resolve();
+                        return;
+                    }
+                }
                 const readStream = await streamFile.createReadStream();
                 await plugins.fsPromises.mkdir(targetDir, { recursive: true });
-                const writePath = plugins.path.join(targetDir, streamFile.relativeFilePath || fileNameArg);
+                const writePath = plugins.path.join(targetDir, relativePath);
                 await plugins.fsPromises.mkdir(plugins.path.dirname(writePath), { recursive: true });
                 const writeStream = plugins.fs.createWriteStream(writePath);
                 readStream.pipe(writeStream);
                 writeStream.on('finish', () => {
-                    done.resolve();
+                    innerDone.resolve();
                 });
-                await done.promise;
+                await innerDone.promise;
             },
             finalFunction: async () => {
                 done.resolve();
@@ -89,41 +299,43 @@ export class SmartArchive {
         }));
         return done.promise;
     }
-    async exportToStreamOfStreamFiles() {
+    /**
+     * Extract archive to a stream of StreamFile objects
+     */
+    async extractToStream() {
         const streamFileIntake = new plugins.smartstream.StreamIntake({
             objectMode: true,
         });
-        const archiveStream = await this.getArchiveStream();
+        // Guard to prevent multiple signalEnd calls
+        let hasSignaledEnd = false;
+        const safeSignalEnd = () => {
+            if (!hasSignaledEnd) {
+                hasSignaledEnd = true;
+                streamFileIntake.signalEnd();
+            }
+        };
+        const archiveStream = await this.toStream();
         const createAnalyzedStream = () => this.archiveAnalyzer.getAnalyzedStream();
-        // lets create a function that can be called multiple times to unpack layers of archives
         const createUnpackStream = () => plugins.smartstream.createTransformFunction(async (analyzedResultChunk) => {
             if (analyzedResultChunk.fileType?.mime === 'application/x-tar') {
                 const tarStream = analyzedResultChunk.decompressionStream;
                 tarStream.on('entry', async (header, stream, next) => {
                     if (header.type === 'directory') {
-                        console.log(`tar stream directory: ${header.name} ... skipping!`);
-                        stream.resume(); // Consume directory stream
+                        stream.resume();
                         stream.on('end', () => next());
                         return;
                     }
-                    console.log(`tar stream file: ${header.name}`);
-                    // Create a PassThrough stream to buffer the data
                     const passThrough = new plugins.stream.PassThrough();
                     const streamfile = plugins.smartfile.StreamFile.fromStream(passThrough, header.name);
-                    // Push the streamfile immediately
                     streamFileIntake.push(streamfile);
-                    // Pipe the tar entry stream to the passthrough
                     stream.pipe(passThrough);
-                    // Move to next entry when this one ends
                     stream.on('end', () => {
                         passThrough.end();
                         next();
                     });
                 });
-                tarStream.on('finish', function () {
-                    console.log('tar extraction finished');
-                    // Only signal end if this is the final stream
-                    streamFileIntake.signalEnd();
+                tarStream.on('finish', () => {
+                    safeSignalEnd();
                 });
                 analyzedResultChunk.resultStream.pipe(analyzedResultChunk.decompressionStream);
             }
@@ -132,33 +344,158 @@ export class SmartArchive {
                     .pipe(analyzedResultChunk.decompressionStream)
                     .pipe(new plugins.smartstream.SmartDuplex({
                     objectMode: true,
-                    writeFunction: async (streamFileArg, streamtools) => {
+                    writeFunction: async (streamFileArg) => {
                         streamFileIntake.push(streamFileArg);
                     },
                     finalFunction: async () => {
-                        streamFileIntake.signalEnd();
+                        safeSignalEnd();
                     },
                 }));
             }
-            else if (analyzedResultChunk.isArchive &&
-                analyzedResultChunk.decompressionStream) {
+            else if (analyzedResultChunk.isArchive && analyzedResultChunk.decompressionStream) {
                 // For nested archives (like gzip containing tar)
-                const nestedStream = analyzedResultChunk.resultStream
+                analyzedResultChunk.resultStream
                     .pipe(analyzedResultChunk.decompressionStream)
                     .pipe(createAnalyzedStream())
                     .pipe(createUnpackStream());
-                // Don't signal end here - let the nested unpacker handle it
             }
             else {
                 const streamFile = plugins.smartfile.StreamFile.fromStream(analyzedResultChunk.resultStream, analyzedResultChunk.fileType?.ext);
                 streamFileIntake.push(streamFile);
-                streamFileIntake.signalEnd();
+                safeSignalEnd();
             }
-        }, {
-            objectMode: true,
-        });
+        }, { objectMode: true });
         archiveStream.pipe(createAnalyzedStream()).pipe(createUnpackStream());
         return streamFileIntake;
     }
+    /**
+     * Extract archive to an array of SmartFile objects (in-memory)
+     */
+    async extractToSmartFiles() {
+        const streamFiles = await this.extractToStream();
+        const smartFiles = [];
+        return new Promise((resolve, reject) => {
+            streamFiles.on('data', async (streamFile) => {
+                try {
+                    const smartFile = await streamFile.toSmartFile();
+                    smartFiles.push(smartFile);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+            streamFiles.on('end', () => resolve(smartFiles));
+            streamFiles.on('error', reject);
+        });
+    }
+    /**
+     * Extract a single file from the archive by path
+     */
+    async extractFile(filePath) {
+        const streamFiles = await this.extractToStream();
+        return new Promise((resolve, reject) => {
+            let found = false;
+            streamFiles.on('data', async (streamFile) => {
+                if (streamFile.relativeFilePath === filePath || streamFile.relativeFilePath?.endsWith(filePath)) {
+                    found = true;
+                    try {
+                        const smartFile = await streamFile.toSmartFile();
+                        resolve(smartFile);
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                }
+            });
+            streamFiles.on('end', () => {
+                if (!found) {
+                    resolve(null);
+                }
+            });
+            streamFiles.on('error', reject);
+        });
+    }
+    // ============================================
+    // ANALYSIS METHODS
+    // ============================================
+    /**
+     * Analyze the archive and return metadata
+     */
+    async analyze() {
+        const stream = await this.toStream();
+        const firstChunk = await this.readFirstChunk(stream);
+        const fileType = await plugins.fileType.fileTypeFromBuffer(firstChunk);
+        let format = null;
+        let isCompressed = false;
+        let isArchive = false;
+        if (fileType) {
+            switch (fileType.mime) {
+                case 'application/gzip':
+                    format = 'gz';
+                    isCompressed = true;
+                    isArchive = true;
+                    break;
+                case 'application/zip':
+                    format = 'zip';
+                    isCompressed = true;
+                    isArchive = true;
+                    break;
+                case 'application/x-tar':
+                    format = 'tar';
+                    isArchive = true;
+                    break;
+                case 'application/x-bzip2':
+                    format = 'bz2';
+                    isCompressed = true;
+                    isArchive = true;
+                    break;
+            }
+        }
+        return {
+            format,
+            isCompressed,
+            isArchive,
+        };
+    }
+    /**
+     * List all entries in the archive without extracting
+     */
+    async listEntries() {
+        const entries = [];
+        const streamFiles = await this.extractToStream();
+        return new Promise((resolve, reject) => {
+            streamFiles.on('data', (streamFile) => {
+                entries.push({
+                    path: streamFile.relativeFilePath || 'unknown',
+                    size: 0, // Size not available without reading
+                    isDirectory: false,
+                    isFile: true,
+                });
+            });
+            streamFiles.on('end', () => resolve(entries));
+            streamFiles.on('error', reject);
+        });
+    }
+    /**
+     * Check if a specific file exists in the archive
+     */
+    async hasFile(filePath) {
+        const entries = await this.listEntries();
+        return entries.some((e) => e.path === filePath || e.path.endsWith(filePath));
+    }
+    /**
+     * Helper to read first chunk from stream
+     */
+    async readFirstChunk(stream) {
+        return new Promise((resolve, reject) => {
+            const onData = (chunk) => {
+                stream.removeListener('data', onData);
+                stream.removeListener('error', reject);
+                resolve(chunk);
+            };
+            stream.on('data', onData);
+            stream.on('error', reject);
+        });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.smartarchive.js","sourceRoot":"","sources":["../ts/classes.smartarchive.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.tartools.d.ts

@@ -1,17 +1,44 @@
 import * as plugins from './plugins.js';
+import type { IArchiveEntry, TCompressionLevel } from './interfaces.js';
+/**
+ * TAR archive creation and extraction utilities
+ */
 export declare class TarTools {
-    constructor();
+    /**
+     * Add a file to a TAR pack stream
+     */
     addFileToPack(pack: plugins.tarStream.Pack, optionsArg: {
         fileName?: string;
-        content?: string | Buffer | plugins.smartstream.stream.Readable | plugins.smartfile.SmartFile | plugins.smartfile.StreamFile;
+        content?: string | Buffer | plugins.stream.Readable | plugins.smartfile.SmartFile | plugins.smartfile.StreamFile;
         byteLength?: number;
         filePath?: string;
     }): Promise<void>;
     /**
-     * packs a directory from disk into a tar stream
-     * @param directoryPath
+     * Pack a directory into a TAR stream
      */
     packDirectory(directoryPath: string): Promise<plugins.tarStream.Pack>;
+    /**
+     * Get a new TAR pack stream
+     */
     getPackStream(): Promise<plugins.tarStream.Pack>;
+    /**
+     * Get a TAR extraction stream
+     */
     getDecompressionStream(): plugins.tarStream.Extract;
+    /**
+     * Pack files into a TAR buffer
+     */
+    packFiles(files: IArchiveEntry[]): Promise<Buffer>;
+    /**
+     * Pack a directory into a TAR.GZ buffer
+     */
+    packDirectoryToTarGz(directoryPath: string, compressionLevel?: TCompressionLevel): Promise<Buffer>;
+    /**
+     * Pack a directory into a TAR.GZ stream
+     */
+    packDirectoryToTarGzStream(directoryPath: string, compressionLevel?: TCompressionLevel): Promise<plugins.stream.Readable>;
+    /**
+     * Pack files into a TAR.GZ buffer
+     */
+    packFilesToTarGz(files: IArchiveEntry[], compressionLevel?: TCompressionLevel): Promise<Buffer>;
 }