@push.rocks/smartarchive 3.0.7 → 4.0.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartarchive',
-    version: '3.0.7',
+    version: '4.0.0',
     description: 'work with archives'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwwQkFBMEI7SUFDaEMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLG9CQUFvQjtDQUNsQyxDQUFBIn0=

package/dist_ts/classes.archiveanalyzer.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { SmartArchive } from './classes.smartarchive.js';
+import * as plugins from './plugins.js';
+export interface IAnalyzedResult {
+    fileType: plugins.fileType.FileTypeResult;
+    isArchive: boolean;
+    resultStream: plugins.smartstream.PassThrough;
+    decompressionStream: plugins.stream.Transform | plugins.stream.Duplex | plugins.tarStream.Extract;
+}
+export declare class ArchiveAnalyzer {
+    smartArchiveRef: SmartArchive;
+    constructor(smartArchiveRefArg: SmartArchive);
+    private mimeTypeIsArchive;
+    private getDecompressionStream;
+    getAnalyzedStream(): plugins.smartstream.SmartDuplex<Buffer, IAnalyzedResult>;
+}

package/dist_ts/classes.archiveanalyzer.js

@@ -0,0 +1,57 @@
+import * as plugins from './plugins.js';
+export class ArchiveAnalyzer {
+    constructor(smartArchiveRefArg) {
+        this.smartArchiveRef = smartArchiveRefArg;
+    }
+    async mimeTypeIsArchive(mimeType) {
+        const archiveMimeTypes = new Set([
+            'application/zip',
+            'application/x-rar-compressed',
+            'application/x-tar',
+            'application/gzip',
+            'application/x-7z-compressed',
+            'application/x-bzip2',
+            // Add other archive mime types here
+        ]);
+        return archiveMimeTypes.has(mimeType);
+    }
+    getDecompressionStream(mimeTypeArg) {
+        switch (mimeTypeArg) {
+            case 'application/gzip':
+                return this.smartArchiveRef.gzipTools.getDecompressionStream();
+            case 'application/x-bzip2':
+                return this.smartArchiveRef.bzip2Tools.getDecompressionStream(); // replace with your own bzip2 decompression stream
+            case 'application/x-tar':
+                return this.smartArchiveRef.tarTools.getDecompressionStream(); // replace with your own tar decompression stream
+            default:
+                // Handle unsupported formats or no decompression needed
+                return new plugins.smartstream.PassThrough();
+        }
+    }
+    getAnalyzedStream() {
+        let firstRun = true;
+        const resultStream = new plugins.smartstream.PassThrough();
+        const analyzerstream = new plugins.smartstream.SmartDuplex({
+            readableObjectMode: true,
+            writeAndTransformFunction: async (chunkArg, streamtools) => {
+                const fileType = await plugins.fileType.fileTypeFromBuffer(chunkArg);
+                const decompressionStream = this.getDecompressionStream(fileType.mime);
+                resultStream.push(chunkArg);
+                if (firstRun) {
+                    firstRun = false;
+                    const result = {
+                        fileType,
+                        isArchive: await this.mimeTypeIsArchive(fileType.mime),
+                        resultStream,
+                        decompressionStream,
+                    };
+                    streamtools.push(result);
+                    streamtools.push(null);
+                    return null;
+                }
+            },
+        });
+        return analyzerstream;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.bzip2tools.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { SmartArchive } from './classes.smartarchive.js';
+import * as plugins from './plugins.js';
+export declare class DecompressBzip2Transform extends plugins.stream.Transform {
+    private bzip2Decompressor;
+    constructor();
+    _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback): void;
+    _flush(callback: plugins.stream.TransformCallback): void;
+}
+export declare class Bzip2Tools {
+    smartArchiveRef: SmartArchive;
+    constructor(smartArchiveRefArg: SmartArchive);
+    getDecompressionStream(): DecompressBzip2Transform;
+}

package/dist_ts/classes.bzip2tools.js

@@ -0,0 +1,36 @@
+import * as plugins from './plugins.js';
+export class DecompressBzip2Transform extends plugins.stream.Transform {
+    constructor() {
+        super();
+        // Initialize the bzip2 decompressor once here
+        this.bzip2Decompressor = plugins.unbzip2Stream();
+        this.bzip2Decompressor.on('data', (data) => {
+            // When data is decompressed, push it to the stream
+            this.push(data);
+        });
+        this.bzip2Decompressor.on('error', (err) => {
+            // If an error occurs, emit it on this stream
+            this.emit('error', err);
+        });
+    }
+    _transform(chunk, encoding, callback) {
+        // Pass the chunk directly to the decompressor
+        // The decompressor will handle the state across chunks
+        this.bzip2Decompressor.write(chunk);
+        callback();
+    }
+    _flush(callback) {
+        // When the stream is ending, end the decompressor stream as well
+        this.bzip2Decompressor.end();
+        callback();
+    }
+}
+export class Bzip2Tools {
+    constructor(smartArchiveRefArg) {
+        this.smartArchiveRef = smartArchiveRefArg;
+    }
+    getDecompressionStream() {
+        return new DecompressBzip2Transform();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5iemlwMnRvb2xzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY2xhc3Nlcy5iemlwMnRvb2xzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBRXhDLE1BQU0sT0FBTyx3QkFBeUIsU0FBUSxPQUFPLENBQUMsTUFBTSxDQUFDLFNBQVM7SUFHcEU7UUFDRSxLQUFLLEVBQUUsQ0FBQztRQUNSLDhDQUE4QztRQUM5QyxJQUFJLENBQUMsaUJBQWlCLEdBQUcsT0FBTyxDQUFDLGFBQWEsRUFBRSxDQUFDO1FBQ2pELElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsSUFBWSxFQUFFLEVBQUU7WUFDakQsbURBQW1EO1lBQ25ELElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDbEIsQ0FBQyxDQUFDLENBQUM7UUFDSCxJQUFJLENBQUMsaUJBQWlCLENBQUMsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDLEdBQUcsRUFBRSxFQUFFO1lBQ3pDLDZDQUE2QztZQUM3QyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxHQUFHLENBQUMsQ0FBQztRQUMxQixDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRCxVQUFVLENBQUMsS0FBYSxFQUFFLFFBQXdCLEVBQUUsUUFBMEM7UUFDNUYsOENBQThDO1FBQzlDLHVEQUF1RDtRQUN2RCxJQUFJLENBQUMsaUJBQWlCLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3BDLFFBQVEsRUFBRSxDQUFDO0lBQ2IsQ0FBQztJQUVELE1BQU0sQ0FBQyxRQUEwQztRQUMvQyxpRUFBaUU7UUFDakUsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQzdCLFFBQVEsRUFBRSxDQUFDO0lBQ2IsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLFVBQVU7SUFHckIsWUFBWSxrQkFBZ0M7UUFDMUMsSUFBSSxDQUFDLGVBQWUsR0FBRyxrQkFBa0IsQ0FBQztJQUM1QyxDQUFDO0lBRUQsc0JBQXNCO1FBQ3BCLE9BQU8sSUFBSSx3QkFBd0IsRUFBRSxDQUFDO0lBQ3hDLENBQUM7Q0FDRiJ9

package/dist_ts/classes.gziptools.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { SmartArchive } from './classes.smartarchive.js';
+import * as plugins from './plugins.js';
+export declare class CompressGunzipTransform extends plugins.stream.Transform {
+    constructor();
+    _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback): void;
+}
+export declare class DecompressGunzipTransform extends plugins.stream.Transform {
+    constructor();
+    _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback): void;
+}
+export declare class GzipTools {
+    smartArchiveRef: SmartArchive;
+    constructor(smartArchiveRefArg: SmartArchive);
+    getCompressionStream(): CompressGunzipTransform;
+    getDecompressionStream(): DecompressGunzipTransform;
+}

package/dist_ts/classes.gziptools.js

@@ -0,0 +1,51 @@
+import * as plugins from './plugins.js';
+// This class wraps fflate's gunzip in a Node.js Transform stream
+export class CompressGunzipTransform extends plugins.stream.Transform {
+    constructor() {
+        super();
+    }
+    _transform(chunk, encoding, callback) {
+        plugins.fflate.gunzip(chunk, (err, decompressed) => {
+            if (err) {
+                callback(err);
+            }
+            else {
+                this.push(decompressed);
+                callback();
+            }
+        });
+    }
+}
+// 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 {
+    constructor() {
+        super();
+    }
+    _transform(chunk, encoding, callback) {
+        // Use fflate's gunzip function to decompress the chunk
+        plugins.fflate.gunzip(chunk, (err, decompressed) => {
+            if (err) {
+                // If an error occurs during decompression, pass the error to the callback
+                callback(err);
+            }
+            else {
+                // If decompression is successful, push the decompressed data into the stream
+                this.push(decompressed);
+                callback();
+            }
+        });
+    }
+}
+export class GzipTools {
+    constructor(smartArchiveRefArg) {
+        this.smartArchiveRef = smartArchiveRefArg;
+    }
+    getCompressionStream() {
+        return new CompressGunzipTransform();
+    }
+    getDecompressionStream() {
+        return new DecompressGunzipTransform();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5nemlwdG9vbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9jbGFzc2VzLmd6aXB0b29scy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQTtBQUV2QyxpRUFBaUU7QUFDakUsTUFBTSxPQUFPLHVCQUF3QixTQUFRLE9BQU8sQ0FBQyxNQUFNLENBQUMsU0FBUztJQUNuRTtRQUNFLEtBQUssRUFBRSxDQUFDO0lBQ1YsQ0FBQztJQUVELFVBQVUsQ0FBQyxLQUFhLEVBQUUsUUFBd0IsRUFBRSxRQUEwQztRQUM1RixPQUFPLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxHQUFHLEVBQUUsWUFBWSxFQUFFLEVBQUU7WUFDakQsSUFBSSxHQUFHLEVBQUU7Z0JBQ1AsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDO2FBQ2Y7aUJBQU07Z0JBQ0wsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztnQkFDeEIsUUFBUSxFQUFFLENBQUM7YUFDWjtRQUNILENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGO0FBRUQsK0VBQStFO0FBQy9FLHdGQUF3RjtBQUN4RixNQUFNLE9BQU8seUJBQTBCLFNBQVEsT0FBTyxDQUFDLE1BQU0sQ0FBQyxTQUFTO0lBQ3JFO1FBQ0UsS0FBSyxFQUFFLENBQUM7SUFDVixDQUFDO0lBRUQsVUFBVSxDQUFDLEtBQWEsRUFBRSxRQUF3QixFQUFFLFFBQTBDO1FBQzVGLHVEQUF1RDtRQUN2RCxPQUFPLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxHQUFHLEVBQUUsWUFBWSxFQUFFLEVBQUU7WUFDakQsSUFBSSxHQUFHLEVBQUU7Z0JBQ1AsMEVBQTBFO2dCQUMxRSxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUM7YUFDZjtpQkFBTTtnQkFDTCw2RUFBNkU7Z0JBQzdFLElBQUksQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7Z0JBQ3hCLFFBQVEsRUFBRSxDQUFDO2FBQ1o7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRjtBQUdELE1BQU0sT0FBTyxTQUFTO0lBR3BCLFlBQVksa0JBQWdDO1FBQzFDLElBQUksQ0FBQyxlQUFlLEdBQUcsa0JBQWtCLENBQUM7SUFDNUMsQ0FBQztJQUVNLG9CQUFvQjtRQUN6QixPQUFPLElBQUksdUJBQXVCLEVBQUUsQ0FBQztJQUN2QyxDQUFDO0lBRU0sc0JBQXNCO1FBQzNCLE9BQU8sSUFBSSx5QkFBeUIsRUFBRSxDQUFDO0lBQ3pDLENBQUM7Q0FDRiJ9

package/dist_ts/classes.smartarchive.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" resolution-mode="require"/>
+import * as plugins from './plugins.js';
+import { GzipTools } from './classes.gziptools.js';
+import { TarTools } from './classes.tartools.js';
+import { Bzip2Tools } from './classes.bzip2tools.js';
+import { ArchiveAnalyzer } from './classes.archiveanalyzer.js';
+export declare class SmartArchive {
+    static fromArchiveUrl(urlArg: string): Promise<SmartArchive>;
+    static fromArchiveFile(filePathArg: string): Promise<SmartArchive>;
+    static fromArchiveStream(streamArg: plugins.stream.Readable | plugins.stream.Duplex | plugins.stream.Transform): Promise<SmartArchive>;
+    tarTools: TarTools;
+    gzipTools: GzipTools;
+    bzip2Tools: Bzip2Tools;
+    archiveAnalyzer: ArchiveAnalyzer;
+    sourceUrl: string;
+    sourceFilePath: string;
+    sourceStream: plugins.stream.Readable | plugins.stream.Duplex | plugins.stream.Transform;
+    archiveName: string;
+    singleFileMode: boolean;
+    addedDirectories: string[];
+    addedFiles: (plugins.smartfile.SmartFile | plugins.smartfile.StreamFile)[];
+    addedUrls: string[];
+    constructor();
+    /**
+     * gets the original archive stream
+     */
+    getArchiveStream(): Promise<plugins.stream.Readable | plugins.stream.Duplex>;
+    exportToTarGzStream(): Promise<void>;
+    exportToFs(targetDir: string): Promise<void>;
+    exportToStreamOfStreamFiles(): Promise<plugins.smartstream.StreamIntake<plugins.smartfile.StreamFile>>;
+}

package/dist_ts/classes.smartarchive.js

@@ -0,0 +1,91 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+import { GzipTools } from './classes.gziptools.js';
+import { TarTools } from './classes.tartools.js';
+import { Bzip2Tools } from './classes.bzip2tools.js';
+import { ArchiveAnalyzer } from './classes.archiveanalyzer.js';
+export class SmartArchive {
+    // STATIC
+    static async fromArchiveUrl(urlArg) {
+        const smartArchiveInstance = new SmartArchive();
+        smartArchiveInstance.sourceUrl = urlArg;
+        return smartArchiveInstance;
+    }
+    static async fromArchiveFile(filePathArg) {
+        const smartArchiveInstance = new SmartArchive();
+        smartArchiveInstance.sourceFilePath = filePathArg;
+        return smartArchiveInstance;
+    }
+    static async fromArchiveStream(streamArg) {
+        const smartArchiveInstance = new SmartArchive();
+        smartArchiveInstance.sourceStream = streamArg;
+        return smartArchiveInstance;
+    }
+    constructor() {
+        // INSTANCE
+        this.tarTools = new TarTools(this);
+        this.gzipTools = new GzipTools(this);
+        this.bzip2Tools = new Bzip2Tools(this);
+        this.archiveAnalyzer = new ArchiveAnalyzer(this);
+        this.singleFileMode = false;
+        this.addedDirectories = [];
+        this.addedFiles = [];
+        this.addedUrls = [];
+    }
+    /**
+     * gets the original archive stream
+     */
+    async getArchiveStream() {
+        if (this.sourceStream) {
+            return this.sourceStream;
+        }
+        if (this.sourceUrl) {
+            const urlStream = await plugins.smartrequest.getStream(this.sourceUrl);
+            return urlStream;
+        }
+        if (this.sourceFilePath) {
+            const fileStream = plugins.smartfile.fs.toReadStream(this.sourceFilePath);
+            return fileStream;
+        }
+    }
+    async exportToTarGzStream() {
+        const tarPackStream = await this.tarTools.getPackStream();
+        const gzipStream = await this.gzipTools.getCompressionStream();
+        // const archiveStream = tarPackStream.pipe(gzipStream);
+        // return archiveStream;
+    }
+    async exportToFs(targetDir) { }
+    async exportToStreamOfStreamFiles() {
+        const streamFileIntake = new plugins.smartstream.StreamIntake({
+            objectMode: true,
+        });
+        const archiveStream = await this.getArchiveStream();
+        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') {
+                analyzedResultChunk.decompressionStream.on('entry', async (header, stream, next) => {
+                    const streamfile = plugins.smartfile.StreamFile.fromStream(stream, header.name);
+                    streamFileIntake.push(streamfile);
+                    stream.on('end', function () {
+                        next(); // ready for next entry
+                    });
+                });
+                analyzedResultChunk.resultStream.pipe(analyzedResultChunk.decompressionStream);
+            }
+            else if (analyzedResultChunk.isArchive && analyzedResultChunk.decompressionStream) {
+                analyzedResultChunk.resultStream
+                    .pipe(analyzedResultChunk.decompressionStream)
+                    .pipe(createAnalyzedStream())
+                    .pipe(createUnpackStream());
+            }
+            else {
+                const streamFile = plugins.smartfile.StreamFile.fromStream(analyzedResultChunk.resultStream, analyzedResultChunk.fileType.ext);
+                streamFileIntake.push(streamFile);
+            }
+        });
+        archiveStream.pipe(createAnalyzedStream()).pipe(createUnpackStream());
+        return streamFileIntake;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.tartools.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { SmartArchive } from './classes.smartarchive.js';
+import * as plugins from './plugins.js';
+export declare class TarTools {
+    smartArchiveRef: SmartArchive;
+    constructor(smartArchiveRefArg: SmartArchive);
+    addFileToPack(pack: plugins.tarStream.Pack, fileName: string, content: string | Buffer): Promise<void>;
+    getPackStream(): Promise<plugins.tarStream.Pack>;
+    getDecompressionStream(): plugins.tarStream.Extract;
+}

package/dist_ts/classes.tartools.js

@@ -0,0 +1,30 @@
+import * as plugins from './plugins.js';
+export class TarTools {
+    constructor(smartArchiveRefArg) {
+        this.smartArchiveRef = smartArchiveRefArg;
+    }
+    // packing
+    addFileToPack(pack, fileName, content) {
+        return new Promise((resolve, reject) => {
+            const entry = pack.entry({ name: fileName, size: content.length }, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+            entry.write(content);
+            entry.end();
+        });
+    }
+    async getPackStream() {
+        const pack = plugins.tarStream.pack();
+        return pack;
+    }
+    // extracting
+    getDecompressionStream() {
+        return plugins.tarStream.extract();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy50YXJ0b29scy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2NsYXNzZXMudGFydG9vbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFFeEMsTUFBTSxPQUFPLFFBQVE7SUFHbkIsWUFBWSxrQkFBZ0M7UUFDMUMsSUFBSSxDQUFDLGVBQWUsR0FBRyxrQkFBa0IsQ0FBQztJQUM1QyxDQUFDO0lBRUQsVUFBVTtJQUNILGFBQWEsQ0FBQyxJQUE0QixFQUFFLFFBQWdCLEVBQUUsT0FBd0I7UUFDM0YsT0FBTyxJQUFJLE9BQU8sQ0FBTyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtZQUMzQyxNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsT0FBTyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsR0FBVSxFQUFFLEVBQUU7Z0JBQ2hGLElBQUksR0FBRyxFQUFFO29CQUNQLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztpQkFDYjtxQkFBTTtvQkFDTCxPQUFPLEVBQUUsQ0FBQztpQkFDWDtZQUNILENBQUMsQ0FBQyxDQUFDO1lBRUgsS0FBSyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUNyQixLQUFLLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDZCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTSxLQUFLLENBQUMsYUFBYTtRQUN4QixNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3RDLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVELGFBQWE7SUFDYixzQkFBc0I7UUFDcEIsT0FBTyxPQUFPLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQ3JDLENBQUM7Q0FDRiJ9

package/dist_ts/index.d.ts

@@ -1 +1 @@
-export * from './smartarchive.classes.smartarchive.js';
+export * from './classes.smartarchive.js';

package/dist_ts/index.js

@@ -1,2 +1,2 @@
-export * from './smartarchive.classes.smartarchive.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdDQUF3QyxDQUFDIn0=
+export * from './classes.smartarchive.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDIn0=

package/dist_ts/paths.d.ts

@@ -0,0 +1,2 @@
+export declare const packageDir: string;
+export declare const nogitDir: string;

package/dist_ts/paths.js

@@ -0,0 +1,4 @@
+import * as plugins from './plugins.js';
+export const packageDir = plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), '../');
+export const nogitDir = plugins.path.join(packageDir, './.nogit');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4QyxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQ3pDLE9BQU8sQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLHdCQUF3QixDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQy9ELEtBQUssQ0FDTixDQUFDO0FBQ0YsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQyJ9

package/dist_ts/plugins.d.ts

@@ -0,0 +1,17 @@
+import * as path from 'path';
+import * as stream from 'stream';
+export { path, stream };
+import * as smartfile from '@push.rocks/smartfile';
+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, smartpath, smartpromise, smartrequest, smartunique, smartstream, smartrx, smarturl };
+import * as fileType from 'file-type';
+import * as fflate from 'fflate';
+import tarStream from 'tar-stream';
+import unbzip2Stream from 'unbzip2-stream';
+export { fileType, fflate, tarStream, unbzip2Stream };

package/dist_ts/plugins.js

@@ -0,0 +1,21 @@
+// node native scope
+import * as path from 'path';
+import * as stream from 'stream';
+export { path, stream };
+// @pushrocks scope
+import * as smartfile from '@push.rocks/smartfile';
+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, 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';
+import unbzip2Stream from 'unbzip2-stream';
+export { fileType, fflate, tarStream, unbzip2Stream };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBRWpDLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLENBQUM7QUFFeEIsbUJBQW1CO0FBQ25CLE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUVqRCxPQUFPLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBRSxXQUFXLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxDQUFDO0FBRXpHLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssUUFBUSxNQUFNLFdBQVcsQ0FBQztBQUN0QyxPQUFPLEtBQUssTUFBTSxNQUFNLFFBQVEsQ0FBQztBQUNqQyxPQUFPLFNBQVMsTUFBTSxZQUFZLENBQUM7QUFDbkMsT0FBTyxhQUFhLE1BQU0sZ0JBQWdCLENBQUM7QUFFM0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLGFBQWEsRUFBRSxDQUFDIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartarchive",
-  "version": "3.0.7",
+  "version": "4.0.0",
   "description": "work with archives",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
@@ -21,24 +21,26 @@
   },
   "homepage": "https://github.com/pushrocks/smartarchive#readme",
   "dependencies": {
-    "@push.rocks/smartfile": "^10.0.28",
+    "@push.rocks/smartfile": "^11.0.0",
     "@push.rocks/smartpath": "^5.0.11",
     "@push.rocks/smartpromise": "^4.0.3",
-    "@push.rocks/smartrequest": "^2.0.18",
-    "@push.rocks/smartrx": "^3.0.6",
-    "@push.rocks/smartstream": "^2.0.4",
-    "@push.rocks/smartunique": "^3.0.3",
-    "@types/gunzip-maybe": "^1.4.0",
-    "@types/tar-stream": "^2.2.2",
-    "gunzip-maybe": "^1.4.2",
-    "tar": "^6.1.15",
-    "tar-stream": "^3.1.6"
+    "@push.rocks/smartrequest": "^2.0.20",
+    "@push.rocks/smartrx": "^3.0.7",
+    "@push.rocks/smartstream": "^3.0.7",
+    "@push.rocks/smartunique": "^3.0.6",
+    "@push.rocks/smarturl": "^3.0.7",
+    "@types/tar-stream": "^3.1.2",
+    "@types/unbzip2-stream": "^1.4.2",
+    "fflate": "^0.8.1",
+    "file-type": "^18.6.0",
+    "tar-stream": "^3.1.6",
+    "unbzip2-stream": "^1.4.3"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.66",
-    "@gitzone/tsrun": "^1.2.44",
-    "@gitzone/tstest": "^1.0.77",
-    "@push.rocks/tapbundle": "^5.0.12"
+    "@git.zone/tsbuild": "^2.1.66",
+    "@git.zone/tsrun": "^1.2.44",
+    "@git.zone/tstest": "^1.0.77",
+    "@push.rocks/tapbundle": "^5.0.15"
   },
   "private": false,
   "files": [

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartarchive',
-  version: '3.0.7',
+  version: '4.0.0',
   description: 'work with archives'
 }

