npm - portapack - Versions diffs - 0.2.1 - Mend

portapack 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (76) hide show

package/.eslintrc.json +9 -0
package/.github/workflows/ci.yml +73 -0
package/.github/workflows/deploy-pages.yml +56 -0
package/.prettierrc +9 -0
package/.releaserc.js +29 -0
package/CHANGELOG.md +21 -0
package/README.md +288 -0
package/commitlint.config.js +36 -0
package/dist/cli/cli-entry.js +1694 -0
package/dist/cli/cli-entry.js.map +1 -0
package/dist/index.d.ts +275 -0
package/dist/index.js +1405 -0
package/dist/index.js.map +1 -0
package/docs/.vitepress/config.ts +89 -0
package/docs/.vitepress/sidebar-generator.ts +73 -0
package/docs/cli.md +117 -0
package/docs/code-of-conduct.md +65 -0
package/docs/configuration.md +151 -0
package/docs/contributing.md +107 -0
package/docs/demo.md +46 -0
package/docs/deployment.md +132 -0
package/docs/development.md +168 -0
package/docs/getting-started.md +106 -0
package/docs/index.md +40 -0
package/docs/portapack-transparent.png +0 -0
package/docs/portapack.jpg +0 -0
package/docs/troubleshooting.md +107 -0
package/examples/main.ts +118 -0
package/examples/sample-project/index.html +12 -0
package/examples/sample-project/logo.png +1 -0
package/examples/sample-project/script.js +1 -0
package/examples/sample-project/styles.css +1 -0
package/jest.config.ts +124 -0
package/jest.setup.cjs +211 -0
package/nodemon.json +11 -0
package/output.html +1 -0
package/package.json +161 -0
package/site-packed.html +1 -0
package/src/cli/cli-entry.ts +28 -0
package/src/cli/cli.ts +139 -0
package/src/cli/options.ts +151 -0
package/src/core/bundler.ts +201 -0
package/src/core/extractor.ts +618 -0
package/src/core/minifier.ts +233 -0
package/src/core/packer.ts +191 -0
package/src/core/parser.ts +115 -0
package/src/core/web-fetcher.ts +292 -0
package/src/index.ts +262 -0
package/src/types.ts +163 -0
package/src/utils/font.ts +41 -0
package/src/utils/logger.ts +139 -0
package/src/utils/meta.ts +100 -0
package/src/utils/mime.ts +90 -0
package/src/utils/slugify.ts +70 -0
package/test-output.html +0 -0
package/tests/__fixtures__/sample-project/index.html +5 -0
package/tests/unit/cli/cli-entry.test.ts +104 -0
package/tests/unit/cli/cli.test.ts +230 -0
package/tests/unit/cli/options.test.ts +316 -0
package/tests/unit/core/bundler.test.ts +287 -0
package/tests/unit/core/extractor.test.ts +1129 -0
package/tests/unit/core/minifier.test.ts +414 -0
package/tests/unit/core/packer.test.ts +193 -0
package/tests/unit/core/parser.test.ts +540 -0
package/tests/unit/core/web-fetcher.test.ts +374 -0
package/tests/unit/index.test.ts +339 -0
package/tests/unit/utils/font.test.ts +81 -0
package/tests/unit/utils/logger.test.ts +275 -0
package/tests/unit/utils/meta.test.ts +70 -0
package/tests/unit/utils/mime.test.ts +96 -0
package/tests/unit/utils/slugify.test.ts +71 -0
package/tsconfig.build.json +11 -0
package/tsconfig.jest.json +17 -0
package/tsconfig.json +20 -0
package/tsup.config.ts +71 -0
package/typedoc.json +28 -0

package/tests/unit/core/minifier.test.ts ADDED Viewed

