node-liblzma 2.0.3 → 2.2.0

package/scripts/analyze-coverage.js

@@ -1,132 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'fs';
-import path from 'path';
-
-const COVERAGE_FILE = './coverage/coverage-final.json';
-const SOURCE_FILE = './src/lzma.ts';
-
-if (!fs.existsSync(COVERAGE_FILE)) {
-  console.log("❌ Fichier de coverage non trouvé. Lancez `pnpm test -- --coverage` d'abord.");
-  process.exit(1);
-}
-
-const coverage = JSON.parse(fs.readFileSync(COVERAGE_FILE, 'utf8'));
-const sourceLines = fs.readFileSync(SOURCE_FILE, 'utf8').split('\n');
-
-// Analyser le fichier principal
-const filePath = path.resolve(SOURCE_FILE);
-const data = coverage[filePath] || coverage[Object.keys(coverage)[0]];
-
-if (!data) {
-  console.log('❌ Données de coverage non trouvées');
-  process.exit(1);
-}
-
-console.log('🔍 ANALYSE DE PRÉCISION DU COVERAGE\n');
-
-// Fonctions non couvertes
-const uncoveredFunctions = Object.entries(data.f).filter(([, count]) => count === 0);
-console.log(`📊 FONCTIONS NON COUVERTES (${uncoveredFunctions.length}):`);
-uncoveredFunctions.forEach(([key, count]) => {
-  const fn = data.fnMap[key];
-  const startLine = fn.loc.start.line;
-  const endLine = fn.loc.end.line;
-
-  console.log(`  Function ${key}: "${fn.name}" (lignes ${startLine}-${endLine})`);
-  console.log(`    Code: ${sourceLines[startLine - 1]?.trim() || 'N/A'}`);
-
-  // Vérifier si c'est un artefact
-  const isArtifact =
-    sourceLines[startLine - 1]?.includes('/* v8 ignore') ||
-    sourceLines[startLine - 1]?.includes('export const') ||
-    fn.name.includes('anonymous');
-
-  if (isArtifact) {
-    console.log(`    ⚠️  Probablement un artefact V8`);
-  } else {
-    console.log(`    🎯 VRAIE fonction non testée`);
-  }
-  console.log('');
-});
-
-// Statements non couverts
-const uncoveredStatements = Object.entries(data.s).filter(([, count]) => count === 0);
-console.log(`📊 STATEMENTS NON COUVERTS (${uncoveredStatements.length}):`);
-uncoveredStatements.slice(0, 10).forEach(([key, count]) => {
-  const stmt = data.statementMap[key];
-  const line = stmt.start.line;
-
-  console.log(`  Statement ${key}: ligne ${line}`);
-  console.log(`    Code: ${sourceLines[line - 1]?.trim() || 'N/A'}`);
-
-  // Vérifier si c'est vraiment du code exécutable
-  const codeLine = sourceLines[line - 1]?.trim() || '';
-  const isIgnorable =
-    codeLine.includes('/* v8 ignore') ||
-    codeLine === '' ||
-    codeLine.includes('//') ||
-    codeLine === '}' ||
-    codeLine === '{' ||
-    codeLine.includes('export const');
-
-  if (isIgnorable) {
-    console.log(`    ⚠️  Ligne probablement ignorable`);
-  } else {
-    console.log(`    🎯 VRAI code non testé`);
-  }
-  console.log('');
-});
-
-// Branches critiques non couvertes
-const uncoveredBranches = Object.entries(data.b)
-  .filter(([, counts]) => counts.includes(0))
-  .filter(([key]) => {
-    const branch = data.branchMap[key];
-    const line = sourceLines[branch.line - 1]?.trim() || '';
-    return !line.includes('/* v8 ignore') && line.length > 0;
-  });
-
-console.log(`📊 BRANCHES CRITIQUES NON COUVERTES (${uncoveredBranches.length}):`);
-uncoveredBranches.slice(0, 10).forEach(([key, counts]) => {
-  const branch = data.branchMap[key];
-  const line = branch.line;
-
-  console.log(`  Branch ${key}: ligne ${line} - ${counts}`);
-  console.log(`    Code: ${sourceLines[line - 1]?.trim() || 'N/A'}`);
-  console.log(`    Type: ${branch.type}`);
-  console.log(`    🎯 VRAIE condition non testée`);
-  console.log('');
-});
-
-console.log('💡 RÉSUMÉ:');
-console.log(
-  `  - Fonctions vraiment non testées: ${
-    uncoveredFunctions.filter(([key]) => {
-      const fn = data.fnMap[key];
-      return (
-        !fn.name.includes('anonymous') &&
-        !sourceLines[fn.loc.start.line - 1]?.includes('export const')
-      );
-    }).length
-  }`
-);
-
-console.log(
-  `  - Statements vraiment non testés: ${
-    uncoveredStatements.filter(([key]) => {
-      const stmt = data.statementMap[key];
-      const codeLine = sourceLines[stmt.start.line - 1]?.trim() || '';
-      return (
-        !codeLine.includes('/* v8 ignore') &&
-        codeLine !== '' &&
-        !codeLine.includes('//') &&
-        codeLine !== '}' &&
-        codeLine !== '{' &&
-        !codeLine.includes('export const')
-      );
-    }).length
-  }`
-);
-
-console.log(`  - Branches vraiment non testées: ${uncoveredBranches.length}`);

