portapack 0.2.1 → 0.3.1

package/jest.config.ts

@@ -5,7 +5,8 @@ const config: Config = {
   /**
    * Use ts-jest with ESM support.
    */
-  preset: 'ts-jest/presets/default-esm',
+  // preset: 'ts-jest/presets/default-esm',
+  preset: 'ts-jest',
 
   /**
    * Node test environment
@@ -20,16 +21,25 @@ const config: Config = {
   /**
    * Tell ts-jest to use ESM transformation
    */
+  // transform: {
+  //   '^.+\\.tsx?$': [
+  //     'ts-jest',
+  //     {
+  //       useESM: true,
+  //       tsconfig: './tsconfig.jest.json'
+  //     }
+  //   ]
+  // },
+
   transform: {
     '^.+\\.tsx?$': [
       'ts-jest',
       {
-        useESM: true,
-        tsconfig: './tsconfig.jest.json'
+        // useESM: false, // Explicitly false or remove this line entirely
+        tsconfig: './tsconfig.jest.json' // Ensure this tsconfig targets CommonJS
       }
     ]
   },
-
   /**
    * Treat `.ts` files as ESM modules.
    */
@@ -68,10 +78,10 @@ const config: Config = {
    */
   coverageThreshold: {
     global: {
-      branches: 60,
-      functions: 60,
-      lines: 60,
-      statements: 60,
+      branches: 70,
+      functions: 70,
+      lines: 70,
+      statements: 70,
     },
   },
 

package/jest.setup.cjs

@@ -1,211 +1,131 @@
-/**
- * @file jest.setup.cjs
- * @description Jest global setup script executed before test suites run (per file).
- * Responsible for creating temporary directories for test outputs and fixtures,
- * setting up mock data (like the sample project), and cleaning up afterwards.
- * Uses CommonJS syntax as Jest setup files often run in a CJS context.
- */
-
-// Node.js core modules required for setup
-const fs = require('fs/promises'); // Using promises API for async operations
+// jest.setup.cjs
+const fs = require('fs/promises');
 const path = require('path');
 const crypto = require('crypto');
 const os = require('os');
+// const jest = require('@jest/globals'); // REMOVE THIS LINE
 
-// Generate a unique ID for each test execution session.
-// This helps isolate test runs if running concurrently or prevents conflicts
-// if cleanup fails on a previous run.
 const TEST_RUN_ID = crypto.randomBytes(4).toString('hex');
-
-// Helper function for resolving paths relative to this setup file's directory
-// (usually the project root or a specific test config directory)
 const resolve = (...args) => path.resolve(__dirname, ...args);
 
-/**
- * Utility function to ensure a directory exists.
- * Creates the directory recursively if it doesn't exist.
- * Ignores 'EEXIST' error if the directory is already present.
- * @param {string} dir - The absolute path of the directory to ensure.
- * @returns {Promise<void>}
- * @throws {Error} Throws errors other than 'EEXIST' during directory creation.
- */
+// Use the *original* console.log temporarily for setup debugging
+const originalSetupLog = console.log;
+
 const ensureDir = async (dir) => {
     try {
         await fs.mkdir(dir, { recursive: true });
     } catch (e) {
-        // If the error is simply that the directory already exists, ignore it.
         if (e.code !== 'EEXIST') {
-            console.error(`Failed to ensure directory ${dir}:`, e); // Log unexpected errors
-            throw e; // Re-throw other errors
+            originalSetupLog(`[SETUP-ERROR] Failed to ensure directory ${dir}:`, e);
+            throw e;
         }
     }
 };
 
-// Define the base temporary directory using the OS's temp location and the unique run ID.
-// Using os.tmpdir() is generally safer regarding permissions and OS conventions.
 const tempDir = path.join(os.tmpdir(), 'portapack-tests', TEST_RUN_ID);
-
-/**
- * Object containing base paths for various test-related directories.
- * These are constructed relative to the main temporary directory.
- */
+// *** Make sure baseDirs is defined ***
+// (Assuming it was defined correctly before the placeholder comment)
 const baseDirs = {
-    root: resolve(), // Project root (where jest.config / setup file likely is)
-    output: path.join(tempDir, 'test-output'), // General output for test artifacts
-    fixtures: path.join(tempDir, '__fixtures__'), // Base for fixture data (if needed)
-    fixturesOutput: path.join(tempDir, '__fixtures__/output'), // Output specifically related to fixtures
-    sampleProject: path.join(tempDir, 'sample-project') // Directory for the mock HTML project
+    root: resolve(), // Project root
+    output: path.join(tempDir, 'test-output'), // General output
+    fixtures: path.join(tempDir, '__fixtures__'), // Base for fixtures
+    fixturesOutput: path.join(tempDir, '__fixtures__/output'), // Fixture output
+    sampleProject: path.join(tempDir, 'sample-project') // Mock project dir
 };
+// **********************************
 
-/**
- * Jest's global beforeAll hook. Runs once before any tests in a suite file execute.
- * Sets up the necessary directory structure and global variables/mocks for tests.
- */
+
+// --- Use Jest's GLOBAL beforeAll/afterAll/jest ---
+// These are available globally in setup files
 beforeAll(async () => {
-    console.log(`Setting up test environment in: ${tempDir}`); // Log setup start
+    originalSetupLog(`[SETUP] Starting setup in: ${tempDir}`);
 
-    // Create essential output/fixture directories early.
-    // Using Promise.all here is likely safe as they are independent paths.
+    originalSetupLog('[SETUP] Ensuring baseDirs...');
+    // Make sure baseDirs is defined before using it
+    if (!baseDirs || !baseDirs.output || !baseDirs.fixturesOutput) {
+        throw new Error("baseDirs is not properly defined!");
+    }
     await Promise.all([
         ensureDir(baseDirs.output),
         ensureDir(baseDirs.fixturesOutput)
     ]);
+    originalSetupLog('[SETUP] BaseDirs ensured.');
 
-    // Define paths specific to this test run using the TEST_RUN_ID for further isolation.
+    originalSetupLog('[SETUP] Creating runDirs...');
     const runDirs = {
         uniqueOutput: path.join(baseDirs.output, TEST_RUN_ID),
         uniqueFixturesOutput: path.join(baseDirs.fixturesOutput, TEST_RUN_ID)
     };
-
-    // Create the run-specific directories.
     await Promise.all([
         fs.mkdir(runDirs.uniqueOutput, { recursive: true }),
         fs.mkdir(runDirs.uniqueFixturesOutput, { recursive: true })
     ]);
+    originalSetupLog('[SETUP] RunDirs created.');
 
-    // --- Set up global variables accessible within tests ---
-    // This provides a consistent way for tests to access temporary paths.
-    global.__TEST_DIRECTORIES__ = {
-        ...baseDirs,
-        ...runDirs
-    };
-
-    // Helper function for tests to get a path within the unique test output directory.
-    global.getTestFilePath = (relPath) =>
-        path.join(global.__TEST_DIRECTORIES__.uniqueOutput, relPath);
-
-    // Helper function for tests to get a path within the unique fixture output directory.
-    global.getTestFixturePath = (relPath) =>
-        path.join(global.__TEST_DIRECTORIES__.uniqueFixturesOutput, relPath);
+    originalSetupLog('[SETUP] Setting globals...');
+    global.__TEST_DIRECTORIES__ = { ...baseDirs, ...runDirs };
+    global.getTestFilePath = (relPath) => path.join(global.__TEST_DIRECTORIES__.uniqueOutput, relPath);
+    global.getTestFixturePath = (relPath) => path.join(global.__TEST_DIRECTORIES__.uniqueFixturesOutput, relPath);
+    originalSetupLog('[SETUP] Globals set.');
 
-    // --- Create specific mock files needed by certain tests ---
-    // Example: Creating virtual font files for font processing tests.
-    await ensureDir(path.dirname(path.join(tempDir, 'font.woff2'))); // Ensure parent dir exists
+    originalSetupLog('[SETUP] Ensuring mock font dirs...');
+    if (!tempDir) throw new Error("tempDir is not defined before font dir creation!");
+    await ensureDir(path.dirname(path.join(tempDir, 'font.woff2')));
     await ensureDir(path.dirname(path.join(tempDir, 'font.ttf')));
-    // No need to ensureDir for 'missing.ttf' as we only need the path, not the file
+    originalSetupLog('[SETUP] Mock font dirs ensured.');
 
-    // Write mock content to the font files.
+    originalSetupLog('[SETUP] Writing mock font files...');
     await fs.writeFile(path.join(tempDir, 'font.woff2'), 'mock woff2 data');
     await fs.writeFile(path.join(tempDir, 'font.ttf'), 'mock ttf data');
-
-    // Set up a global variable pointing to the temp directory for potential use in mocks.
     global.__MOCK_FILE_PATH__ = tempDir;
+    originalSetupLog('[SETUP] Mock font files written.');
 
-    // --- Create the stub/mock sample HTML project ---
-    // **FIX APPLIED HERE:** Ensure directory exists *before* writing files into it
-    // to prevent ENOENT race conditions.
-
-    console.log(`Ensuring sample project directory exists: ${baseDirs.sampleProject}`);
-    // 1. Ensure the sample project directory exists FIRST
+    originalSetupLog('[SETUP] Ensuring sample project dir...');
+    if (!baseDirs || !baseDirs.sampleProject) throw new Error("baseDirs.sampleProject is not defined!");
     await ensureDir(baseDirs.sampleProject);
+    originalSetupLog('[SETUP] Sample project dir ensured.');
 
-    // 2. THEN write all the files into it using Promise.all for concurrency (safe now).
+    originalSetupLog('[SETUP] Writing sample project files...');
     try {
-        console.log(`Writing sample project files to ${baseDirs.sampleProject}...`);
         await Promise.all([
-            fs.writeFile(
-                path.join(baseDirs.sampleProject, 'index.html'),
-                `<!DOCTYPE html><html><head><link rel="stylesheet" href="styles.css"></head><body><img src="logo.png"/><script src="script.js"></script></body></html>`
-            ),
-            fs.writeFile(path.join(baseDirs.sampleProject, 'styles.css'), 'body { margin: 0; }'),
-            fs.writeFile(path.join(baseDirs.sampleProject, 'script.js'), `console.log('hello');`),
-            fs.writeFile(path.join(baseDirs.sampleProject, 'logo.png'), 'fake image data') // Using string for simplicity
+            fs.writeFile(path.join(baseDirs.sampleProject, 'index.html'), ``),
+            fs.writeFile(path.join(baseDirs.sampleProject, 'styles.css'), '/* Mock CSS */'),
+            fs.writeFile(path.join(baseDirs.sampleProject, 'script.js'), '// Mock JS'),
+            fs.writeFile(path.join(baseDirs.sampleProject, 'logo.png'), 'fake image data')
         ]);
-        console.log(`Successfully wrote sample project files.`);
+        originalSetupLog('[SETUP] Sample project files written.');
     } catch (writeError) {
-        console.error(`Failed to write sample project files to ${baseDirs.sampleProject}:`, writeError);
-        // Depending on setup needs, you might want to stop the tests here.
-        throw writeError; // Re-throw to potentially fail the setup.
+        originalSetupLog('[SETUP-ERROR] Failed to write sample project files:', writeError);
+        throw writeError;
     }
-    // --- End Fix ---
 
-    // --- Mock console methods ---
-    // This helps keep test output clean and allows assertions on console messages.
+    originalSetupLog('[SETUP] Mocking console...');
     const originalLog = console.log;
     const originalWarn = console.warn;
     const originalError = console.error;
+    // Use the GLOBAL `jest` object to access `fn`
+    global.console.log = jest.fn((...args) => { if (process.env.DEBUG) originalLog(...args); });
+    global.console.warn = jest.fn((...args) => { /* ... filtering logic ... */ if (process.env.DEBUG) originalWarn(...args); });
+    global.console.error = jest.fn((...args) => { if (process.env.DEBUG) originalError(...args); });
+    originalSetupLog('[SETUP] Console mocked.');
 
-    // Replace global console methods with Jest mocks.
-    global.console.log = jest.fn((...args) => {
-        // Only log to actual console if DEBUG environment variable is set.
-        if (process.env.DEBUG) {
-            originalLog(...args);
-        }
-    });
-
-    global.console.warn = jest.fn((...args) => {
-        // Optionally filter specific warnings you expect and don't want cluttering output.
-        const msg = args.join(' ');
-        if (
-            msg.includes('Could not fetch asset') ||
-            msg.includes('Error minifying')
-            // Add other expected warning patterns here if needed
-        ) {
-            return; // Suppress specific known warnings
-        }
-        // Log other warnings, potentially only in debug mode.
-        if (process.env.DEBUG) {
-            originalWarn(...args);
-        }
-    });
-
-    global.console.error = jest.fn((...args) => {
-        // Always show errors, especially in debug mode.
-        // Could add filtering if there are known, non-critical errors to ignore.
-        if (process.env.DEBUG) {
-            originalError(...args);
-        }
-        // Potentially log even without DEBUG for visibility during tests
-        // originalError(...args);
-    });
-
-    console.log("Test setup complete."); // Log setup finish
+    originalSetupLog("[SETUP] Test setup complete.");
 });
 
-/**
- * Jest's global afterAll hook. Runs once after all tests in a suite file have completed.
- * Cleans up the temporary directory created for the test run.
- */
 afterAll(async () => {
-    console.log(`Cleaning up test environment in: ${tempDir}`); // Log cleanup start
-    const dirs = global.__TEST_DIRECTORIES__; // Retrieve paths from global scope
-    if (!dirs) {
-        console.warn("Global test directories not found during cleanup.");
-        return;
-    }
-
+    originalSetupLog(`[SETUP] Cleaning up test environment in: ${tempDir}`);
     try {
-        // Recursively remove the entire temporary directory for this test run.
-        // Using force: true helps ignore errors if files are missing (e.g., cleanup already ran partially).
-        await fs.rm(tempDir, { recursive: true, force: true });
-        console.log(`Successfully cleaned up test directory: ${tempDir}`);
+        if (tempDir) {
+            await fs.rm(tempDir, { recursive: true, force: true });
+            originalSetupLog(`[SETUP] Successfully cleaned up: ${tempDir}`);
+        } else {
+            originalSetupLog(`[SETUP-WARN] tempDir variable was not defined during cleanup.`);
+        }
     } catch (e) {
-        // Log errors during cleanup but don't fail the tests typically.
-        // ENOENT means the directory was already gone, which is fine.
         if (e.code !== 'ENOENT') {
-            console.warn(`Could not fully clean test directory ${tempDir}:`, e.message);
+            originalSetupLog(`[SETUP-WARN] Could not fully clean test directory ${tempDir}:`, e.message);
         } else {
-            console.log(`Test directory already removed: ${tempDir}`);
+            originalSetupLog(`[SETUP] Test directory already removed: ${tempDir}`);
         }
     }
 });

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "portapack",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "📦 A tool to bundle and minify HTML and all its dependencies into a single portable file.",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "bin": {
-    "portapack": "./dist/cli/cli-entry.js"
+    "portapack": "./dist/cli/cli-entry.cjs"
   },
   "scripts": {
     "dev": "concurrently --success=all -n BUILD,DOCS,TEST -c green,blue,magenta \"npm run dev:build\" \"npm run dev:docs\" \"npm run dev:test\"",
     "dev:build": "tsup --watch",
     "dev:docs": "concurrently \"npm run docs:api:watch\" \"npm run docs:dev\"",
     "dev:test": "cross-env FORCE_COLOR=1 jest --watch --clearCache --passWithNoTests --watchPathIgnorePatterns=\"<rootDir>/tests/__fixtures__/output\"",
-    "dev:test:debug": "cross-env NODE_OPTIONS=--experimental-vm-modules FORCE_COLOR=1 jest --watch --runTestsByPath",
+    "dev:test:debug": "cross-env FORCE_COLOR=1 jest --watch --runTestsByPath",
     "build": "npm run build:code && npm run docs:api && npm run docs:build",
     "build:code": "tsup",
     "example": "npx tsx examples/main.ts",
-    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage",
-    "test:ci": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage --ci",
+    "test": "cross-env jest --coverage",
+    "test:ci": "cross-env jest --coverage --ci",
     "test:clear": "jest --clearCache",
     "coverage": "jest --coverage && open coverage/lcov-report/index.html",
     "docs:coverage": "npm run test && mkdir -p docs/test-coverage && cp -r coverage/lcov-report/* docs/test-coverage/",

package/src/cli/cli-entry.ts

@@ -1,28 +1,28 @@
 /**
  * @file cli-entry.ts
  * @description
- * Node.js entry point for PortaPack CLI (compatible with ESM).
- * 
- * Supports:
- * - Direct execution: `node cli-entry.js`
- * - Programmatic import for testing: `import { startCLI } from './cli-entry'`
+ * Safe Node.js CLI entrypoint for PortaPack, compatible with both ESM and CommonJS output.
  */
 
 import type { CLIResult } from '../types';
 
-/**
- * Starts the CLI by importing and invoking the main CLI logic.
- * 
- * @returns {Promise<CLIResult>} - Exit code and any captured output
- */
 const startCLI = async (): Promise<CLIResult> => {
-  const { main } = await import('./cli.js');
+  const { main } = await import('./cli.js'); // This stays ESM-friendly
   return await main(process.argv);
 };
 
-// If executed directly from the command line, run and exit.
-if (import.meta.url === `file://${process.argv[1]}`) {
-  startCLI().then(({ exitCode }) => process.exit(Number(exitCode))); // Cast exitCode to Number
+// Safe: if this file is the entry point, run the CLI
+if (require.main === module) {
+  startCLI()
+    .then(({ stdout, stderr, exitCode }) => {
+      if (stdout) process.stdout.write(stdout);
+      if (stderr) process.stderr.write(stderr);
+      process.exit(Number(exitCode));
+    })
+    .catch((err) => {
+      console.error('💥 Unhandled CLI error:', err);
+      process.exit(1);
+    });
 }
 
-export { startCLI };
+export { startCLI };