package/ts/classes.archiveanalyzer.ts

@@ -0,0 +1,74 @@
+import type { SmartArchive } from './classes.smartarchive.js';
+import * as plugins from './plugins.js';
+
+export interface IAnalyzedResult {
+  fileType: plugins.fileType.FileTypeResult;
+  isArchive: boolean;
+  resultStream: plugins.smartstream.PassThrough;
+  decompressionStream: plugins.stream.Transform | plugins.stream.Duplex | plugins.tarStream.Extract;
+}
+
+export class ArchiveAnalyzer {
+  smartArchiveRef: SmartArchive;
+
+  constructor(smartArchiveRefArg: SmartArchive) {
+    this.smartArchiveRef = smartArchiveRefArg;
+  }
+
+  private async mimeTypeIsArchive(mimeType: string): Promise<boolean> {
+    const archiveMimeTypes: Set<string> = new Set([
+      'application/zip',
+      'application/x-rar-compressed',
+      'application/x-tar',
+      'application/gzip',
+      'application/x-7z-compressed',
+      'application/x-bzip2',
+      // Add other archive mime types here
+    ]);
+  
+    return archiveMimeTypes.has(mimeType);
+  }
+
+
+  private getDecompressionStream(
+    mimeTypeArg: plugins.fileType.FileTypeResult['mime']
+  ): plugins.stream.Transform | plugins.stream.Duplex | plugins.tarStream.Extract {
+    switch (mimeTypeArg) {
+      case 'application/gzip':
+        return this.smartArchiveRef.gzipTools.getDecompressionStream();
+      case 'application/x-bzip2':
+        return this.smartArchiveRef.bzip2Tools.getDecompressionStream(); // replace with your own bzip2 decompression stream
+      case 'application/x-tar':
+        return this.smartArchiveRef.tarTools.getDecompressionStream(); // replace with your own tar decompression stream
+      default:
+        // Handle unsupported formats or no decompression needed
+        return new plugins.smartstream.PassThrough();
+    }
+  }
+
+  public getAnalyzedStream() {
+    let firstRun = true;
+    const resultStream = new plugins.smartstream.PassThrough();
+    const analyzerstream = new plugins.smartstream.SmartDuplex<Buffer, IAnalyzedResult>({
+      readableObjectMode: true,
+      writeAndTransformFunction: async (chunkArg: Buffer, streamtools) => {
+        const fileType = await plugins.fileType.fileTypeFromBuffer(chunkArg);
+        const decompressionStream = this.getDecompressionStream(fileType.mime as any);
+        resultStream.push(chunkArg);
+        if (firstRun) {
+          firstRun = false;
+          const result: IAnalyzedResult = {
+            fileType,
+            isArchive: await this.mimeTypeIsArchive(fileType.mime),
+            resultStream,
+            decompressionStream,
+          };
+          streamtools.push(result);
+          streamtools.push(null);
+          return null;
+        }
+      },
+    });
+    return analyzerstream;
+  }
+}

