node-liblzma 2.0.0 → 2.1.0

package/src/pool.ts

@@ -1,228 +0,0 @@
-/**
- * node-liblzma - Node.js bindings for liblzma
- * Copyright (C) Olivier Orabona <olivier.orabona@gmail.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-import { EventEmitter } from 'node:events';
-import { type LZMAOptions, unxzAsync, xzAsync } from './lzma.js';
-
-/**
- * Metrics for pool monitoring
- */
-export interface PoolMetrics {
-  /** Number of currently active compression/decompression operations */
-  active: number;
-  /** Number of operations waiting in the queue */
-  queued: number;
-  /** Total number of successfully completed operations */
-  completed: number;
-  /** Total number of failed operations */
-  failed: number;
-}
-
-/**
- * Task in the queue
- */
-interface QueuedTask {
-  fn: () => Promise<Buffer>;
-  resolve: (value: Buffer) => void;
-  reject: (error: Error) => void;
-}
-
-/**
- * LZMA Pool with concurrency control and event monitoring
- *
- * Provides rate limiting and backpressure for LZMA operations.
- * Emits events for monitoring and metrics collection in production.
- *
- * @example
- * ```typescript
- * const pool = new LZMAPool(10); // Max 10 concurrent operations
- *
- * pool.on('metrics', (metrics) => {
- *   console.log(`Active: ${metrics.active}, Queued: ${metrics.queued}`);
- * });
- *
- * const compressed = await pool.compress(buffer);
- * ```
- *
- * Events:
- * - 'queue': Emitted when task added to queue
- * - 'start': Emitted when task starts processing
- * - 'complete': Emitted when task completes successfully
- * - 'error-task': Emitted when task fails
- * - 'metrics': Emitted after each state change with current metrics
- */
-export class LZMAPool extends EventEmitter {
-  private queue: QueuedTask[] = [];
-
-  private metrics: PoolMetrics = {
-    active: 0,
-    queued: 0,
-    completed: 0,
-    failed: 0,
-  };
-
-  /**
-   * Create a new LZMA pool
-   * @param maxConcurrent Maximum number of concurrent operations (default: 10)
-   */
-  constructor(private maxConcurrent = 10) {
-    super();
-
-    if (maxConcurrent < 1) {
-      throw new RangeError('maxConcurrent must be at least 1');
-    }
-  }
-
-  /**
-   * Compress data with automatic queue management
-   * @param data Buffer to compress
-   * @param opts LZMA compression options
-   * @returns Promise that resolves to compressed buffer
-   */
-  async compress(data: Buffer, opts?: LZMAOptions): Promise<Buffer> {
-    return this.enqueue(() => xzAsync(data, opts));
-  }
-
-  /**
-   * Decompress data with automatic queue management
-   * @param data Compressed buffer to decompress
-   * @param opts LZMA decompression options
-   * @returns Promise that resolves to decompressed buffer
-   */
-  async decompress(data: Buffer, opts?: LZMAOptions): Promise<Buffer> {
-    return this.enqueue(() => unxzAsync(data, opts));
-  }
-
-  /**
-   * Get current pool metrics
-   * @returns Copy of current metrics
-   */
-  getMetrics(): Readonly<PoolMetrics> {
-    return { ...this.metrics };
-  }
-
-  /**
-   * Get number of tasks waiting in queue
-   * @returns Queue length
-   */
-  get queueLength(): number {
-    return this.queue.length;
-  }
-
-  /**
-   * Get number of currently active tasks
-   * @returns Active task count
-   */
-  get activeCount(): number {
-    return this.metrics.active;
-  }
-
-  /**
-   * Check if pool is at maximum capacity
-   * @returns True if at capacity
-   */
-  get isAtCapacity(): boolean {
-    return this.metrics.active >= this.maxConcurrent;
-  }
-
-  /**
-   * Enqueue a task for execution
-   * @param fn Task function returning Promise<Buffer>
-   * @returns Promise that resolves when task completes
-   */
-  private async enqueue(fn: () => Promise<Buffer>): Promise<Buffer> {
-    return new Promise((resolve, reject) => {
-      this.queue.push({ fn, resolve, reject });
-      this.metrics.queued = this.queue.length;
-      this.emit('queue', { ...this.metrics });
-      this.processQueue();
-    });
-  }
-
-  /**
-   * Process tasks from queue respecting concurrency limit
-   */
-  private processQueue(): void {
-    // Don't start new tasks if at capacity or queue empty
-    if (this.metrics.active >= this.maxConcurrent || this.queue.length === 0) {
-      return;
-    }
-
-    const item = this.queue.shift();
-    if (!item) return;
-
-    this.metrics.active++;
-    this.metrics.queued = this.queue.length;
-    this.emit('start', { ...this.metrics });
-
-    // Execute task
-    item
-      .fn()
-      .then((result) => {
-        this.metrics.completed++;
-        item.resolve(result);
-        this.emit('complete', { ...this.metrics });
-      })
-      .catch((error: Error) => {
-        this.metrics.failed++;
-        item.reject(error);
-        this.emit('error-task', error, { ...this.metrics });
-      })
-      .finally(() => {
-        this.metrics.active--;
-        this.emit('metrics', { ...this.metrics });
-
-        // Process next task in queue
-        this.processQueue();
-      });
-  }
-
-  /**
-   * Wait for all active tasks to complete
-   * Does not process new tasks added while waiting
-   * @returns Promise that resolves when all active tasks are done
-   */
-  async drain(): Promise<void> {
-    if (this.metrics.active === 0) {
-      return Promise.resolve();
-    }
-
-    return new Promise((resolve) => {
-      const checkDrained = () => {
-        if (this.metrics.active === 0) {
-          this.off('metrics', checkDrained);
-          resolve();
-        }
-      };
-      this.on('metrics', checkDrained);
-    });
-  }
-
-  /**
-   * Clear all pending tasks from the queue
-   * Active tasks will continue to run
-   * @returns Number of tasks removed from queue
-   */
-  clearQueue(): number {
-    const cleared = this.queue.length;
-    this.queue = [];
-    this.metrics.queued = 0;
-    this.emit('metrics', { ...this.metrics });
-    return cleared;
-  }
-}

