portapack 0.3.1 → 0.3.3

package/src/types.ts

@@ -18,7 +18,7 @@
  */
 export interface Asset {
   type: 'css' | 'js' | 'image' | 'font' | 'video' | 'audio' | 'other'; // Add video and audio
-  
+
   /** The resolved or original URL of the asset */
   url: string;
 
@@ -94,17 +94,16 @@ export interface BundleOptions {
 // --- LogLevel Enum ---
 // Defines available log levels as a numeric enum for comparisons.
 export enum LogLevel {
-  NONE = 0,   // No logging (equivalent to 'silent')
-  ERROR = 1,  // Only errors
-  WARN = 2,   // Errors and warnings
-  INFO = 3,   // Errors, warnings, and info (Default)
-  DEBUG = 4   // All messages (Verbose)
+  NONE = 0, // No logging (equivalent to 'silent')
+  ERROR = 1, // Only errors
+  WARN = 2, // Errors and warnings
+  INFO = 3, // Errors, warnings, and info (Default)
+  DEBUG = 4, // All messages (Verbose)
 }
 
 // --- String Literal Type for LogLevel Names (Optional, useful for CLI parsing) ---
 export type LogLevelName = 'debug' | 'info' | 'warn' | 'error' | 'silent' | 'none';
 
-
 /**
  * Summary statistics and metadata returned after the packing/bundling process completes.
  */
@@ -138,14 +137,13 @@ export interface BuildResult {
   metadata: BundleMetadata;
 }
 
-
 /** CLI-specific options extending BundleOptions. */
 export interface CLIOptions extends BundleOptions {
   /** Input file or URL (positional). */
   input?: string;
   /** Max depth for recursive crawling (numeric alias for recursive). */
-   maxDepth?: number; // Used by commander, then merged into 'recursive'
-   minify?: boolean; // Minify assets (defaults to true)
+  maxDepth?: number; // Used by commander, then merged into 'recursive'
+  minify?: boolean; // Minify assets (defaults to true)
 }
 
 /**
@@ -160,4 +158,4 @@ export interface CLIResult {
 
   /** Final exit code intended for the process (0 for success, non-zero for errors) */
   exitCode: number;
-}
+}

package/src/utils/font.ts

@@ -16,12 +16,18 @@ export function getFontMimeType(fontUrl: string): string {
   const ext = path.extname(fontUrl).toLowerCase().replace('.', '');
 
   switch (ext) {
-    case 'woff': return 'font/woff';
-    case 'woff2': return 'font/woff2';
-    case 'ttf': return 'font/ttf';
-    case 'otf': return 'font/otf';
-    case 'eot': return 'application/vnd.ms-fontobject';
-    default: return 'application/octet-stream';
+    case 'woff':
+      return 'font/woff';
+    case 'woff2':
+      return 'font/woff2';
+    case 'ttf':
+      return 'font/ttf';
+    case 'otf':
+      return 'font/otf';
+    case 'eot':
+      return 'application/vnd.ms-fontobject';
+    default:
+      return 'application/octet-stream';
   }
 }
 

package/src/utils/logger.ts

@@ -4,7 +4,6 @@
  * to control output verbosity throughout the application (core, API, CLI).
  */
 
-// FIX: Use a regular import for the enum, not 'import type'
 import { LogLevel } from '../types';
 // Assuming LogLevel enum is defined and exported in '../types' like:
 // export enum LogLevel { NONE = 0, ERROR = 1, WARN = 2, INFO = 3, DEBUG = 4 }