package/ts/classes.bzip2tools.ts

@@ -0,0 +1,45 @@
+import type { SmartArchive } from './classes.smartarchive.js';
+import * as plugins from './plugins.js';
+
+export class DecompressBzip2Transform extends plugins.stream.Transform {
+  private bzip2Decompressor: plugins.stream.Transform;
+
+  constructor() {
+    super();
+    // Initialize the bzip2 decompressor once here
+    this.bzip2Decompressor = plugins.unbzip2Stream();
+    this.bzip2Decompressor.on('data', (data: Buffer) => {
+      // When data is decompressed, push it to the stream
+      this.push(data);
+    });
+    this.bzip2Decompressor.on('error', (err) => {
+      // If an error occurs, emit it on this stream
+      this.emit('error', err);
+    });
+  }
+
+  _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback) {
+    // Pass the chunk directly to the decompressor
+    // The decompressor will handle the state across chunks
+    this.bzip2Decompressor.write(chunk);
+    callback();
+  }
+
+  _flush(callback: plugins.stream.TransformCallback) {
+    // When the stream is ending, end the decompressor stream as well
+    this.bzip2Decompressor.end();
+    callback();
+  }
+}
+
+export class Bzip2Tools {
+  smartArchiveRef: SmartArchive;
+
+  constructor(smartArchiveRefArg: SmartArchive) {
+    this.smartArchiveRef = smartArchiveRefArg;
+  }
+
+  getDecompressionStream() {
+    return new DecompressBzip2Transform();
+  }
+}

