@push.rocks/smartarchive 4.0.39 → 4.2.0

package/ts/classes.archiveanalyzer.ts

@@ -5,7 +5,10 @@ export interface IAnalyzedResult {
   fileType: plugins.fileType.FileTypeResult;
   isArchive: boolean;
   resultStream: plugins.smartstream.SmartDuplex;
-  decompressionStream: plugins.stream.Transform | plugins.stream.Duplex | plugins.tarStream.Extract;
+  decompressionStream:
+    | plugins.stream.Transform
+    | plugins.stream.Duplex
+    | plugins.tarStream.Extract;
 }
 
 export class ArchiveAnalyzer {
@@ -25,14 +28,15 @@ export class ArchiveAnalyzer {
       'application/x-bzip2',
       // Add other archive mime types here
     ]);
-  
+
     return archiveMimeTypes.has(mimeType);
   }
 
-
   private async getDecompressionStream(
-    mimeTypeArg: plugins.fileType.FileTypeResult['mime']
-  ):  Promise<plugins.stream.Transform | plugins.stream.Duplex | plugins.tarStream.Extract> {
+    mimeTypeArg: plugins.fileType.FileTypeResult['mime'],
+  ): Promise<
+    plugins.stream.Transform | plugins.stream.Duplex | plugins.tarStream.Extract
+  > {
     switch (mimeTypeArg) {
       case 'application/gzip':
         return this.smartArchiveRef.gzipTools.getDecompressionStream();
@@ -51,13 +55,18 @@ export class ArchiveAnalyzer {
   public getAnalyzedStream() {
     let firstRun = true;
     const resultStream = plugins.smartstream.createPassThrough();
-    const analyzerstream = new plugins.smartstream.SmartDuplex<Buffer, IAnalyzedResult>({
+    const analyzerstream = new plugins.smartstream.SmartDuplex<
+      Buffer,
+      IAnalyzedResult
+    >({
       readableObjectMode: true,
       writeFunction: async (chunkArg: Buffer, streamtools) => {
         if (firstRun) {
           firstRun = false;
           const fileType = await plugins.fileType.fileTypeFromBuffer(chunkArg);
-          const decompressionStream = await this.getDecompressionStream(fileType?.mime as any);
+          const decompressionStream = await this.getDecompressionStream(
+            fileType?.mime as any,
+          );
           /**
            * analyzed stream emits once with this object
            */
@@ -75,7 +84,7 @@ export class ArchiveAnalyzer {
       finalFunction: async (tools) => {
         resultStream.push(null);
         return null;
-      }
+      },
     });
     return analyzerstream;
   }

package/ts/classes.bzip2tools.ts

@@ -13,4 +13,4 @@ export class Bzip2Tools {
   getDecompressionStream() {
     return unbzip2Stream();
   }
-}
+}

package/ts/classes.gziptools.ts

@@ -1,5 +1,5 @@
 import type { SmartArchive } from './classes.smartarchive.js';
-import * as plugins from './plugins.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 {
@@ -7,7 +7,11 @@ export class CompressGunzipTransform extends plugins.stream.Transform {
     super();
   }
 
-  _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback) {
+  _transform(
+    chunk: Buffer,
+    encoding: BufferEncoding,
+    callback: plugins.stream.TransformCallback,
+  ) {
     plugins.fflate.gunzip(chunk, (err, decompressed) => {
       if (err) {
         callback(err);
@@ -26,7 +30,11 @@ export class DecompressGunzipTransform extends plugins.stream.Transform {
     super();
   }
 
-  _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback) {
+  _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) {
@@ -41,10 +49,8 @@ export class DecompressGunzipTransform extends plugins.stream.Transform {
   }
 }
 
-
 export class GzipTools {
-  constructor() {
-  }
+  constructor() {}
 
   public getCompressionStream() {
     return new CompressGunzipTransform();

package/ts/classes.smartarchive.ts

@@ -6,7 +6,10 @@ import { GzipTools } from './classes.gziptools.js';
 import { TarTools } from './classes.tartools.js';
 import { ZipTools } from './classes.ziptools.js';
 
-import { ArchiveAnalyzer, type IAnalyzedResult } from './classes.archiveanalyzer.js';
+import {
+  ArchiveAnalyzer,
+  type IAnalyzedResult,
+} from './classes.archiveanalyzer.js';
 
 import type { from } from '@push.rocks/smartrx/dist_ts/smartrx.plugins.rxjs.js';
 
@@ -18,14 +21,19 @@ export class SmartArchive {
     return smartArchiveInstance;
   }
 
-  public static async fromArchiveFile(filePathArg: string): Promise<SmartArchive> {
+  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
+    streamArg:
+      | plugins.stream.Readable
+      | plugins.stream.Duplex
+      | plugins.stream.Transform,
   ): Promise<SmartArchive> {
     const smartArchiveInstance = new SmartArchive();
     smartArchiveInstance.sourceStream = streamArg;
@@ -41,13 +49,19 @@ export class SmartArchive {
 
   public sourceUrl: string;
   public sourceFilePath: string;
-  public sourceStream: plugins.stream.Readable | plugins.stream.Duplex | plugins.stream.Transform;
+  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 addedFiles: (
+    | plugins.smartfile.SmartFile
+    | plugins.smartfile.StreamFile
+  )[] = [];
   public addedUrls: string[] = [];
 
   constructor() {}
@@ -60,7 +74,12 @@ export class SmartArchive {
       return this.sourceStream;
     }
     if (this.sourceUrl) {
-      const urlStream = await plugins.smartrequest.getStream(this.sourceUrl);
+      const response = await plugins.smartrequest.SmartRequest.create()
+        .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;
     }
     if (this.sourceFilePath) {
@@ -76,24 +95,35 @@ export class SmartArchive {
     // return archiveStream;
   }
 
-  public async exportToFs(targetDir: string, fileNameArg?: string): Promise<void> {
+  public async exportToFs(
+    targetDir: string,
+    fileNameArg?: string,
+  ): Promise<void> {
     const done = plugins.smartpromise.defer<void>();
     const streamFileStream = await this.exportToStreamOfStreamFiles();
     streamFileStream.pipe(
       new plugins.smartstream.SmartDuplex({
         objectMode: true,
-        writeFunction: async (streamFileArg: plugins.smartfile.StreamFile, streamtools) => {
+        writeFunction: async (
+          streamFileArg: plugins.smartfile.StreamFile,
+          streamtools,
+        ) => {
           const done = plugins.smartpromise.defer<void>();
-          console.log(streamFileArg.relativeFilePath ? streamFileArg.relativeFilePath : 'no relative path');
+          console.log(
+            streamFileArg.relativeFilePath
+              ? streamFileArg.relativeFilePath
+              : 'no relative path',
+          );
           const streamFile = streamFileArg;
           const readStream = await streamFile.createReadStream();
           await plugins.smartfile.fs.ensureDir(targetDir);
           const writePath = plugins.path.join(
             targetDir,
-            streamFile.relativeFilePath || fileNameArg
+            streamFile.relativeFilePath || fileNameArg,
           );
           await plugins.smartfile.fs.ensureDir(plugins.path.dirname(writePath));
-          const writeStream = plugins.smartfile.fsStream.createWriteStream(writePath);
+          const writeStream =
+            plugins.smartfile.fsStream.createWriteStream(writePath);
           readStream.pipe(writeStream);
           writeStream.on('finish', () => {
             done.resolve();
@@ -103,15 +133,16 @@ export class SmartArchive {
         finalFunction: async () => {
           done.resolve();
         },
-      })
+      }),
     );
     return done.promise;
   }
 
   public async exportToStreamOfStreamFiles() {
-    const streamFileIntake = new plugins.smartstream.StreamIntake<plugins.smartfile.StreamFile>({
-      objectMode: true,
-    });
+    const streamFileIntake =
+      new plugins.smartstream.StreamIntake<plugins.smartfile.StreamFile>({
+        objectMode: true,
+      });
     const archiveStream = await this.getArchiveStream();
     const createAnalyzedStream = () => this.archiveAnalyzer.getAnalyzedStream();
 
@@ -120,15 +151,21 @@ export class SmartArchive {
       plugins.smartstream.createTransformFunction<IAnalyzedResult, any>(
         async (analyzedResultChunk) => {
           if (analyzedResultChunk.fileType?.mime === 'application/x-tar') {
-            const tarStream = analyzedResultChunk.decompressionStream as plugins.tarStream.Extract;
+            const tarStream =
+              analyzedResultChunk.decompressionStream as plugins.tarStream.Extract;
             tarStream.on('entry', async (header, stream, next) => {
               if (header.type === 'directory') {
-                console.log(`tar stream directory: ${header.name} ... skipping!`);
+                console.log(
+                  `tar stream directory: ${header.name} ... skipping!`,
+                );
                 next();
                 return;
               }
               console.log(`tar stream file: ${header.name}`);
-              const streamfile = plugins.smartfile.StreamFile.fromStream(stream, header.name);
+              const streamfile = plugins.smartfile.StreamFile.fromStream(
+                stream,
+                header.name,
+              );
               streamFileIntake.push(streamfile);
               stream.on('end', function () {
                 next(); // ready for next entry
@@ -138,20 +175,30 @@ export class SmartArchive {
               console.log('finished');
               streamFileIntake.signalEnd();
             });
-            analyzedResultChunk.resultStream.pipe(analyzedResultChunk.decompressionStream);
+            analyzedResultChunk.resultStream.pipe(
+              analyzedResultChunk.decompressionStream,
+            );
           } else if (analyzedResultChunk.fileType?.mime === 'application/zip') {
             analyzedResultChunk.resultStream
               .pipe(analyzedResultChunk.decompressionStream)
-              .pipe(new plugins.smartstream.SmartDuplex({
-                objectMode: true,
-                writeFunction: async (streamFileArg: plugins.smartfile.StreamFile, streamtools) => {
-                  streamFileIntake.push(streamFileArg);
-                },
-                finalFunction: async () => {
-                  streamFileIntake.signalEnd();
-                }
-              }));
-          } else if (analyzedResultChunk.isArchive && analyzedResultChunk.decompressionStream) {
+              .pipe(
+                new plugins.smartstream.SmartDuplex({
+                  objectMode: true,
+                  writeFunction: async (
+                    streamFileArg: plugins.smartfile.StreamFile,
+                    streamtools,
+                  ) => {
+                    streamFileIntake.push(streamFileArg);
+                  },
+                  finalFunction: async () => {
+                    streamFileIntake.signalEnd();
+                  },
+                }),
+              );
+          } else if (
+            analyzedResultChunk.isArchive &&
+            analyzedResultChunk.decompressionStream
+          ) {
             analyzedResultChunk.resultStream
               .pipe(analyzedResultChunk.decompressionStream)
               .pipe(createAnalyzedStream())
@@ -159,7 +206,7 @@ export class SmartArchive {
           } else {
             const streamFile = plugins.smartfile.StreamFile.fromStream(
               analyzedResultChunk.resultStream,
-              analyzedResultChunk.fileType?.ext
+              analyzedResultChunk.fileType?.ext,
             );
             streamFileIntake.push(streamFile);
             streamFileIntake.signalEnd();
@@ -167,7 +214,7 @@ export class SmartArchive {
         },
         {
           objectMode: true,
-        }
+        },
       );
 
     archiveStream.pipe(createAnalyzedStream()).pipe(createUnpackStream());

package/ts/classes.tartools.ts

@@ -18,7 +18,7 @@ export class TarTools {
         | plugins.smartfile.StreamFile;
       byteLength?: number;
       filePath?: string;
-    }
+    },
   ): Promise<void> {
     return new Promise<void>(async (resolve, reject) => {
       let fileName: string | null = null;
@@ -28,7 +28,8 @@ export class TarTools {
       } else if (optionsArg.content instanceof plugins.smartfile.SmartFile) {
         fileName = (optionsArg.content as plugins.smartfile.SmartFile).relative;
       } else if (optionsArg.content instanceof plugins.smartfile.StreamFile) {
-        fileName = (optionsArg.content as plugins.smartfile.StreamFile).relativeFilePath;
+        fileName = (optionsArg.content as plugins.smartfile.StreamFile)
+          .relativeFilePath;
       } else if (optionsArg.filePath) {
         fileName = optionsArg.filePath;
       }
@@ -47,9 +48,11 @@ export class TarTools {
         contentByteLength = await optionsArg.content.getSize(); // assuming SmartFile has getSize method
       } else if (optionsArg.content instanceof plugins.smartfile.StreamFile) {
         contentByteLength = await optionsArg.content.getSize(); // assuming StreamFile has getSize method
-      } else if (optionsArg.content instanceof plugins.smartstream.stream.Readable) {
+      } else if (
+        optionsArg.content instanceof plugins.smartstream.stream.Readable
+      ) {
         console.warn(
-          '@push.rocks/smartarchive: When streaming, it is recommended to provide byteLength, if known.'
+          '@push.rocks/smartarchive: When streaming, it is recommended to provide byteLength, if known.',
         );
       } else if (optionsArg.filePath) {
         const fileStat = await plugins.smartfile.fs.stat(optionsArg.filePath);
@@ -63,12 +66,18 @@ export class TarTools {
       if (Buffer.isBuffer(optionsArg.content)) {
         content = plugins.smartstream.stream.Readable.from(optionsArg.content);
       } else if (typeof optionsArg.content === 'string') {
-        content = plugins.smartstream.stream.Readable.from(Buffer.from(optionsArg.content));
+        content = plugins.smartstream.stream.Readable.from(
+          Buffer.from(optionsArg.content),
+        );
       } else if (optionsArg.content instanceof plugins.smartfile.SmartFile) {
-        content = plugins.smartstream.stream.Readable.from(optionsArg.content.contents);
+        content = plugins.smartstream.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.smartstream.stream.Readable) {
+      } else if (
+        optionsArg.content instanceof plugins.smartstream.stream.Readable
+      ) {
         content = optionsArg.content;
       }
 
@@ -87,7 +96,7 @@ export class TarTools {
           } else {
             resolve();
           }
-        }
+        },
       );
 
       content.pipe(entry);
@@ -100,7 +109,10 @@ export class TarTools {
    * @param directoryPath
    */
   public async packDirectory(directoryPath: string) {
-    const fileTree = await plugins.smartfile.fs.listFileTree(directoryPath, '**/*');
+    const fileTree = await plugins.smartfile.fs.listFileTree(
+      directoryPath,
+      '**/*',
+    );
     const pack = await this.getPackStream();
     for (const filePath of fileTree) {
       const absolutePath = plugins.path.join(directoryPath, filePath);

package/ts/classes.ziptools.ts

@@ -1,33 +1,39 @@
 import type { SmartArchive } from './classes.smartarchive.js';
 import * as plugins from './plugins.js';
 
-class DecompressZipTransform extends plugins.smartstream.SmartDuplex<ArrayBufferLike> {
+class DecompressZipTransform extends plugins.smartstream
+  .SmartDuplex<ArrayBufferLike> {
   private streamtools: plugins.smartstream.IStreamTools;
   private unzipper = new plugins.fflate.Unzip(async (fileArg) => {
     let resultBuffer: Buffer;
     fileArg.ondata = async (flateError, dat, final) => {
-      resultBuffer? resultBuffer = Buffer.concat([resultBuffer, Buffer.from(dat)])
-        : resultBuffer = Buffer.from(dat);
+      resultBuffer
+        ? (resultBuffer = Buffer.concat([resultBuffer, Buffer.from(dat)]))
+        : (resultBuffer = Buffer.from(dat));
       if (final) {
-        const streamFile = plugins.smartfile.StreamFile.fromBuffer(resultBuffer);
+        const streamFile =
+          plugins.smartfile.StreamFile.fromBuffer(resultBuffer);
         streamFile.relativeFilePath = fileArg.name;
         this.streamtools.push(streamFile);
       }
-    }
+    };
     fileArg.start();
   });
   constructor() {
     super({
       objectMode: true,
-      writeFunction: async (chunkArg: Buffer, streamtoolsArg) => {
-        this.streamtools? null : this.streamtools = streamtoolsArg;
-        this.unzipper.push(chunkArg, false);
+      writeFunction: async (chunkArg, streamtoolsArg) => {
+        this.streamtools ? null : (this.streamtools = streamtoolsArg);
+        this.unzipper.push(
+          Buffer.isBuffer(chunkArg) ? chunkArg : Buffer.from(chunkArg),
+          false,
+        );
       },
       finalFunction: async () => {
         this.unzipper.push(Buffer.from(''), true);
         await plugins.smartdelay.delayFor(0);
         await this.streamtools.push(null);
-      }
+      },
     });
     this.unzipper.register(plugins.fflate.UnzipInflate);
   }
@@ -42,7 +48,11 @@ export class CompressZipTransform extends plugins.stream.Transform {
     this.files = {};
   }
 
-  _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback) {
+  _transform(
+    chunk: Buffer,
+    encoding: BufferEncoding,
+    callback: plugins.stream.TransformCallback,
+  ) {
     // Simple example: storing chunks in memory before finalizing ZIP in _flush
     this.files['file.txt'] = new Uint8Array(chunk);
     callback();
@@ -61,8 +71,7 @@ export class CompressZipTransform extends plugins.stream.Transform {
 }
 
 export class ZipTools {
-  constructor() {
-  }
+  constructor() {}
 
   public getCompressionStream() {
     return new CompressZipTransform();

package/ts/paths.ts

@@ -2,6 +2,6 @@ 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');

package/ts/plugins.ts

@@ -15,7 +15,17 @@ 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 };
+export {
+  smartfile,
+  smartdelay,
+  smartpath,
+  smartpromise,
+  smartrequest,
+  smartunique,
+  smartstream,
+  smartrx,
+  smarturl,
+};
 
 // third party scope
 import * as fileType from 'file-type';