fix(core): update

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartarchive',
-  version: '4.0.24',
+  version: '4.0.25',
   description: 'A library for working with archive files, providing utilities for compressing and decompressing data.'
 }

ts/classes.tartools.ts

@@ -2,28 +2,116 @@ import type { SmartArchive } from './classes.smartarchive.js';
 import * as plugins from './plugins.js';
 
 export class TarTools {
+  // INSTANCE
   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();
+  // packing
+  public async addFileToPack(
+    pack: plugins.tarStream.Pack,
+    optionsArg: {
+      fileName?: string;
+      content?:
+        | string
+        | Buffer
+        | plugins.smartstream.stream.Readable
+        | plugins.smartfile.SmartFile
+        | plugins.smartfile.StreamFile;
+      byteLength?: number;
+      filePath?: string;
+    }
+  ): Promise<void> {
+    return new Promise<void>(async (resolve, reject) => {
+      let fileName =
+        optionsArg.fileName || optionsArg.content instanceof plugins.smartfile.SmartFile
+          ? (optionsArg.content as plugins.smartfile.SmartFile).relative
+          : null || optionsArg.content instanceof plugins.smartfile.StreamFile
+          ? (optionsArg.content as plugins.smartfile.StreamFile).relativeFilePath
+          : null || optionsArg.filePath;
+
+      /**
+       * contentByteLength is used to set the size of the entry in the tar file
+       */
+      let contentByteLength: number;
+      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(); // 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) {
+        console.warn(
+          '@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);
+        contentByteLength = fileStat.size;
+      }
+
+      const entry = pack.entry(
+        {
+          name: fileName,
+          ...(contentByteLength
+            ? {
+                size: contentByteLength,
+              }
+            : null),
+        },
+        (err: Error) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        }
+      );
+
+      let content: plugins.smartstream.stream.Readable;
+      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));
+      } else if (optionsArg.content instanceof plugins.smartfile.SmartFile) {
+        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) {
+        content = optionsArg.content;
+      }
+
+      content.pipe(entry);
+      entry.on('end', () => {
+        resolve();
+      });
     });
   }
 
+  /**
+   * packs a directory from disk into a tar stream
+   * @param directoryPath
+   */
+  public async packDirectory(directoryPath: string) {
+    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);
+      const fileStat = await plugins.smartfile.fs.stat(absolutePath);
+      await this.addFileToPack(pack, {
+        byteLength: fileStat.size,
+        filePath: filePath,
+        fileName: filePath,
+        content: plugins.smartfile.fsStream.createReadStream(absolutePath),
+      });
+    }
+  }
+
   public async getPackStream() {
     const pack = plugins.tarStream.pack();
     return pack;

ts/classes.ziptools.ts

@@ -5,7 +5,7 @@ class DecompressZipTransform extends plugins.smartstream.SmartDuplex<ArrayBuffer
   private streamtools: plugins.smartstream.IStreamTools;
   private unzipper = new plugins.fflate.Unzip(async (fileArg) => {
     let resultBuffer: Buffer;
-    fileArg.ondata = async (dataArg, dat, final) => {
+    fileArg.ondata = async (flateError, dat, final) => {
       resultBuffer? resultBuffer = Buffer.concat([resultBuffer, Buffer.from(dat)])
         : resultBuffer = Buffer.from(dat);
       if (final) {