package/ts/classes.gziptools.ts

@@ -0,0 +1,59 @@
+import type { SmartArchive } from './classes.smartarchive.js';
+import * as plugins from './plugins.js'
+
+// This class wraps fflate's gunzip in a Node.js Transform stream
+export class CompressGunzipTransform extends plugins.stream.Transform {
+  constructor() {
+    super();
+  }
+
+  _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback) {
+    plugins.fflate.gunzip(chunk, (err, decompressed) => {
+      if (err) {
+        callback(err);
+      } else {
+        this.push(decompressed);
+        callback();
+      }
+    });
+  }
+}
+
+// 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 {
+  constructor() {
+    super();
+  }
+
+  _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback) {
+    // Use fflate's gunzip function to decompress the chunk
+    plugins.fflate.gunzip(chunk, (err, decompressed) => {
+      if (err) {
+        // If an error occurs during decompression, pass the error to the callback
+        callback(err);
+      } else {
+        // If decompression is successful, push the decompressed data into the stream
+        this.push(decompressed);
+        callback();
+      }
+    });
+  }
+}
+
+
+export class GzipTools {
+  smartArchiveRef: SmartArchive;
+
+  constructor(smartArchiveRefArg: SmartArchive) {
+    this.smartArchiveRef = smartArchiveRefArg;
+  }
+
+  public getCompressionStream() {
+    return new CompressGunzipTransform();
+  }
+
+  public getDecompressionStream() {
+    return new DecompressGunzipTransform();
+  }
+}

