@push.rocks/smartarchive 4.2.4 → 5.0.0

package/dist_ts/interfaces.d.ts

@@ -0,0 +1,115 @@
+import type * as stream from 'node:stream';
+import type { SmartFile, StreamFile } from '@push.rocks/smartfile';
+/**
+ * Supported archive formats
+ */
+export type TArchiveFormat = 'tar' | 'tar.gz' | 'tgz' | 'zip' | 'gz' | 'bz2';
+/**
+ * Compression level (0 = no compression, 9 = maximum compression)
+ */
+export type TCompressionLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+/**
+ * Supported MIME types for archive detection
+ */
+export type TSupportedMime = 'application/gzip' | 'application/zip' | 'application/x-bzip2' | 'application/x-tar' | undefined;
+/**
+ * Entry to add to an archive during creation
+ */
+export interface IArchiveEntry {
+    /** Path within the archive */
+    archivePath: string;
+    /** Content: string, Buffer, Readable stream, SmartFile, or StreamFile */
+    content: string | Buffer | stream.Readable | SmartFile | StreamFile;
+    /** Optional size hint for streams (improves performance) */
+    size?: number;
+    /** Optional file mode/permissions */
+    mode?: number;
+    /** Optional modification time */
+    mtime?: Date;
+}
+/**
+ * Options for creating archives
+ */
+export interface IArchiveCreationOptions {
+    /** Target archive format */
+    format: TArchiveFormat;
+    /** Compression level (0-9, default depends on format) */
+    compressionLevel?: TCompressionLevel;
+    /** Base path to strip from file paths in archive */
+    basePath?: string;
+}
+/**
+ * Options for extracting archives
+ */
+export interface IArchiveExtractionOptions {
+    /** Target directory for extraction */
+    targetDir: string;
+    /** Optional filename for single-file archives (gz, bz2) */
+    fileName?: string;
+    /** Number of leading path components to strip */
+    stripComponents?: number;
+    /** Filter function to select which entries to extract */
+    filter?: (entry: IArchiveEntryInfo) => boolean;
+    /** Whether to overwrite existing files */
+    overwrite?: boolean;
+}
+/**
+ * Information about an archive entry
+ */
+export interface IArchiveEntryInfo {
+    /** Path of the entry within the archive */
+    path: string;
+    /** Size in bytes */
+    size: number;
+    /** Whether this entry is a directory */
+    isDirectory: boolean;
+    /** Whether this entry is a file */
+    isFile: boolean;
+    /** Modification time */
+    mtime?: Date;
+    /** File mode/permissions */
+    mode?: number;
+}
+/**
+ * Result of archive analysis
+ */
+export interface IArchiveInfo {
+    /** Detected archive format */
+    format: TArchiveFormat | null;
+    /** Whether the archive is compressed */
+    isCompressed: boolean;
+    /** Whether this is a recognized archive format */
+    isArchive: boolean;
+    /** List of entries (if available without full extraction) */
+    entries?: IArchiveEntryInfo[];
+}
+/**
+ * Options for adding a file to a TAR pack stream
+ */
+export interface IAddFileOptions {
+    /** Filename within the archive */
+    fileName?: string;
+    /** File content */
+    content?: string | Buffer | stream.Readable | SmartFile | StreamFile;
+    /** Size in bytes (required for streams) */
+    byteLength?: number;
+    /** Path to file on disk (alternative to content) */
+    filePath?: string;
+}
+/**
+ * Bit reader interface for BZIP2 decompression
+ */
+export interface IBitReader {
+    (n: number | null): number | void;
+    bytesRead: number;
+}
+/**
+ * Huffman group for BZIP2 decompression
+ */
+export interface IHuffmanGroup {
+    permute: Int32Array;
+    limit: Int32Array;
+    base: Int32Array;
+    minLen: number;
+    maxLen: number;
+}

package/dist_ts/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartarchive",
-  "version": "4.2.4",
+  "version": "5.0.0",
   "description": "A library for working with archive files, providing utilities for compressing and decompressing data.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",

package/ts/00_commitinfo_data.ts

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

package/ts/bzip2/bititerator.ts

@@ -1,44 +1,60 @@
-var BITMASK = [0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff];
-
-// returns a function that reads bits.
-// takes a buffer iterator as input
-export function bitIterator(nextBuffer: () => Buffer) {
-  var bit = 0,
-    byte = 0;
-  var bytes = nextBuffer();
-  var f = function (n) {
-    if (n === null && bit != 0) {
+import type { IBitReader } from '../interfaces.js';
+
+const BITMASK = [0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff] as const;
+
+/**
+ * Creates a bit reader function for BZIP2 decompression.
+ * Takes a buffer iterator as input and returns a function that reads bits.
+ */
+export function bitIterator(nextBuffer: () => Buffer): IBitReader {
+  let bit = 0;
+  let byte = 0;
+  let bytes = nextBuffer();
+  let _bytesRead = 0;
+
+  const reader = function (n: number | null): number | void {
+    if (n === null && bit !== 0) {
       // align to byte boundary
       bit = 0;
       byte++;
       return;
     }
-    var result = 0;
-    while (n > 0) {
+
+    let result = 0;
+    let remaining = n as number;
+
+    while (remaining > 0) {
       if (byte >= bytes.length) {
         byte = 0;
         bytes = nextBuffer();
       }
-      var left = 8 - bit;
-      if (bit === 0 && n > 0)
-        // @ts-ignore
-        f.bytesRead++;
-      if (n >= left) {
+
+      const left = 8 - bit;
+
+      if (bit === 0 && remaining > 0) {
+        _bytesRead++;
+      }
+
+      if (remaining >= left) {
         result <<= left;
         result |= BITMASK[left] & bytes[byte++];
         bit = 0;
-        n -= left;
+        remaining -= left;
       } else {
-        result <<= n;
-        result |=
-          (bytes[byte] & (BITMASK[n] << (8 - n - bit))) >> (8 - n - bit);
-        bit += n;
-        n = 0;
+        result <<= remaining;
+        result |= (bytes[byte] & (BITMASK[remaining] << (8 - remaining - bit))) >> (8 - remaining - bit);
+        bit += remaining;
+        remaining = 0;
       }
     }
+
     return result;
-  };
-  // @ts-ignore
-  f.bytesRead = 0;
-  return f;
+  } as IBitReader;
+
+  Object.defineProperty(reader, 'bytesRead', {
+    get: () => _bytesRead,
+    enumerable: true,
+  });
+
+  return reader;
 }