package/scripts/compare-coverage-tools.js

@@ -1,93 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'fs';
-import path from 'path';
-
-const V8_COVERAGE = './coverage/coverage-final.json';
-const MONOCART_DATA = './coverage-reports/coverage-data.js';
-const SOURCE_FILE = './src/lzma.ts';
-
-console.log('🔍 COMPARAISON V8 vs MONOCART\n');
-
-// Lire V8
-if (!fs.existsSync(V8_COVERAGE)) {
-  console.log('❌ V8 coverage manquant');
-  process.exit(1);
-}
-const v8Coverage = JSON.parse(fs.readFileSync(V8_COVERAGE, 'utf8'));
-const sourceLines = fs.readFileSync(SOURCE_FILE, 'utf8').split('\n');
-const filePath = path.resolve(SOURCE_FILE);
-const v8Data = v8Coverage[filePath] || v8Coverage[Object.keys(v8Coverage)[0]];
-
-// Lire Monocart
-if (!fs.existsSync(MONOCART_DATA)) {
-  console.log('❌ Monocart data manquant');
-  process.exit(1);
-}
-
-// Extraire les données Monocart du fichier JS
-const monocartContent = fs.readFileSync(MONOCART_DATA, 'utf8');
-const monocartMatch = monocartContent.match(/window\.reportData\s*=\s*'([^']+)'/);
-if (!monocartMatch) {
-  console.log('❌ Format Monocart non reconnu');
-  process.exit(1);
-}
-
-// Monocart utilise un format compressé, on doit le décoder
-console.log('⚠️  Monocart utilise un format de données compressé, analyse simplifiée...');
-const monocartData = { summary: null };
-const summaryData = monocartData.summary;
-
-console.log('📊 COMPARAISON GLOBALE:');
-console.log(
-  `V8       : ${v8Data.s ? Object.values(v8Data.s).filter((x) => x > 0).length : 0} statements couverts / ${v8Data.s ? Object.keys(v8Data.s).length : 0} total`
-);
-console.log(
-  `Monocart : ${summaryData.statements.covered} statements couverts / ${summaryData.statements.total} total`
-);
-console.log('');
-
-console.log(
-  `V8       : ${v8Data.b ? Object.values(v8Data.b).filter((arr) => arr.every((x) => x > 0)).length : 0} branches couvertes / ${v8Data.b ? Object.keys(v8Data.b).length : 0} total`
-);
-console.log(
-  `Monocart : ${summaryData.branches.covered} branches couvertes / ${summaryData.branches.total} total`
-);
-console.log('');
-
-console.log(
-  `V8       : ${v8Data.f ? Object.values(v8Data.f).filter((x) => x > 0).length : 0} fonctions couvertes / ${v8Data.f ? Object.keys(v8Data.f).length : 0} total`
-);
-console.log(
-  `Monocart : ${summaryData.functions.covered} fonctions couvertes / ${summaryData.functions.total} total`
-);
-console.log('');
-
-// Analyse des statements non couverts
-const v8UncoveredStmts = Object.entries(v8Data.s || {}).filter(([, count]) => count === 0);
-console.log(`🎯 V8 STATEMENTS NON COUVERTS: ${v8UncoveredStmts.length}`);
-v8UncoveredStmts.slice(0, 5).forEach(([key]) => {
-  const stmt = v8Data.statementMap[key];
-  const line = stmt.start.line;
-  console.log(`  Ligne ${line}: ${sourceLines[line - 1]?.trim() || 'N/A'}`);
-});
-
-console.log('\n💡 VERDICT:');
-if (summaryData.statements.total !== Object.keys(v8Data.s || {}).length) {
-  console.log('⚠️  Monocart détecte un nombre différent de statements');
-}
-
-const v8Pct = (
-  (Object.values(v8Data.s || {}).filter((x) => x > 0).length / Object.keys(v8Data.s || {}).length) *
-  100
-).toFixed(2);
-const monocartPct = summaryData.statements.pct;
-
-console.log(`V8       : ${v8Pct}% statements coverage`);
-console.log(`Monocart : ${monocartPct}% statements coverage`);
-
-if (Math.abs(parseFloat(monocartPct) - parseFloat(v8Pct)) > 1) {
-  console.log('✨ Monocart montre une différence significative !');
-} else {
-  console.log('📊 Résultats similaires entre V8 et Monocart');
-}