package/src/types.ts

@@ -1,30 +0,0 @@
-/**
- * Shared TypeScript types for node-liblzma
- */
-
-export interface LZMAOptions {
-  /** Integrity check type */
-  check?: number;
-  /** Compression preset level */
-  preset?: number;
-  /** Array of filters to use */
-  filters?: number[];
-  /** Compression mode */
-  mode?: number;
-  /** Number of threads for compression (encoding only) */
-  threads?: number;
-  /** Chunk size for processing */
-  chunkSize?: number;
-  /** Flush flag to use */
-  flushFlag?: number;
-}
-
-export type CompressionCallback = (error: Error | null, result?: Buffer) => void;
-
-// Union types for better type safety and validation
-export type LZMAActionType = 0 | 1 | 2 | 3; // RUN | SYNC_FLUSH | FULL_FLUSH | FINISH
-export type LZMAStatusType = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11; // All LZMA status codes
-export type CheckType = 0 | 1 | 4 | 10; // NONE | CRC32 | CRC64 | SHA256
-export type PresetType = 6 | 9; // DEFAULT | EXTREME
-export type FilterType = 0x21 | 0x03 | 0x04 | 0x06 | 0x07 | 0x08 | 0x09; // LZMA2 | X86 | POWERPC | IA64 | ARM | ARMTHUMB | SPARC
-export type ModeType = 1 | 2; // FAST | NORMAL

package/tsconfig.json

@@ -1,50 +0,0 @@
-{
-  "compilerOptions": {
-    /* Language and Environment */
-    "target": "ES2020",
-    "lib": ["ES2020", "ES2020.Promise"],
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
-
-    /* Output */
-    "outDir": "./lib",
-    "rootDir": "./src",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "removeComments": false,
-    "importHelpers": false,
-
-    /* Interop Constraints */
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-
-    /* Type Checking */
-    "strict": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "strictFunctionTypes": true,
-    "strictBindCallApply": true,
-    "strictPropertyInitialization": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": false,
-    "noImplicitOverride": true,
-
-    /* Completeness */
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-
-    /* Node.js specific */
-    "types": ["node", "vitest"],
-
-    /* Emit */
-    "noEmitOnError": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "lib", "build", "test", "**/*.coffee", "**/*.d.ts"],
-  "ts-node": {
-    "esm": true
-  }
-}