@@ -0,0 +1,414 @@
+/**
+ * @file tests/unit/core/minifier.test.ts
+ * @description Unit tests for the Minifier module (minifyAssets function).
+ * Uses jest.unstable_mockModule for mocking dependencies.
+ */
+// --- Imports ---
+import type { Options as HtmlMinifyOptions } from 'html-minifier-terser';
+import type { Options as CleanCSSOptions, Output as CleanCSSOutput } from 'clean-css';
+import type { MinifyOptions, MinifyOutput } from 'terser';
+import type { ParsedHTML, BundleOptions, Asset } from '../../../src/types';
+import { Logger } from '../../../src/utils/logger';
+import { jest, describe, it, expect, beforeEach } from '@jest/globals';
+// =================== MOCK SETUP ===================
+const mockHtmlMinifierMinifyFn = jest.fn<any>();
+const mockCleanCSSInstanceMinifyFn = jest.fn<any>();
+const mockCleanCSSConstructorFn = jest.fn<any>();
+const mockTerserMinifyFn = jest.fn<any>();
+// Mock the dependencies BEFORE importing the module under test
+jest.unstable_mockModule('html-minifier-terser', () => ({
+  minify: mockHtmlMinifierMinifyFn,
+}));
+jest.unstable_mockModule('clean-css', () => ({
+  // Mock the default export which is the class constructor
+  default: mockCleanCSSConstructorFn,
+}));
+jest.unstable_mockModule('terser', () => ({
+  minify: mockTerserMinifyFn,
+}));
+// ====================================================
+// Import the module under test *after* mocks are set up
+const { minifyAssets } = await import('../../../src/core/minifier');
+const { LogLevel: LogLevelEnum } = await import('../../../src/types');
+// Helper for basic CSS mock logic (can be simple for tests)
+const simpleMockCssMinify = (css: string): string => {
+    return css
+      .replace(/\/\*.*?\*\//g, '') // Remove comments
+      .replace(/\s*([{}:;,])\s*/g, '$1') // Remove space around syntax chars
+      .replace(/\s+/g, ' ') // Collapse remaining whitespace
+      .replace(/;}/g, '}') // Remove trailing semicolons inside blocks
+      .trim();
+}
+describe('🧼 Minifier', () => {
+    let mockLogger: Logger;
+    let mockLoggerWarnFn: jest.SpiedFunction<typeof Logger.prototype.warn>;
+    let mockLoggerDebugFn: jest.SpiedFunction<typeof Logger.prototype.debug>;
+    const sampleHtmlContent = '<html> <head> <title> Test </title> </head> <body> Test Content </body> </html>';
+    // This is the EXPECTED output after full minification by the real library
+    const minifiedHtmlContent = '<html><head><title>Test</title></head><body>Test Content</body></html>';
+    const sampleCssContent = ' body { color: blue; /* comment */ } ';
+    // Expected CSS output from our simple mock helper
+    const minifiedCssContent = 'body{color:blue}';
+    const sampleJsContent = ' function hello ( name ) { console.log("hello", name ); alert ( 1 ) ; } ';
+    // Expected JS output (can be a fixed string for the mock)
+    const minifiedJsContent = 'function hello(o){console.log("hello",o),alert(1)}';
+    const sampleParsedInput: ParsedHTML = {
+        htmlContent: sampleHtmlContent,
+        assets: [
+            { type: 'css', url: 'style.css', content: sampleCssContent },
+            { type: 'js', url: 'script.js', content: sampleJsContent },
+            { type: 'image', url: 'logo.png', content: 'data:image/png;base64,abc' },
+        ]
+    };
+    beforeEach(() => {
+        jest.clearAllMocks(); // Clear mocks between tests
+        // Set up logger spies
+        mockLogger = new Logger(LogLevelEnum.DEBUG); // Use DEBUG to see verbose logs if needed
+        mockLoggerWarnFn = jest.spyOn(mockLogger, 'warn');
+        mockLoggerDebugFn = jest.spyOn(mockLogger, 'debug');
+        // --- Configure Mock Implementations ---
+        // FIX: HTML Mock: Directly return the expected fully minified string.
+        // The mock should simulate the *result* of html-minifier-terser with collapseWhitespace: true.
+        mockHtmlMinifierMinifyFn.mockImplementation(async (_html: string, _options?: HtmlMinifyOptions) => {
+            // Assume if this mock is called, the desired output is the fully minified version
+            return minifiedHtmlContent;
+        });
+        // Mock the CleanCSS constructor to return an object with a 'minify' method
+        mockCleanCSSConstructorFn.mockImplementation(() => ({
+            minify: mockCleanCSSInstanceMinifyFn
+        }));
+        // Default mock for successful CleanCSS run (synchronous behavior)
+        // Uses the simple helper defined above
+        mockCleanCSSInstanceMinifyFn.mockImplementation((css: string): CleanCSSOutput => {
+            const minifiedStyles = simpleMockCssMinify(css);
+            const stats = { // Provide mock stats structure
+                originalSize: css.length,
+                minifiedSize: minifiedStyles.length,
+                efficiency: css.length > 0 ? (css.length - minifiedStyles.length) / css.length : 0,
+                timeSpent: 1, // Mock time
+            };
+            // Return the structure expected by the code (CleanCSSSyncResult shape)
+            return { styles: minifiedStyles, errors: [], warnings: [], stats: stats };
+        });
+        // Default mock for successful Terser run (asynchronous)
+        mockTerserMinifyFn.mockImplementation(async (_js: string, _options?: MinifyOptions): Promise<MinifyOutput> => {
+            // Return the expected minified JS content for the test case
+            return Promise.resolve({ code: minifiedJsContent, error: undefined });
+        });
+    });
+    describe('Basic functionality', () => {
+        it('✅ leaves content unchanged when minification is disabled', async () => {
+            const options: BundleOptions = { minifyHtml: false, minifyCss: false, minifyJs: false };
+            const result = await minifyAssets(sampleParsedInput, options, mockLogger);
+            expect(mockHtmlMinifierMinifyFn).not.toHaveBeenCalled();
+            expect(mockCleanCSSConstructorFn).not.toHaveBeenCalled(); // Check constructor wasn't called
+            expect(mockTerserMinifyFn).not.toHaveBeenCalled();
+            expect(result.htmlContent).toBe(sampleHtmlContent); // Should be original
+            expect(result.assets.find(a => a.type === 'css')?.content).toBe(sampleCssContent); // Should be original
+            expect(result.assets.find(a => a.type === 'js')?.content).toBe(sampleJsContent); // Should be original
+            expect(result.assets.find(a => a.type === 'image')?.content).toBe('data:image/png;base64,abc'); // Should be untouched
+        });
+        // Check against the corrected expectations
+        it('🔧 minifies HTML, CSS, and JS with all options enabled (default)', async () => {
+            const result = await minifyAssets(sampleParsedInput, {}, mockLogger); // Default options enable all minification
+            expect(mockHtmlMinifierMinifyFn).toHaveBeenCalledTimes(1);
+            // Check the *instance* minify was called, implies constructor was called too
+            expect(mockCleanCSSInstanceMinifyFn).toHaveBeenCalledTimes(1);
+            expect(mockTerserMinifyFn).toHaveBeenCalledTimes(1);
+            // Check against the defined minified constants
+            expect(result.htmlContent).toBe(minifiedHtmlContent);
+            expect(result.assets.find(a => a.type === 'css')?.content).toBe(minifiedCssContent);
+            expect(result.assets.find(a => a.type === 'js')?.content).toBe(minifiedJsContent);
+            expect(result.assets.find(a => a.type === 'image')?.content).toBe('data:image/png;base64,abc'); // Should still be untouched
+        });
+    });
+    describe('Error handling', () => {
+        it('💥 handles broken HTML minification gracefully', async () => {
+            const htmlError = new Error('HTML parse error!');
+            // Make the HTML mock reject
+            mockHtmlMinifierMinifyFn.mockRejectedValueOnce(htmlError);
+            const result = await minifyAssets(sampleParsedInput, {}, mockLogger);
+            // Original HTML should be kept
+            expect(result.htmlContent).toBe(sampleHtmlContent);
+            // Other assets should still be minified if successful
+            expect(result.assets.find(a => a.type === 'css')?.content).toBe(minifiedCssContent);
+            expect(result.assets.find(a => a.type === 'js')?.content).toBe(minifiedJsContent);
+            // Logger should have been warned
+            expect(mockLoggerWarnFn).toHaveBeenCalledWith(expect.stringContaining(`HTML minification failed: ${htmlError.message}`));
+            // Ensure other minifiers were still called
+            expect(mockCleanCSSInstanceMinifyFn).toHaveBeenCalledTimes(1);
+            expect(mockTerserMinifyFn).toHaveBeenCalledTimes(1);
+        });
+        it('💥 handles CSS minifier failure (returning errors array)', async () => {
+            const cssErrorMsg = 'Invalid CSS syntax';
+            // Make the CSS mock return an error structure
+            mockCleanCSSInstanceMinifyFn.mockReturnValueOnce({
+                errors: [cssErrorMsg], warnings: [], styles: undefined, // No styles on error
+                stats: { originalSize: sampleCssContent.length, minifiedSize: 0, efficiency: 0, timeSpent: 0 }
+            });
+            const result = await minifyAssets(sampleParsedInput, {}, mockLogger);
+            // HTML and JS should still be minified
+            expect(result.htmlContent).toBe(minifiedHtmlContent);
+            expect(result.assets.find(a => a.type === 'js')?.content).toBe(minifiedJsContent);
+            // Original CSS should be kept
+            expect(result.assets.find(a => a.type === 'css')?.content).toBe(sampleCssContent);
+            // Logger should have been warned
+            expect(mockLoggerWarnFn).toHaveBeenCalledWith(expect.stringContaining(`CleanCSS failed for style.css: ${cssErrorMsg}`));
+            // Ensure other minifiers were still called
+            expect(mockHtmlMinifierMinifyFn).toHaveBeenCalledTimes(1);
+            expect(mockTerserMinifyFn).toHaveBeenCalledTimes(1);
+        });
+        it('💥 handles CSS minifier failure (throwing exception)', async () => {
+            const cssError = new Error('CleanCSS crashed!');
+            // Make the CSS mock throw
+            mockCleanCSSInstanceMinifyFn.mockImplementationOnce(() => { throw cssError; });
+            const result = await minifyAssets(sampleParsedInput, {}, mockLogger);
+            // HTML and JS should still be minified
+            expect(result.htmlContent).toBe(minifiedHtmlContent);
+            expect(result.assets.find(a => a.type === 'js')?.content).toBe(minifiedJsContent);
+            // Original CSS should be kept
+            expect(result.assets.find(a => a.type === 'css')?.content).toBe(sampleCssContent);
+            // Logger should have been warned about the catch block
+            expect(mockLoggerWarnFn).toHaveBeenCalledWith(expect.stringContaining(`Failed to minify asset style.css (css): ${cssError.message}`));
+             // Ensure other minifiers were still called
+             expect(mockHtmlMinifierMinifyFn).toHaveBeenCalledTimes(1);
+             expect(mockTerserMinifyFn).toHaveBeenCalledTimes(1);
+        });
+        it('💥 handles JS minifier failure (returning error object)', async () => {
+            const jsError = new Error('Terser parse error!');
+             // Make the JS mock return an error structure (as per Terser docs)
+            mockTerserMinifyFn.mockResolvedValueOnce({ code: undefined, error: jsError });
+            const result = await minifyAssets(sampleParsedInput, {}, mockLogger);
+            // HTML and CSS should still be minified
+            expect(result.htmlContent).toBe(minifiedHtmlContent);
+            expect(result.assets.find(a => a.type === 'css')?.content).toBe(minifiedCssContent);
+             // Original JS should be kept
+            expect(result.assets.find(a => a.type === 'js')?.content).toBe(sampleJsContent);
+            // Logger should have been warned
+            // Note: Your code checks for `result.code` first, then `(result as any).error`
+            expect(mockLoggerWarnFn).toHaveBeenCalledWith(expect.stringContaining(`Terser failed for script.js: ${jsError.message}`));
+             // Ensure other minifiers were still called
+             expect(mockHtmlMinifierMinifyFn).toHaveBeenCalledTimes(1);
+             expect(mockCleanCSSInstanceMinifyFn).toHaveBeenCalledTimes(1);
+        });
+         it('💥 handles JS minifier failure (throwing exception)', async () => {
+             const jsError = new Error('Terser crashed!');
+             // Make the JS mock reject
+             mockTerserMinifyFn.mockRejectedValueOnce(jsError);
+             const result = await minifyAssets(sampleParsedInput, {}, mockLogger);
+             // HTML and CSS should still be minified
+             expect(result.htmlContent).toBe(minifiedHtmlContent);
+             expect(result.assets.find(a => a.type === 'css')?.content).toBe(minifiedCssContent);
+              // Original JS should be kept
+             expect(result.assets.find(a => a.type === 'js')?.content).toBe(sampleJsContent);
+             // Logger should have been warned from the catch block
+             expect(mockLoggerWarnFn).toHaveBeenCalledWith(expect.stringContaining(`Failed to minify asset script.js (js): ${jsError.message}`));
+             // Ensure other minifiers were still called
+             expect(mockHtmlMinifierMinifyFn).toHaveBeenCalledTimes(1);
+             expect(mockCleanCSSInstanceMinifyFn).toHaveBeenCalledTimes(1);
+         });
+        it('🧼 skips minification for assets without content or empty content', async () => {
+            const inputWithMissingContent: ParsedHTML = {
+                htmlContent: sampleHtmlContent,
+                assets: [
+                    { type: 'css', url: 'style.css', content: sampleCssContent }, // Has content
+                    { type: 'js', url: 'missing.js' /* no content property */ },
+                    { type: 'css', url: 'empty.css', content: '' }, // Empty string content
+                    { type: 'js', url: 'script2.js', content: sampleJsContent } // Has content
+                ]
+            };
+            const result = await minifyAssets(inputWithMissingContent, {}, mockLogger);
+            // Check assets individually
+            expect(result.assets.find(a => a.url === 'style.css')?.content).toBe(minifiedCssContent); // Minified
+            expect(result.assets.find(a => a.url === 'missing.js')?.content).toBeUndefined(); // Still undefined
+            expect(result.assets.find(a => a.url === 'empty.css')?.content).toBe(''); // Still empty
+            expect(result.assets.find(a => a.url === 'script2.js')?.content).toBe(minifiedJsContent); // Minified
+            // HTML should still be minified
+            expect(result.htmlContent).toBe(minifiedHtmlContent);
+            // Check how many times minifiers were actually called
+            expect(mockCleanCSSInstanceMinifyFn).toHaveBeenCalledTimes(1); // Only for style.css
+            expect(mockTerserMinifyFn).toHaveBeenCalledTimes(1); // Only for script2.js
+            expect(mockHtmlMinifierMinifyFn).toHaveBeenCalledTimes(1); // For the HTML
+        });
+    });
+    describe('Selective minification', () => {
+        it('🎛 only minifies CSS + HTML, leaves JS unchanged', async () => {
+            const options: BundleOptions = { minifyHtml: true, minifyCss: true, minifyJs: false };
+            const result = await minifyAssets(sampleParsedInput, options, mockLogger);
+            expect(mockHtmlMinifierMinifyFn).toHaveBeenCalledTimes(1);
+            expect(mockCleanCSSInstanceMinifyFn).toHaveBeenCalledTimes(1);
+            expect(mockTerserMinifyFn).not.toHaveBeenCalled(); // JS shouldn't be called
+            expect(result.htmlContent).toBe(minifiedHtmlContent); // Minified
+            expect(result.assets.find(a => a.type === 'css')?.content).toBe(minifiedCssContent); // Minified
+            expect(result.assets.find(a => a.type === 'js')?.content).toBe(sampleJsContent); // Original
+        });
+        it('🎛 only minifies JS + CSS, leaves HTML unchanged', async () => {
+            const options: BundleOptions = { minifyHtml: false, minifyCss: true, minifyJs: true };
+            const result = await minifyAssets(sampleParsedInput, options, mockLogger);
+            expect(mockHtmlMinifierMinifyFn).not.toHaveBeenCalled(); // HTML shouldn't be called
+            expect(mockCleanCSSInstanceMinifyFn).toHaveBeenCalledTimes(1);
+            expect(mockTerserMinifyFn).toHaveBeenCalledTimes(1);
+            expect(result.htmlContent).toBe(sampleHtmlContent); // Original
+            expect(result.assets.find(a => a.type === 'css')?.content).toBe(minifiedCssContent); // Minified
+            expect(result.assets.find(a => a.type === 'js')?.content).toBe(minifiedJsContent); // Minified
+        });
+         it('🎛 only minifies HTML, leaves CSS/JS unchanged', async () => {
+             const options: BundleOptions = { minifyHtml: true, minifyCss: false, minifyJs: false };
+             const result = await minifyAssets(sampleParsedInput, options, mockLogger);
+             expect(mockHtmlMinifierMinifyFn).toHaveBeenCalledTimes(1);
+             expect(mockCleanCSSInstanceMinifyFn).not.toHaveBeenCalled();
+             expect(mockTerserMinifyFn).not.toHaveBeenCalled();
+             expect(result.htmlContent).toBe(minifiedHtmlContent); // Minified
+             expect(result.assets.find(a => a.type === 'css')?.content).toBe(sampleCssContent); // Original
+             expect(result.assets.find(a => a.type === 'js')?.content).toBe(sampleJsContent); // Original
+         });
+    });
+    describe('Content types', () => {
+        it('📦 only processes css/js types, skips image/font/other', async () => {
+            const inputWithVariousTypes: ParsedHTML = {
+                htmlContent: sampleHtmlContent,
+                assets: [
+                    { type: 'css', url: 'style.css', content: sampleCssContent },
+                    { type: 'js', url: 'script.js', content: sampleJsContent },
+                    { type: 'image', url: 'logo.png', content: 'data:image/png;base64,abc' },
+                    { type: 'font', url: 'font.woff2', content: 'data:font/woff2;base64,def' },
+                    { type: 'other', url: 'data.json', content: '{"a":1}' }
+                ]
+            };
+            const result = await minifyAssets(inputWithVariousTypes, {}, mockLogger); // Default options
+            expect(mockHtmlMinifierMinifyFn).toHaveBeenCalledTimes(1);
+            expect(mockCleanCSSInstanceMinifyFn).toHaveBeenCalledTimes(1); // Called only for CSS
+            expect(mockTerserMinifyFn).toHaveBeenCalledTimes(1); // Called only for JS
+            // Check that non-CSS/JS assets are untouched
+            expect(result.assets.find(a => a.type === 'image')?.content).toBe('data:image/png;base64,abc');
+            expect(result.assets.find(a => a.type === 'font')?.content).toBe('data:font/woff2;base64,def');
+            expect(result.assets.find(a => a.type === 'other')?.content).toBe('{"a":1}');
+            // Check CSS/JS were minified
+            expect(result.assets.find(a => a.type === 'css')?.content).toBe(minifiedCssContent);
+            expect(result.assets.find(a => a.type === 'js')?.content).toBe(minifiedJsContent);
+            // Check HTML was minified
+            expect(result.htmlContent).toBe(minifiedHtmlContent);
+        });
+    });
+    describe('Edge Cases', () => {
+        it('💨 handles empty input object gracefully', async () => {
+            const emptyInput: ParsedHTML = { htmlContent: '', assets: [] };
+            const result = await minifyAssets(emptyInput, {}, mockLogger);
+            expect(result.htmlContent).toBe('');
+            expect(result.assets).toEqual([]);
+            expect(mockHtmlMinifierMinifyFn).not.toHaveBeenCalled();
+            expect(mockCleanCSSConstructorFn).not.toHaveBeenCalled();
+            expect(mockTerserMinifyFn).not.toHaveBeenCalled();
+            expect(mockLoggerDebugFn).toHaveBeenCalledWith('Minification skipped: No content.');
+        });
+        it('💨 handles input with assets but empty HTML content string', async () => {
+            const input: ParsedHTML = {
+                htmlContent: '',
+                assets: [ { type: 'css', url: 'style.css', content: sampleCssContent } ]
+            };
+            const result = await minifyAssets(input, {}, mockLogger);
+            expect(result.htmlContent).toBe(''); // Should remain empty
+            expect(result.assets.find(a => a.type === 'css')?.content).toBe(minifiedCssContent); // CSS should be minified
+            expect(mockHtmlMinifierMinifyFn).not.toHaveBeenCalled(); // No HTML to minify
+            expect(mockCleanCSSInstanceMinifyFn).toHaveBeenCalledTimes(1);
+            expect(mockTerserMinifyFn).not.toHaveBeenCalled();
+        });
+        it('💨 handles input with HTML but empty assets array', async () => {
+            const input: ParsedHTML = { htmlContent: sampleHtmlContent, assets: [] };
+            const result = await minifyAssets(input, {}, mockLogger);
+            expect(result.htmlContent).toBe(minifiedHtmlContent); // HTML should be minified
+            expect(result.assets).toEqual([]); // Assets should remain empty
+            expect(mockHtmlMinifierMinifyFn).toHaveBeenCalledTimes(1);
+            expect(mockCleanCSSInstanceMinifyFn).not.toHaveBeenCalled(); // No CSS assets
+            expect(mockTerserMinifyFn).not.toHaveBeenCalled(); // No JS assets
+        });
+        // Test case for the CleanCSS warning path (no error, no styles)
+        it('⚠️ handles CleanCSS returning no styles without errors', async () => {
+            mockCleanCSSInstanceMinifyFn.mockReturnValueOnce({
+                errors: [], warnings: [], styles: undefined, // Simulate no styles returned
+                stats: { originalSize: sampleCssContent.length, minifiedSize: 0, efficiency: 0, timeSpent: 0 }
+            });
+            const result = await minifyAssets(sampleParsedInput, {}, mockLogger);
+            expect(result.htmlContent).toBe(minifiedHtmlContent); // HTML minified
+            expect(result.assets.find(a => a.type === 'css')?.content).toBe(sampleCssContent); // Original CSS kept
+            expect(result.assets.find(a => a.type === 'js')?.content).toBe(minifiedJsContent); // JS minified
+            expect(mockLoggerWarnFn).toHaveBeenCalledWith(expect.stringContaining('CleanCSS produced no styles but reported no errors for style.css. Keeping original.'));
+        });
+         // Test case for the Terser warning path (no error, no code)
+         it('⚠️ handles Terser returning no code without errors', async () => {
+             mockTerserMinifyFn.mockResolvedValueOnce({ code: undefined, error: undefined }); // Simulate no code returned
+             const result = await minifyAssets(sampleParsedInput, {}, mockLogger);
+             expect(result.htmlContent).toBe(minifiedHtmlContent); // HTML minified
+             expect(result.assets.find(a => a.type === 'css')?.content).toBe(minifiedCssContent); // CSS minified
+             expect(result.assets.find(a => a.type === 'js')?.content).toBe(sampleJsContent); // Original JS kept
+             expect(mockLoggerWarnFn).toHaveBeenCalledWith(expect.stringContaining('Terser produced no code but reported no errors for script.js. Keeping original.'));
+         });
+    });
+});

