portapack 0.3.0 → 0.3.1

package/.github/workflows/ci.yml

@@ -23,11 +23,12 @@ jobs:
           cache: 'npm'
 
       - run: npm ci
-      # - run: npm run test:ci
-      # - run: npm run lint
-      # - run: npm run format:check
-      - run: npm run build # for now we keep it simple to release
+      - run: npm run test:ci
 
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
 # coverage:
 #   needs: build
 #   runs-on: ubuntu-latest

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.3.1](https://github.com/manicinc/portapack/compare/v0.3.0...v0.3.1) (2025-04-14)
+
+
+### Bug Fixes
+
+* **ci:** update Codecov config [skip release] ([593b126](https://github.com/manicinc/portapack/commit/593b1262183d05a9a7099463b6da0f4deb916576))
+* **extractor:** resolve test failures and coverage issues ([40ea42c](https://github.com/manicinc/portapack/commit/40ea42cbdbeec67657225c50eb97ef0965cd2769))
+
 # [0.3.0](https://github.com/manicinc/portapack/compare/v0.2.1...v0.3.0) (2025-04-13)
 
 

package/README.md

@@ -2,7 +2,8 @@
 
 [![npm version](https://img.shields.io/npm/v/portapack.svg?style=for-the-badge&logo=npm&color=CB3837)](https://www.npmjs.com/package/portapack)
 [![Build Status](https://img.shields.io/github/actions/workflow/status/manicinc/portapack/ci.yml?branch=master&style=for-the-badge&logo=github)](https://github.com/manicinc/portapack/actions)
-[![Coverage Status](https://img.shields.io/coveralls/github/manicinc/portapack?style=for-the-badge&logo=codecov)](https://coveralls.io/github/manicinc/portapack)
+[![Codecov](https://img.shields.io/codecov/c/github/manicinc/portapack?style=for-the-badge&logo=codecov)](https://codecov.io/gh/manicinc/portapack)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg?style=for-the-badge)](./LICENSE)
 
 **PortaPack** bundles your entire website — HTML, CSS, JS, images, and fonts — into one  self-contained HTML file. Perfect for snapshots, demos, testing, and offline apps.
 
@@ -125,15 +126,6 @@ import {
 | `fetchAndPackWebPage()` | Just fetch HTML (no asset processing) |
 | `bundleMultiPageHTML()` | Combine multiple HTMLs with router |
 
-## 🧪 Use Cases
-
-- Archive pages for offline use
-- Create demo bundles without a web server
-- Simplify distribution of small apps
-- QA test static assets
-- Embed pages in PDFs or ebooks
-- Analyze asset weight impact
-
 ## 🤝 Contribute
 
 ```bash
@@ -146,10 +138,13 @@ npm run dev
 
 ## 📊 Project Health
 
-(Metrics auto-generated coming soon)
+| Metric       | Value |
+|--------------|-------|
+| 📦 Version   | [![npm](https://img.shields.io/npm/v/portapack.svg)](https://www.npmjs.com/package/portapack) |
+| ✅ Build     | [![Build Status](https://img.shields.io/github/actions/workflow/status/manicinc/portapack/ci.yml?branch=master)](https://github.com/manicinc/portapack/actions) |
+| 🧪 Coverage  | [![Codecov](https://img.shields.io/codecov/c/github/manicinc/portapack)](https://codecov.io/gh/manicinc/portapack) |
 
 ## 📄 License
 
-MIT — Built with ✨ by Manic Agency
+MIT — Built by Manic.agency
 
-*Open Source Empowering Designers and Developers 🖥️*

package/dist/cli/cli-entry.cjs

@@ -326,7 +326,6 @@ function isUtf8DecodingLossy(originalBuffer, decodedString) {
   }
 }
 function determineBaseUrl(inputPathOrUrl, logger) {
-  console.log(`[DEBUG determineBaseUrl] Input: "${inputPathOrUrl}"`);
   logger?.debug(`Determining base URL for input: ${inputPathOrUrl}`);
   if (!inputPathOrUrl) {
     logger?.warn("Cannot determine base URL: inputPathOrUrl is empty or invalid.");
@@ -340,11 +339,9 @@ function determineBaseUrl(inputPathOrUrl, logger) {
       url.hash = "";
       const baseUrl = url.href;
       logger?.debug(`Determined remote base URL: ${baseUrl}`);
-      console.log(`[DEBUG determineBaseUrl] Determined Remote URL: "${baseUrl}"`);
       return baseUrl;
     } else if (inputPathOrUrl.includes("://") && !inputPathOrUrl.startsWith("file:")) {
       logger?.warn(`Input "${inputPathOrUrl}" looks like a URL but uses an unsupported protocol. Cannot determine base URL.`);
-      console.log(`[DEBUG determineBaseUrl] Unsupported protocol.`);
       return void 0;
     } else {
       let resourcePath;
@@ -360,9 +357,7 @@ function determineBaseUrl(inputPathOrUrl, logger) {
           isInputLikelyDirectory = false;
         }
       }
-      console.log(`[DEBUG determineBaseUrl] resourcePath: "${resourcePath}", isInputLikelyDirectory: ${isInputLikelyDirectory}`);
       const baseDirPath = isInputLikelyDirectory ? resourcePath : import_path2.default.dirname(resourcePath);
-      console.log(`[DEBUG determineBaseUrl] Calculated baseDirPath: "${baseDirPath}"`);
       let normalizedPathForURL = baseDirPath.replace(/\\/g, "/");
       if (/^[A-Z]:\//i.test(normalizedPathForURL) && !normalizedPathForURL.startsWith("/")) {
         normalizedPathForURL = "/" + normalizedPathForURL;
@@ -373,12 +368,10 @@ function determineBaseUrl(inputPathOrUrl, logger) {
       const fileUrl = new import_url.URL("file://" + normalizedPathForURL);
       const fileUrlString = fileUrl.href;
       logger?.debug(`Determined base URL: ${fileUrlString} (from: ${inputPathOrUrl}, resolved base dir: ${baseDirPath})`);
-      console.log(`[DEBUG determineBaseUrl] Determined File URL: "${fileUrlString}"`);
       return fileUrlString;
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(`[DEBUG determineBaseUrl] Error determining base URL: ${message}`);
     logger?.error(`\u{1F480} Failed to determine base URL for "${inputPathOrUrl}": ${message}${error instanceof Error && error.stack ? ` - Stack: ${error.stack}` : ""}`);
     return void 0;
   }
@@ -416,82 +409,69 @@ function resolveAssetUrl(assetUrl, baseContextUrl, logger) {
   }
 }
 function resolveCssRelativeUrl(relativeUrl, cssBaseContextUrl, logger) {
-  console.log(`[DEBUG resolveCssRelativeUrl] Input: relative="${relativeUrl}", base="${cssBaseContextUrl}"`);
   if (!relativeUrl || relativeUrl.startsWith("data:") || relativeUrl.startsWith("#")) {
     return null;
   }
   try {
     const resolvedUrl = new import_url.URL(relativeUrl, cssBaseContextUrl);
-    console.log(`[DEBUG resolveCssRelativeUrl] Resolved URL object href: "${resolvedUrl.href}"`);
     return resolvedUrl.href;
   } catch (error) {
     logger?.warn(
       `Failed to resolve CSS URL: "${relativeUrl}" relative to "${cssBaseContextUrl}": ${String(error)}`
     );
-    console.error(`[DEBUG resolveCssRelativeUrl] Error resolving: ${String(error)}`);
     return null;
   }
 }
 async function fetchAsset(resolvedUrl, logger, timeout = 1e4) {
-  console.log(`[DEBUG fetchAsset] Attempting fetch for URL: ${resolvedUrl.href}`);
   logger?.debug(`Attempting to fetch asset: ${resolvedUrl.href}`);
   const protocol = resolvedUrl.protocol;
   try {
     if (protocol === "http:" || protocol === "https:") {
       const response = await axiosNs.default.get(resolvedUrl.href, {
         responseType: "arraybuffer",
+        // Fetch as binary data
         timeout
+        // Apply network timeout
       });
       logger?.debug(`Workspaceed remote asset ${resolvedUrl.href} (Status: ${response.status}, Type: ${response.headers["content-type"] || "N/A"}, Size: ${response.data?.byteLength ?? 0} bytes)`);
-      console.log(`[DEBUG fetchAsset] HTTP fetch SUCCESS for: ${resolvedUrl.href}, Status: ${response.status}`);
       return Buffer.from(response.data);
     } else if (protocol === "file:") {
       let filePath;
       try {
         filePath = (0, import_url.fileURLToPath)(resolvedUrl);
       } catch (e) {
-        console.error(`[DEBUG fetchAsset] fileURLToPath FAILED for: ${resolvedUrl.href}`, e);
         logger?.error(`Could not convert file URL to path: ${resolvedUrl.href}. Error: ${e.message}`);
         return null;
       }
       const normalizedForLog = import_path2.default.normalize(filePath);
-      console.log(`[DEBUG fetchAsset] Attempting readFile with path: "${normalizedForLog}" (Original from URL: "${filePath}")`);
       const data = await (0, import_promises.readFile)(filePath);
-      console.log(`[DEBUG fetchAsset] readFile call SUCCEEDED for path: "${normalizedForLog}". Data length: ${data?.byteLength}`);
       logger?.debug(`Read local file ${filePath} (${data.byteLength} bytes)`);
       return data;
     } else {
-      console.log(`[DEBUG fetchAsset] Unsupported protocol: ${protocol}`);
       logger?.warn(`Unsupported protocol "${protocol}" in URL: ${resolvedUrl.href}`);
       return null;
     }
   } catch (error) {
     const failedId = protocol === "file:" ? import_path2.default.normalize((0, import_url.fileURLToPath)(resolvedUrl)) : resolvedUrl.href;
-    console.error(`[DEBUG fetchAsset] fetch/read FAILED for: "${failedId}". Error:`, error);
-    if ((protocol === "http:" || protocol === "https:") && axiosNs.isAxiosError(error)) {
-      const status = error.response?.status ?? "N/A";
-      const statusText = error.response?.statusText ?? "Error";
-      const code = error.code ?? "N/A";
-      const message = error.message;
-      const logMessage = `\u26A0\uFE0F Failed to fetch remote asset ${resolvedUrl.href}: Status ${status} - ${statusText}. Code: ${code}, Message: ${message}`;
+    if ((protocol === "http:" || protocol === "https:") && error?.isAxiosError === true) {
+      const axiosError = error;
+      const status = axiosError.response?.status ?? "N/A";
+      const code = axiosError.code ?? "N/A";
+      const logMessage = `\u26A0\uFE0F Failed to fetch remote asset ${resolvedUrl.href}: ${axiosError.message} (Code: ${code})`;
       logger?.warn(logMessage);
-    }
-    if (error instanceof Error && error.code === "ENOENT") {
+    } else if (protocol === "file:" && error instanceof Error) {
       let failedPath = resolvedUrl.href;
       try {
         failedPath = (0, import_url.fileURLToPath)(resolvedUrl);
       } catch {
       }
       failedPath = import_path2.default.normalize(failedPath);
-      if (error instanceof Error && error.code === "ENOENT") {
+      if (error.code === "ENOENT") {
         logger?.warn(`\u26A0\uFE0F File not found (ENOENT) for asset: ${failedPath}.`);
-      } else if (error instanceof Error && error.code === "EACCES") {
+      } else if (error.code === "EACCES") {
         logger?.warn(`\u26A0\uFE0F Permission denied (EACCES) reading asset: ${failedPath}.`);
-        logger?.warn(`\u26A0\uFE0F Failed to read local asset ${failedPath}: ${error.message}`);
-      } else if (error instanceof Error) {
-        logger?.warn(`\u26A0\uFE0F Failed to read local asset ${failedPath}: ${error.message}`);
       } else {
-        logger?.warn(`\u26A0\uFE0F An unknown error occurred while reading local asset ${failedPath}: ${String(error)}`);
+        logger?.warn(`\u26A0\uFE0F Failed to read local asset ${failedPath}: ${error.message}`);
       }
     } else if (error instanceof Error) {
       logger?.warn(`\u26A0\uFE0F An unexpected error occurred processing asset ${resolvedUrl.href}: ${error.message}`);
@@ -507,7 +487,7 @@ function extractUrlsFromCSS(cssContent, cssBaseContextUrl, logger) {
   const urlRegex = /url\(\s*(['"]?)(.*?)\1\s*\)/gi;
   const importRegex = /@import\s+(?:url\(\s*(['"]?)(.*?)\1\s*\)|(['"])(.*?)\3)\s*;/gi;
   const processFoundUrl = (rawUrl, ruleType) => {
-    if (!rawUrl || rawUrl.trim() === "" || rawUrl.startsWith("data:")) return;
+    if (!rawUrl || rawUrl.trim() === "" || rawUrl.startsWith("data:") || rawUrl.startsWith("#")) return;
     const resolvedUrl = resolveCssRelativeUrl(rawUrl, cssBaseContextUrl, logger);
     if (resolvedUrl && !processedInThisParse.has(resolvedUrl)) {
       processedInThisParse.add(resolvedUrl);
@@ -515,7 +495,7 @@ function extractUrlsFromCSS(cssContent, cssBaseContextUrl, logger) {
       newlyDiscovered.push({
         type: assetType,
         url: resolvedUrl,
-        // The resolved absolute URL string
+        // Store the resolved absolute URL string
         content: void 0
         // Content will be fetched later if needed
       });
@@ -552,7 +532,7 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
       continue;
     }
     const urlToQueue = resolvedUrlObj.href;
-    if (!urlToQueue.startsWith("data:") && !processedOrQueuedUrls.has(urlToQueue)) {
+    if (!processedOrQueuedUrls.has(urlToQueue)) {
       processedOrQueuedUrls.add(urlToQueue);
       const { assetType: guessedType } = guessMimeType(urlToQueue);
       const initialType = asset.type ?? guessedType;
@@ -561,10 +541,9 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
         // Use the resolved URL
         type: initialType,
         content: void 0
+        // Content is initially undefined
       });
       logger?.debug(` -> Queued initial asset: ${urlToQueue} (Original raw: ${asset.url})`);
-    } else if (urlToQueue.startsWith("data:")) {
-      logger?.debug(` -> Skipping data URI: ${urlToQueue.substring(0, 50)}...`);
     } else {
       logger?.debug(` -> Skipping already processed/queued initial asset: ${urlToQueue}`);
     }
@@ -684,7 +663,7 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
           const newlyDiscoveredAssets = extractUrlsFromCSS(
             cssContentForParsing,
             cssBaseContextUrl,
-            // Use CSS file's base URL
+            // Use the CSS file's own URL as the base
             logger
           );
           if (newlyDiscoveredAssets.length > 0) {
@@ -705,7 +684,7 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
       }
     }
   }
-  const finalIterationCount = iterationCount > MAX_ASSET_EXTRACTION_ITERATIONS ? "MAX+" : iterationCount;
+  const finalIterationCount = iterationCount > MAX_ASSET_EXTRACTION_ITERATIONS ? `${MAX_ASSET_EXTRACTION_ITERATIONS}+ (limit hit)` : iterationCount;
   logger?.info(`\u2705 Asset extraction COMPLETE! Found ${finalAssetsMap.size} unique assets in ${finalIterationCount} iterations.`);
   return {
     htmlContent: parsed.htmlContent,