package/ts/classes.smartarchive.ts

@@ -0,0 +1,120 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+
+import { GzipTools } from './classes.gziptools.js';
+import { TarTools } from './classes.tartools.js';
+import { Bzip2Tools } from './classes.bzip2tools.js';
+
+import { ArchiveAnalyzer, type IAnalyzedResult } from './classes.archiveanalyzer.js';
+
+import type { from } from '@push.rocks/smartrx/dist_ts/smartrx.plugins.rxjs.js';
+
+export class SmartArchive {
+  // STATIC
+  public static async fromArchiveUrl(urlArg: string): Promise<SmartArchive> {
+    const smartArchiveInstance = new SmartArchive();
+    smartArchiveInstance.sourceUrl = urlArg;
+    return smartArchiveInstance;
+  }
+
+  public static async fromArchiveFile(filePathArg: string): Promise<SmartArchive> {
+    const smartArchiveInstance = new SmartArchive();
+    smartArchiveInstance.sourceFilePath = filePathArg;
+    return smartArchiveInstance;
+  }
+
+  public static async fromArchiveStream(
+    streamArg: plugins.stream.Readable | plugins.stream.Duplex | plugins.stream.Transform
+  ): Promise<SmartArchive> {
+    const smartArchiveInstance = new SmartArchive();
+    smartArchiveInstance.sourceStream = streamArg;
+    return smartArchiveInstance;
+  }
+
+  // INSTANCE
+  public tarTools = new TarTools(this);
+  public gzipTools = new GzipTools(this);
+  public bzip2Tools = new Bzip2Tools(this);
+  public archiveAnalyzer = new ArchiveAnalyzer(this);
+
+  public sourceUrl: string;
+  public sourceFilePath: string;
+  public sourceStream: plugins.stream.Readable | plugins.stream.Duplex | plugins.stream.Transform;
+
+  public archiveName: string;
+  public singleFileMode: boolean = false;
+
+  public addedDirectories: string[] = [];
+  public addedFiles: (plugins.smartfile.SmartFile | plugins.smartfile.StreamFile)[] = [];
+  public addedUrls: string[] = [];
+
+  constructor() {}
+
+  /**
+   * gets the original archive stream
+   */
+  public async getArchiveStream() {
+    if (this.sourceStream) {
+      return this.sourceStream;
+    }
+    if (this.sourceUrl) {
+      const urlStream = await plugins.smartrequest.getStream(this.sourceUrl);
+      return urlStream;
+    }
+    if (this.sourceFilePath) {
+      const fileStream = plugins.smartfile.fs.toReadStream(this.sourceFilePath);
+      return fileStream;
+    }
+  }
+
+  public async exportToTarGzStream() {
+    const tarPackStream = await this.tarTools.getPackStream();
+    const gzipStream = await this.gzipTools.getCompressionStream();
+    // const archiveStream = tarPackStream.pipe(gzipStream);
+    // return archiveStream;
+  }
+
+  public async exportToFs(targetDir: string): Promise<void> {}
+
+  public async exportToStreamOfStreamFiles() {
+    const streamFileIntake = new plugins.smartstream.StreamIntake<plugins.smartfile.StreamFile>({
+      objectMode: true,
+    });
+    const archiveStream = await this.getArchiveStream();
+    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<IAnalyzedResult, any>(
+        async (analyzedResultChunk) => {
+          if (analyzedResultChunk.fileType.mime === 'application/x-tar') {
+            (analyzedResultChunk.decompressionStream as plugins.tarStream.Extract).on(
+              'entry',
+              async (header, stream, next) => {
+                const streamfile = plugins.smartfile.StreamFile.fromStream(stream, header.name);
+                streamFileIntake.push(streamfile);
+                stream.on('end', function () {
+                  next(); // ready for next entry
+                });
+              }
+            );
+            analyzedResultChunk.resultStream.pipe(analyzedResultChunk.decompressionStream);
+          } else if (analyzedResultChunk.isArchive && analyzedResultChunk.decompressionStream) {
+            analyzedResultChunk.resultStream
+              .pipe(analyzedResultChunk.decompressionStream)
+              .pipe(createAnalyzedStream())
+              .pipe(createUnpackStream());
+          } else {
+            const streamFile = plugins.smartfile.StreamFile.fromStream(
+              analyzedResultChunk.resultStream,
+              analyzedResultChunk.fileType.ext
+            );
+            streamFileIntake.push(streamFile);
+          }
+        }
+      );
+
+    archiveStream.pipe(createAnalyzedStream()).pipe(createUnpackStream());
+    return streamFileIntake;
+  }
+}

