@push.rocks/smartarchive 5.0.0 → 5.0.1

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartarchive',
-    version: '5.0.0',
+    version: '5.0.1',
     description: 'A library for working with archive files, providing utilities for compressing and decompressing data.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwwQkFBMEI7SUFDaEMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHVHQUF1RztDQUNySCxDQUFBIn0=

package/dist_ts/classes.gziptools.d.ts

@@ -40,10 +40,14 @@ export declare class GzipTools {
     decompressSync(data: Buffer): Buffer;
     /**
      * Compress data asynchronously
+     * Note: Uses sync version for Deno compatibility (fflate async uses Web Workers
+     * which have issues in Deno)
      */
     compress(data: Buffer, level?: TCompressionLevel): Promise<Buffer>;
     /**
      * Decompress data asynchronously
+     * Note: Uses sync version for Deno compatibility (fflate async uses Web Workers
+     * which have issues in Deno)
      */
     decompress(data: Buffer): Promise<Buffer>;
 }

package/dist_ts/classes.gziptools.js

@@ -96,30 +96,21 @@ export class GzipTools {
     }
     /**
      * Compress data asynchronously
+     * Note: Uses sync version for Deno compatibility (fflate async uses Web Workers
+     * which have issues in Deno)
      */
     async compress(data, level) {
-        return new Promise((resolve, reject) => {
-            const options = level !== undefined ? { level } : undefined;
-            plugins.fflate.gzip(data, options, (err, result) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(Buffer.from(result));
-            });
-        });
+        // Use sync version wrapped in Promise for cross-runtime compatibility
+        return this.compressSync(data, level);
     }
     /**
      * Decompress data asynchronously
+     * Note: Uses sync version for Deno compatibility (fflate async uses Web Workers
+     * which have issues in Deno)
      */
     async decompress(data) {
-        return new Promise((resolve, reject) => {
-            plugins.fflate.gunzip(data, (err, result) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(Buffer.from(result));
-            });
-        });
+        // Use sync version wrapped in Promise for cross-runtime compatibility
+        return this.decompressSync(data);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.smartarchive.d.ts

@@ -1,117 +1,214 @@
 import * as plugins from './plugins.js';