@@ -14,7 +13,7 @@ import { LogLevel } from '../types';
  * (Note: Currently constructor only accepts LogLevel directly)
  */
 export interface LoggerOptions {
-    level?: LogLevel;
+  level?: LogLevel;
 }
 
 /**
@@ -22,118 +21,124 @@ export interface LoggerOptions {
  * Uses standard console methods (debug, info, warn, error) for output.
  */
 export class Logger {
-    /** The current minimum log level required for a message to be output. */
-    public level: LogLevel;
+  /** The current minimum log level required for a message to be output. */
+  public level: LogLevel;
 
-    /**
-     * Creates a new Logger instance.
-     * Defaults to LogLevel.INFO if no level is provided.
-     *
-     * @param {LogLevel} [level=LogLevel.INFO] - The initial log level for this logger instance.
-     * Must be one of the values from the LogLevel enum.
-     */
-    constructor(level: LogLevel = LogLevel.INFO) { // Defaulting to INFO level using the enum value
-        // Ensure a valid LogLevel enum member is provided or default correctly
-        this.level = (level !== undefined && LogLevel[level] !== undefined)
-            ? level
-            : LogLevel.INFO; // Use the enum value for default
-    }
+  /**
+   * Creates a new Logger instance.
+   * Defaults to LogLevel.INFO if no level is provided.
+   *
+   * @param {LogLevel} [level=LogLevel.INFO] - The initial log level for this logger instance.
+   * Must be one of the values from the LogLevel enum.
+   */
+  constructor(level: LogLevel = LogLevel.INFO) {
+    // Defaulting to INFO level using the enum value
+    // Ensure a valid LogLevel enum member is provided or default correctly
+    this.level = level !== undefined && LogLevel[level] !== undefined ? level : LogLevel.INFO; // Use the enum value for default
+  }
 
-    /**
-     * Updates the logger's current level. Messages below this level will be suppressed.
-     *
-     * @param {LogLevel} level - The new log level to set. Must be a LogLevel enum member.
-     */
-    setLevel(level: LogLevel): void {
-        this.level = level;
-    }
+  /**
+   * Updates the logger's current level. Messages below this level will be suppressed.
+   *
+   * @param {LogLevel} level - The new log level to set. Must be a LogLevel enum member.
+   */
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
 
-    /**
-     * Logs a debug message if the current log level is DEBUG or higher.
-     *
-     * @param {string} message - The debug message string.
-     */
-    debug(message: string): void {
-        // Use enum member for comparison
-        if (this.level >= LogLevel.DEBUG) {
-            console.debug(`[DEBUG] ${message}`);
-        }
+  /**
+   * Logs a debug message if the current log level is DEBUG or higher.
+   *
+   * @param {string} message - The debug message string.
+   */
+  debug(message: string): void {
+    // Use enum member for comparison
+    if (this.level >= LogLevel.DEBUG) {
+      console.debug(`[DEBUG] ${message}`);
     }
+  }
 
-    /**
-     * Logs an informational message if the current log level is INFO or higher.
-     *
-     * @param {string} message - The informational message string.
-     */
-    info(message: string): void {
-        // Use enum member for comparison
-        if (this.level >= LogLevel.INFO) {
-            console.info(`[INFO] ${message}`);
-        }
+  /**
+   * Logs an informational message if the current log level is INFO or higher.
+   *
+   * @param {string} message - The informational message string.
+   */
+  info(message: string): void {
+    // Use enum member for comparison
+    if (this.level >= LogLevel.INFO) {
+      console.info(`[INFO] ${message}`);
     }
+  }
 
-    /**
-     * Logs a warning message if the current log level is WARN or higher.
-     *
-     * @param {string} message - The warning message string.
-     */
-    warn(message: string): void {
-        // Use enum member for comparison
-        if (this.level >= LogLevel.WARN) {
-            console.warn(`[WARN] ${message}`);
-        }
+  /**
+   * Logs a warning message if the current log level is WARN or higher.
+   *
+   * @param {string} message - The warning message string.
+   */
+  warn(message: string): void {
+    // Use enum member for comparison
+    if (this.level >= LogLevel.WARN) {
+      console.warn(`[WARN] ${message}`);
     }
+  }
 
-    /**
-     * Logs an error message if the current log level is ERROR or higher.
-     *
-     * @param {string} message - The error message string.
-     */
-    error(message: string): void {
-        // Use enum member for comparison
-        if (this.level >= LogLevel.ERROR) {
-            console.error(`[ERROR] ${message}`);
-        }
+  /**
+   * Logs an error message if the current log level is ERROR or higher.
+   *
+   * @param {string} message - The error message string.
+   */
+  error(message: string): void {
+    // Use enum member for comparison
+    if (this.level >= LogLevel.ERROR) {
+      console.error(`[ERROR] ${message}`);
     }
+  }
 
-    /**
-     * Static factory method to create a Logger instance based on a simple boolean `verbose` flag.
-     *
-     * @static
-     * @param {{ verbose?: boolean }} [options={}] - An object potentially containing a `verbose` flag.
-     * @returns {Logger} A new Logger instance set to LogLevel.DEBUG if options.verbose is true,
-     * otherwise set to LogLevel.INFO.
-     */
-    static fromVerboseFlag(options: { verbose?: boolean } = {}): Logger {
-        // Use enum members for assignment
-        return new Logger(options.verbose ? LogLevel.DEBUG : LogLevel.INFO);
-    }
+  /**
+   * Static factory method to create a Logger instance based on a simple boolean `verbose` flag.
+   *
+   * @static
+   * @param {{ verbose?: boolean }} [options={}] - An object potentially containing a `verbose` flag.
+   * @returns {Logger} A new Logger instance set to LogLevel.DEBUG if options.verbose is true,
+   * otherwise set to LogLevel.INFO.
+   */
+  static fromVerboseFlag(options: { verbose?: boolean } = {}): Logger {
+    // Use enum members for assignment
+    return new Logger(options.verbose ? LogLevel.DEBUG : LogLevel.INFO);
+  }
 
-     /**
-      * Static factory method to create a Logger instance based on a LogLevel string name.
-      * Useful for creating a logger from config files or environments variables.
-      *
-      * @static
-      * @param {string | undefined} levelName - The name of the log level (e.g., 'debug', 'info', 'warn', 'error', 'silent'/'none'). Case-insensitive.
-      * @param {LogLevel} [defaultLevel=LogLevel.INFO] - The level to use if levelName is invalid or undefined.
-      * @returns {Logger} A new Logger instance set to the corresponding LogLevel.
-      */
-     static fromLevelName(levelName?: string, defaultLevel: LogLevel = LogLevel.INFO): Logger {
-         if (!levelName) {
-             return new Logger(defaultLevel);
-         }
-         switch (levelName.toLowerCase()) {
-             // Return enum members
-             case 'debug': return new Logger(LogLevel.DEBUG);
-             case 'info': return new Logger(LogLevel.INFO);
-             case 'warn': return new Logger(LogLevel.WARN);
-             case 'error': return new Logger(LogLevel.ERROR);
-             case 'silent':
-             case 'none': return new Logger(LogLevel.NONE);
-             default:
-                 // Use console.warn directly here as logger might not be ready
-                 console.warn(`[Logger] Invalid log level name "${levelName}". Defaulting to ${LogLevel[defaultLevel]}.`);
-                 return new Logger(defaultLevel);
-         }
-     }
-}
+  /**
+   * Static factory method to create a Logger instance based on a LogLevel string name.
+   * Useful for creating a logger from config files or environments variables.
+   *
+   * @static
+   * @param {string | undefined} levelName - The name of the log level (e.g., 'debug', 'info', 'warn', 'error', 'silent'/'none'). Case-insensitive.
+   * @param {LogLevel} [defaultLevel=LogLevel.INFO] - The level to use if levelName is invalid or undefined.
+   * @returns {Logger} A new Logger instance set to the corresponding LogLevel.
+   */
+  static fromLevelName(levelName?: string, defaultLevel: LogLevel = LogLevel.INFO): Logger {
+    if (!levelName) {
+      return new Logger(defaultLevel);
+    }
+    switch (levelName.toLowerCase()) {
+      // Return enum members
+      case 'debug':
+        return new Logger(LogLevel.DEBUG);
+      case 'info':
+        return new Logger(LogLevel.INFO);
+      case 'warn':
+        return new Logger(LogLevel.WARN);
+      case 'error':
+        return new Logger(LogLevel.ERROR);
+      case 'silent':
+      case 'none':
+        return new Logger(LogLevel.NONE);
+      default:
+        // Use console.warn directly here as logger might not be ready
+        console.warn(
+          `[Logger] Invalid log level name "${levelName}". Defaulting to ${LogLevel[defaultLevel]}.`
+        );
+        return new Logger(defaultLevel);
+    }
+  }
+}

package/src/utils/meta.ts

@@ -12,89 +12,88 @@ import type { BundleMetadata } from '../types'; // Assuming types are in ../type
  * (asset counts, page counts, errors) during the HTML bundling process.
  */
 export class BuildTimer {
-    private startTime: number;
-    private input: string;
-    private pagesBundled?: number; // Tracks pages for recursive bundles
-    private assetCount: number = 0; // Tracks discovered/processed assets
-    private errors: string[] = []; // Collects warnings/errors
+  private startTime: number;
+  private input: string;
+  private pagesBundled?: number; // Tracks pages for recursive bundles
+  private assetCount: number = 0; // Tracks discovered/processed assets
+  private errors: string[] = []; // Collects warnings/errors
 
-    /**
-     * Creates and starts a build timer session for a given input.
-     *
-     * @param {string} input - The source file path or URL being processed.
-     */
-    constructor(input: string) {
-        this.startTime = Date.now();
-        this.input = input;
-    }
+  /**
+   * Creates and starts a build timer session for a given input.
+   *
+   * @param {string} input - The source file path or URL being processed.
+   */
+  constructor(input: string) {
+    this.startTime = Date.now();
+    this.input = input;
+  }
 
-    /**
-     * Explicitly sets the number of assets discovered or processed.
-     * This might be called after asset extraction/minification.
-     *
-     * @param {number} count - The total number of assets.
-     */
-    setAssetCount(count: number): void {
-        this.assetCount = count;
-    }
+  /**
+   * Explicitly sets the number of assets discovered or processed.
+   * This might be called after asset extraction/minification.
+   *
+   * @param {number} count - The total number of assets.
+   */
+  setAssetCount(count: number): void {
+    this.assetCount = count;
+  }
 
-    /**
-     * Records a warning or error message encountered during the build.
-     * These are added to the final metadata.
-     *
-     * @param {string} message - The warning or error description.
-     */
-    addError(message: string): void {
-        this.errors.push(message);
-    }
+  /**
+   * Records a warning or error message encountered during the build.
+   * These are added to the final metadata.
+   *
+   * @param {string} message - The warning or error description.
+   */
+  addError(message: string): void {
+    this.errors.push(message);
+  }
 
-    /**
-     * Sets the number of pages bundled, typically used in multi-page
-     * or recursive bundling scenarios.
-     *
-     * @param {number} count - The number of HTML pages included in the bundle.
-     */
-    setPageCount(count: number): void {
-        this.pagesBundled = count;
-    }
+  /**
+   * Sets the number of pages bundled, typically used in multi-page
+   * or recursive bundling scenarios.
+   *
+   * @param {number} count - The number of HTML pages included in the bundle.
+   */
+  setPageCount(count: number): void {
+    this.pagesBundled = count;
+  }
 
-    /**
-     * Stops the timer, calculates final metrics, and returns the complete
-     * BundleMetadata object. Merges any explicitly provided metadata
-     * (like assetCount calculated elsewhere) with the timer's tracked data.
-     *
-     * @param {string} finalHtml - The final generated HTML string, used to calculate output size.
-     * @param {Partial<BundleMetadata>} [extra] - Optional object containing metadata fields
-     * (like assetCount or pre-calculated errors) that should override the timer's internal values.
-     * @returns {BundleMetadata} The finalized metadata object for the build process.
-     */
-    finish(html: string, extra?: Partial<BundleMetadata>): BundleMetadata {
-      const buildTimeMs = Date.now() - this.startTime;
-      const outputSize = Buffer.byteLength(html || '', 'utf-8');
+  /**
+   * Stops the timer, calculates final metrics, and returns the complete
+   * BundleMetadata object. Merges any explicitly provided metadata
+   * (like assetCount calculated elsewhere) with the timer's tracked data.
+   *
+   * @param {string} finalHtml - The final generated HTML string, used to calculate output size.
+   * @param {Partial<BundleMetadata>} [extra] - Optional object containing metadata fields
+   * (like assetCount or pre-calculated errors) that should override the timer's internal values.
+   * @returns {BundleMetadata} The finalized metadata object for the build process.
+   */
+  finish(html: string, extra?: Partial<BundleMetadata>): BundleMetadata {
+    const buildTimeMs = Date.now() - this.startTime;
+    const outputSize = Buffer.byteLength(html || '', 'utf-8');
 
-      // Combine internal errors with any errors passed in 'extra', avoiding duplicates
-      // FIX: Ensure extra.errors is treated as an empty array if undefined/null
-      const combinedErrors = Array.from(new Set([...this.errors, ...(extra?.errors ?? [])]));
+    // Combine internal errors with any errors passed in 'extra', avoiding duplicates
+    const combinedErrors = Array.from(new Set([...this.errors, ...(extra?.errors ?? [])]));
 
-      const finalMetadata: BundleMetadata = {
-          input: this.input,
-          outputSize,
-          buildTimeMs,
-          assetCount: extra?.assetCount ?? this.assetCount,
-          pagesBundled: extra?.pagesBundled ?? this.pagesBundled,
-          // Assign the combined errors array
-          errors: combinedErrors,
-      };
+    const finalMetadata: BundleMetadata = {
+      input: this.input,
+      outputSize,
+      buildTimeMs,
+      assetCount: extra?.assetCount ?? this.assetCount,
+      pagesBundled: extra?.pagesBundled ?? this.pagesBundled,
+      // Assign the combined errors array
+      errors: combinedErrors,
+    };
 
-      // Clean up optional fields if they weren't set/provided or are empty
-      if (finalMetadata.pagesBundled === undefined) {
-          delete finalMetadata.pagesBundled;
-      }
-      // Delete errors only if the *combined* array is empty
-      if (finalMetadata.errors?.length === 0) {
-          delete finalMetadata.errors;
-      }
+    // Clean up optional fields if they weren't set/provided or are empty
+    if (finalMetadata.pagesBundled === undefined) {
+      delete finalMetadata.pagesBundled;
+    }
+    // Delete errors only if the *combined* array is empty
+    if (finalMetadata.errors?.length === 0) {
+      delete finalMetadata.errors;
+    }
 
-      return finalMetadata;
+    return finalMetadata;
   }
-}
+}

package/src/utils/mime.ts

@@ -10,46 +10,46 @@ import type { Asset } from '../types'; // Assuming types are in ../types
  * Maps common file extensions to their corresponding MIME types and general Asset types.
  */
 const MIME_MAP: Record<string, { mime: string; assetType: Asset['type'] }> = {
-    // CSS
-    '.css': { mime: 'text/css', assetType: 'css' },
-    // JavaScript
-    '.js': { mime: 'application/javascript', assetType: 'js' },
-    '.mjs': { mime: 'application/javascript', assetType: 'js' },
-    // Images
-    '.png': { mime: 'image/png', assetType: 'image' },
-    '.jpg': { mime: 'image/jpeg', assetType: 'image' },
-    '.jpeg': { mime: 'image/jpeg', assetType: 'image' },
-    '.gif': { mime: 'image/gif', assetType: 'image' },
-    '.svg': { mime: 'image/svg+xml', assetType: 'image' },
-    '.webp': { mime: 'image/webp', assetType: 'image' },
-    '.ico': { mime: 'image/x-icon', assetType: 'image' },
-    '.avif': { mime: 'image/avif', assetType: 'image' },
-    // Fonts
-    '.woff': { mime: 'font/woff', assetType: 'font' },
-    '.woff2': { mime: 'font/woff2', assetType: 'font' },
-    '.ttf': { mime: 'font/ttf', assetType: 'font' },
-    '.otf': { mime: 'font/otf', assetType: 'font' },
-    '.eot': { mime: 'application/vnd.ms-fontobject', assetType: 'font' },
-    // Audio/Video (add more as needed)
-    '.mp3': { mime: 'audio/mpeg', assetType: 'other' },
-    '.ogg': { mime: 'audio/ogg', assetType: 'other' },
-    '.wav': { mime: 'audio/wav', assetType: 'other' },
-    '.mp4': { mime: 'video/mp4', assetType: 'other' },
-    '.webm': { mime: 'video/webm', assetType: 'other' },
-    // Other common web types
-    '.json': { mime: 'application/json', assetType: 'other' },
-    '.webmanifest': { mime: 'application/manifest+json', assetType: 'other' },
-    '.xml': { mime: 'application/xml', assetType: 'other' },
-    '.html': { mime: 'text/html', assetType: 'other' }, // Usually not needed as asset, but for completeness
-    '.txt': { mime: 'text/plain', assetType: 'other' },
+  // CSS
+  '.css': { mime: 'text/css', assetType: 'css' },
+  // JavaScript
+  '.js': { mime: 'application/javascript', assetType: 'js' },
+  '.mjs': { mime: 'application/javascript', assetType: 'js' },
+  // Images
+  '.png': { mime: 'image/png', assetType: 'image' },
+  '.jpg': { mime: 'image/jpeg', assetType: 'image' },
+  '.jpeg': { mime: 'image/jpeg', assetType: 'image' },
+  '.gif': { mime: 'image/gif', assetType: 'image' },
+  '.svg': { mime: 'image/svg+xml', assetType: 'image' },
+  '.webp': { mime: 'image/webp', assetType: 'image' },
+  '.ico': { mime: 'image/x-icon', assetType: 'image' },
+  '.avif': { mime: 'image/avif', assetType: 'image' },
+  // Fonts
+  '.woff': { mime: 'font/woff', assetType: 'font' },
+  '.woff2': { mime: 'font/woff2', assetType: 'font' },
+  '.ttf': { mime: 'font/ttf', assetType: 'font' },
+  '.otf': { mime: 'font/otf', assetType: 'font' },
+  '.eot': { mime: 'application/vnd.ms-fontobject', assetType: 'font' },
+  // Audio/Video (add more as needed)
+  '.mp3': { mime: 'audio/mpeg', assetType: 'other' },
+  '.ogg': { mime: 'audio/ogg', assetType: 'other' },
+  '.wav': { mime: 'audio/wav', assetType: 'other' },
+  '.mp4': { mime: 'video/mp4', assetType: 'other' },
+  '.webm': { mime: 'video/webm', assetType: 'other' },
+  // Other common web types
+  '.json': { mime: 'application/json', assetType: 'other' },
+  '.webmanifest': { mime: 'application/manifest+json', assetType: 'other' },
+  '.xml': { mime: 'application/xml', assetType: 'other' },
+  '.html': { mime: 'text/html', assetType: 'other' }, // Usually not needed as asset, but for completeness
+  '.txt': { mime: 'text/plain', assetType: 'other' },
 };
 
 /**
  * Default MIME type and Asset type for unknown file extensions.
  */
 const DEFAULT_MIME_TYPE = {
-    mime: 'application/octet-stream',
-    assetType: 'other' as Asset['type'] // Explicit cast needed
+  mime: 'application/octet-stream',
+  assetType: 'other' as Asset['type'], // Explicit cast needed
 };
 
 /**
@@ -61,21 +61,21 @@ const DEFAULT_MIME_TYPE = {
  * if the extension is unknown.
  */
 export function guessMimeType(urlOrPath: string): { mime: string; assetType: Asset['type'] } {
-    if (!urlOrPath) {
-        return DEFAULT_MIME_TYPE;
-    }
-    // Extract the extension, handling potential query parameters or fragments
-    let ext = '';
-    try {
-        // Use URL parsing first to handle URLs correctly
-        const parsedUrl = new URL(urlOrPath);
-        ext = path.extname(parsedUrl.pathname).toLowerCase();
-    } catch {
-        // If it's not a valid URL, treat it as a path
-        ext = path.extname(urlOrPath).toLowerCase();
-    }
+  if (!urlOrPath) {
+    return DEFAULT_MIME_TYPE;
+  }
+  // Extract the extension, handling potential query parameters or fragments
+  let ext = '';
+  try {
+    // Use URL parsing first to handle URLs correctly
+    const parsedUrl = new URL(urlOrPath);
+    ext = path.extname(parsedUrl.pathname).toLowerCase();
+  } catch {
+    // If it's not a valid URL, treat it as a path
+    ext = path.extname(urlOrPath).toLowerCase();
+  }
 
-    return MIME_MAP[ext] || DEFAULT_MIME_TYPE;
+  return MIME_MAP[ext] || DEFAULT_MIME_TYPE;
 }
 
 /**
@@ -86,5 +86,5 @@ export function guessMimeType(urlOrPath: string): { mime: string; assetType: Ass
  * @returns {string} The corresponding font MIME type or a default.
  */
 export function getFontMimeType(fontUrl: string): string {
-    return guessMimeType(fontUrl).mime; // Delegate to the main function
-}
+  return guessMimeType(fontUrl).mime; // Delegate to the main function
+}