package/vitest.config.istanbul.ts

@@ -1,29 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    // Include TypeScript and JavaScript test files, but exclude utils files
-    include: ['test/**/*.{ts,js,tsx,jsx}'],
-    exclude: ['test/**/*.utils.{ts,js}'],
-
-    // Timeout for tests (similar to Mocha config)
-    testTimeout: 5000,
-
-    // Coverage configuration with Istanbul
-    coverage: {
-      provider: 'istanbul',
-      reporter: ['text', 'json', 'html'],
-      include: ['src/**/*.{ts,js}', 'lib/**/*.js'],
-      exclude: ['test/**/*', 'node_modules/**/*', '**/*.d.ts'],
-      reportsDirectory: './coverage-istanbul',
-    },
-
-    // Allow tests to run in Node environment
-    environment: 'node',
-
-    // TypeScript support
-    typecheck: {
-      enabled: true,
-    },
-  },
-});

package/vitest.config.monocart.ts

@@ -1,44 +0,0 @@
-import { withMonocartProvider } from '@oorabona/vitest-monocart-coverage';
-import { defineConfig } from 'vitest/config';
-
-export default withMonocartProvider(
-  defineConfig({
-    test: {
-      // Include TypeScript and JavaScript test files, but exclude utils files
-      include: ['test/**/*.{ts,js,tsx,jsx}'],
-      exclude: ['test/**/*.utils.{ts,js}'],
-
-      // Timeout for tests (similar to Mocha config)
-      testTimeout: 5000,
-
-      // Coverage configuration with Monocart
-      coverage: {
-        enabled: true,
-        reporter: ['console-details', 'json', 'html', 'lcov'],
-        include: ['src/**/*.{ts,js}'],
-        exclude: ['test/**/*', 'node_modules/**/*', '**/*.d.ts', 'lib/**/*.js'],
-        // Configurations V8 pour précision maximale
-        cleanOnRerun: true,
-        all: false, // N'inclut que les fichiers qui sont réellement chargés
-        skipFull: true, // Plus rapide et plus précis
-        // Nouvelle option Vitest 3.2+ pour améliorer la précision
-        experimentalAstAwareRemapping: true,
-        ignoreEmptyLines: true,
-
-        // Options Monocart spécifiques
-        clean: true,
-      },
-
-      // Allow tests to run in Node environment
-      environment: 'node',
-
-      // TypeScript support
-      typecheck: {
-        enabled: true,
-      },
-    },
-  }),
-  {
-    reports: ['html', 'console-details', 'lcov'],
-  }
-);

package/vitest.config.ts

@@ -1,44 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    // Include TypeScript and JavaScript test files, but exclude utils files
-    include: ['test/**/*.{ts,js,tsx,jsx}'],
-    exclude: ['test/**/*.utils.{ts,js}'],
-
-    // Timeout for tests (similar to Mocha config)
-    testTimeout: 5000,
-
-    // Use forks instead of threads on macOS to avoid IPC channel issues
-    pool: process.platform === 'darwin' ? 'forks' : 'threads',
-    poolOptions: {
-      forks: {
-        singleFork: true,
-      },
-    },
-
-    // Coverage configuration - V8 optimisé pour précision max
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'json', 'html', 'lcov'],
-      include: ['src/**/*.{ts,js}'],
-      exclude: ['test/**/*', 'node_modules/**/*', '**/*.d.ts', 'lib/**/*.js'],
-      // Configurations V8 pour précision maximale
-      cleanOnRerun: true,
-      all: false, // N'inclut que les fichiers qui sont réellement chargés
-      skipFull: true, // Plus rapide et plus précis
-      // Nouvelle option Vitest 3.2+ pour améliorer la précision
-      experimentalAstAwareRemapping: true,
-      ignoreEmptyLines: true,
-      // Pas de thresholds pour l'instant - focus sur la précision
-    },
-
-    // Allow tests to run in Node environment
-    environment: 'node',
-
-    // TypeScript support
-    typecheck: {
-      enabled: true,
-    },
-  },
-});