-import type { IArchiveCreationOptions, IArchiveEntry, IArchiveExtractionOptions, IArchiveEntryInfo, IArchiveInfo } from './interfaces.js';
+import type { IArchiveEntryInfo, IArchiveInfo, TArchiveFormat, TCompressionLevel, TEntryFilter } from './interfaces.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';
 /**
- * Main class for archive manipulation
+ * Main class for archive manipulation with fluent API
  * Supports TAR, ZIP, GZIP, and BZIP2 formats
+ *
+ * @example Extraction from URL
+ * ```typescript
+ * await SmartArchive.create()
+ *   .url('https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz')
+ *   .stripComponents(1)
+ *   .extract('./node_modules/lodash');
+ * ```
+ *
+ * @example Creation with thenable
+ * ```typescript
+ * const archive = await SmartArchive.create()
+ *   .format('tar.gz')
+ *   .compression(9)
+ *   .entry('config.json', JSON.stringify(config))
+ *   .directory('./src');
+ * ```
  */
 export declare class SmartArchive {
     /**
-     * Create SmartArchive from a URL
+     * Create a new SmartArchive instance for fluent configuration
      */
-    static fromUrl(urlArg: string): Promise<SmartArchive>;
+    static create(): SmartArchive;
+    tarTools: TarTools;
+    zipTools: ZipTools;
+    gzipTools: GzipTools;
+    bzip2Tools: Bzip2Tools;
+    archiveAnalyzer: ArchiveAnalyzer;
+    private sourceUrl?;
+    private sourceFilePath?;
+    private sourceStream?;
+    private archiveBuffer?;
+    private creationFormat?;
+    private _compressionLevel;
+    private pendingEntries;
+    private pendingDirectories;
+    private _mode;
+    private _filters;
+    private _excludePatterns;
+    private _includePatterns;
+    private _stripComponents;
+    private _overwrite;
+    private _fileName?;
+    constructor();
     /**
-     * Create SmartArchive from a local file path
+     * Load archive from URL
      */
-    static fromFile(filePathArg: string): Promise<SmartArchive>;
+    url(urlArg: string): this;
     /**
-     * Create SmartArchive from a readable stream
+     * Load archive from file path
      */
-    static fromStream(streamArg: plugins.stream.Readable | plugins.stream.Duplex | plugins.stream.Transform): Promise<SmartArchive>;
+    file(pathArg: string): this;
     /**
-     * Create SmartArchive from an in-memory buffer
+     * Load archive from readable stream
      */
-    static fromBuffer(buffer: Buffer): Promise<SmartArchive>;
+    stream(streamArg: plugins.stream.Readable | plugins.stream.Duplex | plugins.stream.Transform): this;
     /**
-     * Create a new archive from a directory
+     * Load archive from buffer
      */
-    static fromDirectory(directoryPath: string, options: IArchiveCreationOptions): Promise<SmartArchive>;
+    buffer(bufferArg: Buffer): this;
     /**
-     * Create a new archive from an array of entries
+     * Set output format for archive creation
      */
-    static fromFiles(files: IArchiveEntry[], options: IArchiveCreationOptions): Promise<SmartArchive>;
+    format(fmt: TArchiveFormat): this;
     /**
-     * Start building an archive incrementally using a builder pattern
+     * Set compression level (0-9)
      */
-    static create(options: IArchiveCreationOptions): SmartArchive;
+    compression(level: TCompressionLevel): this;
     /**
-     * Helper to convert a stream to buffer
+     * Add a single file entry to the archive
      */
-    private static streamToBuffer;
-    tarTools: TarTools;
-    zipTools: ZipTools;
-    gzipTools: GzipTools;
-    bzip2Tools: Bzip2Tools;
-    archiveAnalyzer: ArchiveAnalyzer;
-    sourceUrl?: string;
-    sourceFilePath?: string;
-    sourceStream?: plugins.stream.Readable | plugins.stream.Duplex | plugins.stream.Transform;
-    private archiveBuffer?;
-    private creationOptions?;
-    private pendingEntries?;
-    constructor();
+    entry(archivePath: string, content: string | Buffer): this;
     /**
-     * Add a file to the archive (builder pattern)
+     * Add multiple entries to the archive
      */
-    addFile(archivePath: string, content: string | Buffer): this;
+    entries(entriesArg: Array<{
+        archivePath: string;
+        content: string | Buffer;
+    }>): this;
     /**
-     * Add a SmartFile to the archive (builder pattern)
+     * Add an entire directory to the archive (queued, resolved at build time)
      */
-    addSmartFile(file: plugins.smartfile.SmartFile, archivePath?: string): this;
+    directory(sourcePath: string, archiveBase?: string): this;
     /**
-     * Add a StreamFile to the archive (builder pattern)
+     * Add a SmartFile to the archive
      */
-    addStreamFile(file: plugins.smartfile.StreamFile, archivePath?: string): this;
+    addSmartFile(fileArg: plugins.smartfile.SmartFile, archivePath?: string): this;
     /**
-     * Build the archive from pending entries
+     * Add a StreamFile to the archive
      */
-    build(): Promise<SmartArchive>;
+    addStreamFile(fileArg: plugins.smartfile.StreamFile, archivePath?: string): this;
     /**
-     * Get the original archive stream
+     * Filter entries by predicate function
      */
-    toStream(): Promise<plugins.stream.Readable>;
+    filter(predicate: TEntryFilter): this;
     /**
-     * Get archive as a Buffer
+     * Include only entries matching the pattern
      */
-    toBuffer(): Promise<Buffer>;
+    include(pattern: string | RegExp): this;
     /**
-     * Write archive to a file
+     * Exclude entries matching the pattern
      */
-    toFile(filePath: string): Promise<void>;
+    exclude(pattern: string | RegExp): this;
+    /**
+     * Strip N leading path components from extracted files
+     */
+    stripComponents(n: number): this;
+    /**
+     * Overwrite existing files during extraction
+     */
+    overwrite(value?: boolean): this;
+    /**
+     * Set output filename for single-file archives (gz, bz2)
+     */
+    fileName(name: string): this;
     /**
-     * Extract archive to filesystem
+     * Extract archive to filesystem directory
      */
-    extractToDirectory(targetDir: string, options?: Partial<IArchiveExtractionOptions>): Promise<void>;
+    extract(targetDir: string): Promise<void>;
     /**
      * Extract archive to a stream of StreamFile objects
      */
-    extractToStream(): Promise<plugins.smartstream.StreamIntake<plugins.smartfile.StreamFile>>;
+    toStreamFiles(): Promise<plugins.smartstream.StreamIntake<plugins.smartfile.StreamFile>>;
     /**
      * Extract archive to an array of SmartFile objects (in-memory)
      */
-    extractToSmartFiles(): Promise<plugins.smartfile.SmartFile[]>;
+    toSmartFiles(): Promise<plugins.smartfile.SmartFile[]>;
     /**
      * Extract a single file from the archive by path
      */
     extractFile(filePath: string): Promise<plugins.smartfile.SmartFile | null>;
+    /**
+     * Build and finalize the archive, returning this instance
+     */
+    build(): Promise<SmartArchive>;
+    /**
+     * Internal build implementation (avoids thenable recursion)
+     */
+    private doBuild;
+    /**
+     * Build archive and return as Buffer
+     */
+    toBuffer(): Promise<Buffer>;
+    /**
+     * Build archive and write to file
+     */
+    toFile(filePath: string): Promise<void>;
+    /**
+     * Get archive as a readable stream
+     */
+    toStream(): Promise<plugins.stream.Readable>;
     /**
      * Analyze the archive and return metadata
      */
     analyze(): Promise<IArchiveInfo>;
     /**
-     * List all entries in the archive without extracting
+     * List all entries in the archive
      */
-    listEntries(): Promise<IArchiveEntryInfo[]>;
+    list(): Promise<IArchiveEntryInfo[]>;
     /**
      * Check if a specific file exists in the archive
      */
     hasFile(filePath: string): Promise<boolean>;
     /**
-     * Helper to read first chunk from stream
+     * Ensure we're not in create mode when calling extraction methods
+     */
+    private ensureNotInCreateMode;
+    /**
+     * Ensure we're not in extract mode when calling creation methods
+     */
+    private ensureNotInExtractMode;
+    /**
+     * Ensure an extraction source is configured
+     */
+    private ensureExtractionSource;
+    /**
+     * Ensure a format is configured for creation
+     */
+    private ensureCreationFormat;
+    /**
+     * Get the source stream
+     */
+    private getSourceStream;
+    /**
+     * Build a combined filter function from all configured filters
+     */
+    private buildFilterFunction;
+    /**
+     * Resolve pending directories to entries
+     */
+    private resolveDirectories;
+    /**
+     * Get entries filtered by include/exclude patterns
+     */
+    private getFilteredEntries;
+    /**
+     * Convert a stream to buffer
+     */
+    private streamToBuffer;
+    /**
+     * Read first chunk from stream
      */
     private readFirstChunk;
 }