package/src/errors.ts

@@ -1,167 +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/>.
- */
-
-/**
- * Base class for all LZMA-related errors
- */
-export class LZMAError extends Error {
-  public readonly errno: number;
-  public readonly code: number;
-
-  constructor(message: string, errno: number) {
-    super(message);
-    this.name = 'LZMAError';
-    this.errno = errno;
-    this.code = errno;
-    Error.captureStackTrace(this, this.constructor);
-  }
-}
-
-/**
- * Memory allocation error - thrown when LZMA cannot allocate required memory
- */
-export class LZMAMemoryError extends LZMAError {
-  constructor(errno: number) {
-    super('Cannot allocate memory', errno);
-    this.name = 'LZMAMemoryError';
-  }
-}
-
-/**
- * Memory limit error - thrown when operation would exceed memory usage limit
- */
-export class LZMAMemoryLimitError extends LZMAError {
-  constructor(errno: number) {
-    super('Memory usage limit was reached', errno);
-    this.name = 'LZMAMemoryLimitError';
-  }
-}
-
-/**
- * Format error - thrown when file format is not recognized
- */
-export class LZMAFormatError extends LZMAError {
-  constructor(errno: number) {
-    super('File format not recognized', errno);
-    this.name = 'LZMAFormatError';
-  }
-}
-
-/**
- * Options error - thrown when invalid or unsupported options are provided
- */
-export class LZMAOptionsError extends LZMAError {
-  constructor(errno: number) {
-    super('Invalid or unsupported options', errno);
-    this.name = 'LZMAOptionsError';
-  }
-}
-
-/**
- * Data error - thrown when compressed data is corrupt
- */
-export class LZMADataError extends LZMAError {
-  constructor(errno: number) {
-    super('Data is corrupt', errno);
-    this.name = 'LZMADataError';
-  }
-}
-
-/**
- * Buffer error - thrown when no progress is possible (e.g., buffer too small)
- */
-export class LZMABufferError extends LZMAError {
-  constructor(errno: number) {
-    super('No progress is possible', errno);
-    this.name = 'LZMABufferError';
-  }
-}
-
-/**
- * Programming error - thrown when there's an internal programming error
- */
-export class LZMAProgrammingError extends LZMAError {
-  constructor(errno: number) {
-    super('Programming error', errno);
-    this.name = 'LZMAProgrammingError';
-  }
-}
-
-/**
- * Factory function to create appropriate error instance based on errno
- */
-export function createLZMAError(errno: number, message?: string): LZMAError {
-  // LZMA error codes mapping
-  const LZMA_OK = 0;
-  const LZMA_STREAM_END = 1;
-  const LZMA_NO_CHECK = 2;
-  const LZMA_UNSUPPORTED_CHECK = 3;
-  const LZMA_GET_CHECK = 4;
-  const LZMA_MEM_ERROR = 5;
-  const LZMA_MEMLIMIT_ERROR = 6;
-  const LZMA_FORMAT_ERROR = 7;
-  const LZMA_OPTIONS_ERROR = 8;
-  const LZMA_DATA_ERROR = 9;
-  const LZMA_BUF_ERROR = 10;
-  const LZMA_PROG_ERROR = 11;
-
-  switch (errno) {
-    case LZMA_MEM_ERROR:
-      return new LZMAMemoryError(errno);
-    case LZMA_MEMLIMIT_ERROR:
-      return new LZMAMemoryLimitError(errno);
-    case LZMA_FORMAT_ERROR:
-      return new LZMAFormatError(errno);
-    case LZMA_OPTIONS_ERROR:
-      return new LZMAOptionsError(errno);
-    case LZMA_DATA_ERROR:
-      return new LZMADataError(errno);
-    case LZMA_BUF_ERROR:
-      return new LZMABufferError(errno);
-    case LZMA_PROG_ERROR:
-      return new LZMAProgrammingError(errno);
-    default: {
-      // For success codes and unknown errors, use base LZMAError
-      const errorMessage = message || getErrorMessage(errno);
-      return new LZMAError(errorMessage, errno);
-    }
-  }
-}
-
-/**
- * Get error message for a given errno
- */
-function getErrorMessage(errno: number): string {
-  const messages = [
-    'Operation completed successfully',
-    'End of stream was reached',
-    'Input stream has no integrity check',
-    'Cannot calculate the integrity check',
-    'Integrity check type is not available',
-    'Cannot allocate memory',
-    'Memory usage limit was reached',
-    'File format not recognized',
-    'Invalid or unsupported options',
-    'Data is corrupt',
-    'No progress is possible',
-    'Programming error',
-  ];
-
-  const messageIndex = Math.max(0, Math.min(errno, messages.length - 1));
-  return messages[messageIndex];
-}