package/ts/classes.tartools.ts

@@ -0,0 +1,36 @@
+import type { SmartArchive } from './classes.smartarchive.js';
+import * as plugins from './plugins.js';
+
+export class TarTools {
+  smartArchiveRef: SmartArchive;
+
+  constructor(smartArchiveRefArg: SmartArchive) {
+    this.smartArchiveRef = smartArchiveRefArg;
+  }
+  
+  // packing
+  public addFileToPack(pack: plugins.tarStream.Pack, fileName: string, content: string | Buffer) {
+    return new Promise<void>((resolve, reject) => {
+      const entry = pack.entry({ name: fileName, size: content.length }, (err: Error) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+
+      entry.write(content);
+      entry.end();
+    });
+  }
+
+  public async getPackStream() {
+    const pack = plugins.tarStream.pack();
+    return pack;
+  }
+
+  // extracting
+  getDecompressionStream() {
+    return plugins.tarStream.extract();
+  }
+}

package/ts/index.ts

@@ -1 +1 @@
-export * from './smartarchive.classes.smartarchive.js';
+export * from './classes.smartarchive.js';

package/ts/{smartarchive.paths.ts → paths.ts}

@@ -1,4 +1,4 @@
-import * as plugins from './smartarchive.plugins.js';
+import * as plugins from './plugins.js';
 
 export const packageDir = plugins.path.join(
   plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),

package/ts/{smartarchive.plugins.ts → plugins.ts}

@@ -1,7 +1,8 @@
 // node native scope
 import * as path from 'path';
+import * as stream from 'stream';
 
-export { path };
+export { path, stream };
 
 // @pushrocks scope
 import * as smartfile from '@push.rocks/smartfile';
@@ -11,14 +12,14 @@ 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, smartpath, smartpromise, smartrequest, smartunique, smartstream, smartrx };
+export { smartfile, smartpath, smartpromise, smartrequest, smartunique, smartstream, smartrx, smarturl };
 
 // third party scope