package/tests/unit/core/packer.test.ts ADDED Viewed

@@ -0,0 +1,193 @@
+/**
+ * @file tests/unit/core/packer.test.ts
+ * @description Unit tests for the HTML packer module (packHTML function).
+ * Focuses on asset inlining, handling different HTML structures, and edge cases.
+ */
+import * as cheerio from 'cheerio';
+import { jest, describe, it, expect, beforeEach } from '@jest/globals';
+import { packHTML } from '../../../src/core/packer'; // Use .js if outputting JS
+import { Logger } from '../../../src/utils/logger'; // Use .js if outputting JS
+import { LogLevel } from '../../../src/types'; // Use .js if outputting JS
+import type { ParsedHTML, Asset } from '../../../src/types'; // Use .js if outputting JS
+/**
+ * @describe Test suite for the packHTML function in the HTML Packer module.
+ */
+describe('📦 HTML Packer - packHTML()', () => {
+    let mockLogger: Logger;
+    let mockLoggerDebugFn: jest.SpiedFunction<typeof Logger.prototype.debug>;
+    let mockLoggerWarnFn: jest.SpiedFunction<typeof Logger.prototype.warn>;
+    // --- Test Constants ---
+    const cssUrl = 'style.css';
+    const jsUrl = 'script.js';
+    const imgUrl = 'logo.png';
+    const videoPosterUrl = 'poster.jpg';
+    const videoSrcUrl = 'movie.mp4';
+    const missingAssetUrl = 'not-found.css';
+    const trickyJsUrl = 'tricky.js';
+    const cssContent = 'body { background: blue; }';
+    const jsContent = 'console.log("hello");';
+    const jsWithScriptTag = 'console.log("</script>"); alert("hello");';
+    const imgDataUri = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII='; // 1x1 red pixel png
+    const videoDataUri = 'data:video/mp4;base64,AAAAFGZ0eXBNNFYgAAACAGlzb21pc28yYXZjMQAAAAhmcmVlAAAAGm1kYXQ='; // Minimal mp4
+    const sampleAssets: Asset[] = [
+        { type: 'css', url: cssUrl, content: cssContent },
+        { type: 'js', url: jsUrl, content: jsContent },
+        { type: 'js', url: trickyJsUrl, content: jsWithScriptTag },
+        { type: 'image', url: imgUrl, content: imgDataUri },
+        { type: 'image', url: videoPosterUrl, content: imgDataUri }, // Using img for poster for simplicity
+        { type: 'video', url: videoSrcUrl, content: videoDataUri },
+        { type: 'css', url: missingAssetUrl, content: undefined }, // Asset without content
+    ];
+    const baseHtml = `
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="UTF-8">
+            <title>Test Page</title>
+            <link rel="stylesheet" href="${cssUrl}">
+            <link rel="stylesheet" href="${missingAssetUrl}">
+        </head>
+        <body>
+            <h1>Hello</h1>
+            <img src="${imgUrl}" alt="Logo">
+            <video poster="${videoPosterUrl}" controls>
+                  <source src="${videoSrcUrl}" type="video/mp4">
+                  Your browser does not support the video tag.
+            </video>
+             <img srcset="${imgUrl} 1x, ${videoPosterUrl} 2x" alt="Srcset Image">
+             <input type="image" src="${imgUrl}" alt="Input image">
+            <script src="${jsUrl}"></script>
+            <script src="non-existent.js"></script>
+            <script> /* Inline script should be kept */ console.log('inline'); </script>
+        </body>
+        </html>
+    `;
+    const fragmentHtml = `
+        <div>Just a div</div>
+        <link rel="stylesheet" href="${cssUrl}">
+        <script src="${jsUrl}"></script>
+    `;
+    /**
+     * @beforeEach Resets mocks before each test.
+     */
+    beforeEach(() => {
+        mockLogger = new Logger(LogLevel.WARN); // Use DEBUG level for tests
+        mockLoggerDebugFn = jest.spyOn(mockLogger, 'debug');
+        mockLoggerWarnFn = jest.spyOn(mockLogger, 'warn');
+    });
+    /**
+     * @it Tests if packHTML correctly handles HTML fragments (input without <html>, <head>, <body>).
+     * It verifies that Cheerio creates the basic structure, adds the base tag,
+     * preserves original content, and correctly inlines assets (noting that link/script tags
+     * from fragments often end up in the body during parsing).
+     */
+    it('handles missing <head> and <body> (HTML fragment)', () => {
+        // Input is just a div, link, and script
+        const parsedInput: ParsedHTML = { htmlContent: fragmentHtml, assets: sampleAssets };
+        const result = packHTML(parsedInput, mockLogger);
+        const $ = cheerio.load(result);
+        // Verify Cheerio created the basic structure
+        expect($('html').length).toBe(1);
+        expect($('head').length).toBe(1);
+        expect($('body').length).toBe(1);
+        // Verify <base> tag was added to the created <head>
+        expect($('head > base[href="./"]').length).toBe(1);
+        // Verify the original div exists within the created <body>
+        expect($('body > div:contains("Just a div")').length).toBe(1);
+        // Verify assets were inlined into the structure where Cheerio placed the original tags.
+        // NOTE: Cheerio often places fragment <link> and <script> tags into the <body> it creates.
+        // The packer replaces them *in place*.
+        expect($('body > style').length).toBe(1); // <<< FIXED: Check body for style tag from fragment link
+        expect($('body > style').text()).toBe(cssContent); // <<< FIXED: Check body for style tag from fragment link
+        // JS likely also goes in body when inlining based on original fragment script placement
+        expect($('body > script:not([src])').length).toBe(1);
+        expect($('body > script:not([src])').html()).toContain(jsContent); // jsContent is 'console.log("hello");'
+        // Check relevant logs were called (ensureBaseTag logic)
+        expect(mockLoggerDebugFn).toHaveBeenCalledWith(expect.stringContaining('Loading HTML content into Cheerio'));
+        expect(mockLoggerDebugFn).toHaveBeenCalledWith(expect.stringContaining('Ensuring <base> tag exists...'));
+        // Cheerio creates <head>, so the code finds it and adds the base tag.
+        expect(mockLoggerDebugFn).toHaveBeenCalledWith(expect.stringContaining('Prepending <base href="./"> to <head>.'));
+        expect(mockLoggerDebugFn).toHaveBeenCalledWith(expect.stringContaining('Starting asset inlining...'));
+        // Verify the 'No <head> tag found' log IS NOT called, because Cheerio creates one.
+        expect(mockLoggerDebugFn).not.toHaveBeenCalledWith(expect.stringContaining('No <head> tag found'));
+    });
+    /**
+     * @it Tests if packHTML returns a minimal valid HTML shell when input htmlContent is empty or invalid.
+     */
+    it('returns minimal HTML shell if input htmlContent is empty or invalid', () => {
+        const expectedShell = '<!DOCTYPE html><html><head><base href="./"></head><body></body></html>';
+        // Test with empty string
+        const emptyParsed: ParsedHTML = { htmlContent: '', assets: [] };
+        const resultEmpty = packHTML(emptyParsed, mockLogger);
+        expect(resultEmpty).toBe(expectedShell);
+        expect(mockLoggerWarnFn).toHaveBeenCalledWith(expect.stringContaining('Packer received empty or invalid htmlContent'));
+        mockLoggerWarnFn.mockClear(); // Reset mock for next check
+        // Test with null (simulating invalid input)
+        // @ts-expect-error Testing invalid input type deliberately
+        const nullParsed: ParsedHTML = { htmlContent: null, assets: [] };
+        const resultNull = packHTML(nullParsed, mockLogger);
+        expect(resultNull).toBe(expectedShell);
+        expect(mockLoggerWarnFn).toHaveBeenCalledWith(expect.stringContaining('Packer received empty or invalid htmlContent'));
+    });
+    /**
+     * @it Tests if closing script tags within JS content are correctly escaped to prevent breaking the HTML structure.
+     */
+    it('escapes closing script tags in JS content', () => {
+        const assets: Asset[] = [{ type: 'js', url: trickyJsUrl, content: jsWithScriptTag }];
+        const html = `<html><head></head><body><script src="${trickyJsUrl}"></script></body></html>`;
+        const parsed: ParsedHTML = { htmlContent: html, assets };
+        const result = packHTML(parsed, mockLogger);
+        const $ = cheerio.load(result);
+        const scriptContent = $('script:not([src])').html();
+        expect(scriptContent).toContain('console.log("<\\/script>");'); // Check for escaped tag: <\/script>
+        expect(scriptContent).toContain('alert("hello");');
+        expect(scriptContent).not.toContain('</script>'); // Original unescaped should not be present
+    });
+    /**
+     * @it Tests if attributes (other than 'src') on original script tags are preserved when the script is inlined.
+     */
+    it('preserves other attributes on inlined script tags', () => {
+        const assets: Asset[] = [{ type: 'js', url: jsUrl, content: jsContent }];
+        // Original script tag has type="module" and defer attributes
+        const html = `<html><head></head><body><script src="${jsUrl}" type="module" defer></script></body></html>`;
+        const parsed: ParsedHTML = { htmlContent: html, assets };
+        const result = packHTML(parsed, mockLogger);
+        const $ = cheerio.load(result);
+        const scriptTag = $('script:not([src])');
+        expect(scriptTag.length).toBe(1);
+        expect(scriptTag.attr('type')).toBe('module'); // Check 'type' is preserved
+        expect(scriptTag.attr('defer')).toBeDefined(); // Check 'defer' attribute presence
+        expect(scriptTag.attr('src')).toBeUndefined(); // src should be removed
+        expect(scriptTag.html()).toContain(jsContent); // Check content is inlined
+    });
+    // --- Potential Future Tests ---
+    // - HTML without <html> tag initially (covered partly by fragment test)
+    // - Assets with URLs containing special characters? (Cheerio/Map should handle)
+    // - Very large assets? (Performance not tested here)
+    // - Conflicting asset URLs? (Map uses last one - maybe test this explicitly?)
+});