-import gunzipMaybe from 'gunzip-maybe';
-
-// @ts-ignore
-import tar from 'tar';
+import * as fileType from 'file-type';
+import * as fflate from 'fflate';
 import tarStream from 'tar-stream';
+import unbzip2Stream from 'unbzip2-stream';
 
-export { gunzipMaybe, tar, tarStream };
+export { fileType, fflate, tarStream, unbzip2Stream };

package/ts/smartarchive.classes.smartarchive.ts

@@ -1,133 +0,0 @@
-import * as plugins from './smartarchive.plugins.js';
-import * as paths from './smartarchive.paths.js';
-
-export class SmartArchive {
-  constructor() {}
-
-  /**
-   * extracts an archive from a given url
-   */
-  public async extractArchiveFromUrlToFs(urlArg: string, targetDir: string) {
-    const parsedPath = plugins.path.parse(urlArg);
-    const uniqueFileName = plugins.smartunique.uni() + parsedPath.ext;
-    plugins.smartfile.fs.ensureDir(paths.nogitDir); // TODO: totally remove caching needs
-    const downloadPath = plugins.path.join(paths.nogitDir, uniqueFileName);
-    const downloadedArchive = (await plugins.smartrequest.getBinary(urlArg)).body;
-    await plugins.smartfile.memory.toFs(downloadedArchive, downloadPath);
-    await this.extractArchiveFromFilePathToFs(downloadPath, targetDir);
-    await plugins.smartfile.fs.remove(downloadPath);
-  }
-
-  /**
-   * extracts an archive from a given filePath on disk
-   * @param filePathArg
-   * @param targetDirArg
-   */
-  public async extractArchiveFromFilePathToFs(filePathArg: string, targetDirArg: string) {
-    console.log(`extracting ${filePathArg}`);
-    const done = plugins.smartpromise.defer();
-    filePathArg = plugins.smartpath.transform.makeAbsolute(filePathArg);
-    targetDirArg = plugins.smartpath.transform.makeAbsolute(targetDirArg);
-    const readableStream = plugins.smartfile.fsStream.createReadStream(filePathArg);
-    const extractPipeStop = plugins.tarStream.extract();
-    extractPipeStop.on('entry', async (header, stream, next) => {
-      const targetFilePath = plugins.path.join(targetDirArg, header.name);
-      const parsedPath = plugins.path.parse(targetFilePath);
-      await plugins.smartfile.fs.ensureDir(parsedPath.dir);
-      const writeStream = plugins.smartfile.fsStream.createWriteStream(targetFilePath);
-      stream.pipe(writeStream);
-      stream.on('end', () => {
-        console.log(`extracted ${header.name}`);
-        next();
-      });
-      stream.resume();
-    });
-    extractPipeStop.on('finish', () => {
-      console.log(`Sucessfully extracted ${filePathArg}!`);
-      done.resolve();
-    });
-
-    // lets run the stream
-    readableStream.pipe(plugins.gunzipMaybe()).pipe(extractPipeStop);
-    await done.promise;
-  }
-
-  /**
-   * extracts to Observable
-   * where the Observable is emitting smartfiles
-   */
-  public async extractArchiveFromBufferToObservable(
-    bufferArg: Buffer
-  ): Promise<plugins.smartrx.rxjs.ReplaySubject<plugins.smartfile.Smartfile>> {
-    const { intake, replaySubject } = this.extractArchiveWithIntakeAndReplaySubject();
-    intake.pushData(bufferArg);
-    intake.signalEnd();
-    return replaySubject;
-  }
-
-  extractArchiveWithIntakeAndReplaySubject() {
-    const intake = new plugins.smartstream.StreamIntake<Buffer>();
-    const replaySubject = new plugins.smartrx.rxjs.ReplaySubject<plugins.smartfile.Smartfile>();
-    const readableStream = intake.getReadableStream();
-    const extractPipeStop = plugins.tarStream.extract();
-    extractPipeStop.on('entry', (header, stream, next) => {
-      let fileBuffer: Buffer;
-      stream.on('data', (chunkArg) => {
-        if (!fileBuffer) {
-          fileBuffer = chunkArg;
-        } else {
-          fileBuffer = Buffer.concat([fileBuffer, chunkArg]);
-        }
-      });
-      stream.on('end', () => {
-        replaySubject.next(
-          new plugins.smartfile.Smartfile({
-            base: null, // no working directory for this one
-            contentBuffer: fileBuffer,
-            path: `${header.name}`,
-          })
-        );
-        next();
-      });
-      stream.resume();
-    });
-    extractPipeStop.on('finish', () => {
-      replaySubject.complete();
-    });
-    // lets run the stream
-    readableStream.pipe(plugins.gunzipMaybe()).pipe(extractPipeStop);
-    return {
-      intake,
-      replaySubject,
-    };
-  }
-
-  /**
-   * extracts to Observable
-   */
-  public async extractArchiveFromUrlToObservable(
-    urlArg: string
-  ): Promise<plugins.smartrx.rxjs.ReplaySubject<plugins.smartfile.Smartfile>> {
-    const response = await plugins.smartrequest.getBinary(urlArg);
-    const replaySubject = this.extractArchiveFromBufferToObservable(response.body);
-    return replaySubject;
-  }
-
-  // TODO
-  public async extractArchiveFromUrlToStream() {}
-
-  // TODO
-  public async extractArchiveFromFilePathToStream() {}
-
-  // TODO
-  public async extractArchiveFromStreamToStream() {}
-
-  // TODO
-  public async packFromStreamToStream() {}
-
-  // TODO
-  public async packFromDirPathToStream() {}
-
-  // TODO
-  public async packFromDirPathToFs() {}
-}