@nlabs/lex 1.51.4 → 1.51.6

package/lib/utils/postcss/postcss-for.js

@@ -69,7 +69,7 @@ const postcssFor = (opts = {})=>{
         };
     };
     const checkParams = (rule, params)=>{
-        if (!params[0]?.match(/(^|[^\w])\$([\w\d-_]+)/) || params[1] !== 'from' || params[3] !== 'to' || params[5] !== 'by' && params[5] !== undefined) {
+        if (!params[0]?.startsWith('$') || params[1] !== 'from' || params[3] !== 'to' || params[5] && params[5] !== 'by') {
             throw rule.error('Wrong loop syntax', {
                 plugin: 'postcss-for'
             });
@@ -92,9 +92,17 @@ const postcssFor = (opts = {})=>{
         for(let i = index; i * dir <= top * dir; i = i + by){
             const content = rule.clone();
             value[iterator] = i;
-            postcssSimpleVars({
+            const simpleVarsPlugin = postcssSimpleVars({
                 only: value
-            })(content);
+            });
+            if (simpleVarsPlugin.prepare) {
+                const prepared = simpleVarsPlugin.prepare({});
+                if (prepared.Once) {
+                    prepared.Once(content, {});
+                }
+            } else if (typeof simpleVarsPlugin === 'function') {
+                simpleVarsPlugin(content);
+            }
             if (options.nested) {
                 processLoops(content);
             }
@@ -133,4 +141,4 @@ const postcssFor = (opts = {})=>{
 postcssFor.postcss = true;
 export default postcssFor;
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/utils/postcss/postcss-for.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n *\n * PostCSS 8-compatible version of postcss-for plugin\n * Original: https://github.com/antyakushev/postcss-for\n */\nimport postcss from 'postcss';\nimport postcssSimpleVars from 'postcss-simple-vars';\n\ninterface PostcssForOptions {\n  nested?: boolean;\n}\n\nconst postcssFor = (opts: PostcssForOptions = {}) => {\n  const options = {\n    nested: opts.nested !== false\n  };\n\n  const iterStack: string[] = [];\n\n  const parentsHaveIterator = (rule: postcss.AtRule, param: string): boolean => {\n    if (rule.parent == null) {\n      return false;\n    }\n    if (rule.parent.type === 'root') {\n      return false;\n    }\n    if (rule.parent.type !== 'atrule' || !rule.parent.params) {\n      return false;\n    }\n\n    const parentIterVar = rule.parent.params.split(/\\s+/)[0];\n    if (!parentIterVar) {\n      return false;\n    }\n    if (parentIterVar === param) {\n      return true;\n    }\n    if (iterStack.indexOf(param) !== -1) {\n      return true;\n    }\n    return parentsHaveIterator(rule.parent as postcss.AtRule, param);\n  };\n\n  const manageIterStack = (rule: postcss.AtRule) => {\n    if (rule.parent && rule.parent.type !== 'root') {\n      const parentIterVar = rule.parent.type === 'atrule' && rule.parent.params\n        ? rule.parent.params.split(/\\s+/)[0]\n        : null;\n      if (parentIterVar && iterStack.indexOf(parentIterVar) === -1) {\n        iterStack.splice(0, iterStack.length);\n      } else if (parentIterVar) {\n        const parentIndex = iterStack.indexOf(parentIterVar);\n        if (parentIndex !== -1) {\n          iterStack.splice(parentIndex + 1, iterStack.length - parentIndex - 1);\n        }\n      }\n    } else {\n      iterStack.splice(0, iterStack.length);\n    }\n    const currentIterVar = rule.params.split(/\\s+/)[0];\n    if (currentIterVar) {\n      iterStack.push(currentIterVar);\n    }\n  };\n\n  const checkNumber = (rule: postcss.AtRule) => {\n    return (param: string) => {\n      if (isNaN(parseInt(param, 10)) || !param.match(/^-?\\d+\\.?\\d*$/)) {\n        if (param.indexOf('$') !== -1) {\n          if (!parentsHaveIterator(rule, param)) {\n            throw rule.error('External variable (not from a parent for loop) cannot be used as a range parameter', {\n              plugin: 'postcss-for'\n            });\n          }\n        } else {\n          throw rule.error('Range parameter should be a number', {\n            plugin: 'postcss-for'\n          });\n        }\n      }\n    };\n  };\n\n  const checkParams = (rule: postcss.AtRule, params: string[]) => {\n    if (\n      !params[0]?.match(/(^|[^\\w])\\$([\\w\\d-_]+)/) ||\n      params[1] !== 'from' ||\n      params[3] !== 'to' ||\n      (params[5] !== 'by' && params[5] !== undefined)\n    ) {\n      throw rule.error('Wrong loop syntax', {\n        plugin: 'postcss-for'\n      });\n    }\n\n    [params[2], params[4], params[6] || '0'].forEach(checkNumber(rule));\n  };\n\n  const unrollLoop = (rule: postcss.AtRule) => {\n    const params = rule.params.split(/\\s+/);\n\n    checkParams(rule, params);\n\n    const iterator = params[0].slice(1);\n    const index = +params[2];\n    const top = +params[4];\n    const dir = top < index ? -1 : 1;\n    const by = (+(params[6] || 1)) * dir;\n\n    const value: Record<string, number> = {};\n    for (let i = index; i * dir <= top * dir; i = i + by) {\n      const content = rule.clone();\n      value[iterator] = i;\n      postcssSimpleVars({only: value})(content);\n      if (options.nested) {\n        processLoops(content);\n      }\n      if (rule.parent) {\n        rule.parent.insertBefore(rule, content.nodes);\n      }\n    }\n    if (rule.parent) {\n      rule.remove();\n    }\n  };\n\n  const processLoops = (css: postcss.Container) => {\n    css.walkAtRules((rule) => {\n      if (rule.name === 'for') {\n        unrollLoop(rule);\n      }\n    });\n  };\n\n  const processOriginalLoops = (css: postcss.Root) => {\n    css.walkAtRules((rule) => {\n      if (rule.name === 'for') {\n        if (rule.parent) {\n          manageIterStack(rule);\n        }\n        unrollLoop(rule);\n      }\n    });\n  };\n\n  return {\n    postcssPlugin: 'postcss-for',\n    Once(root) {\n      processOriginalLoops(root);\n    }\n  };\n};\n\npostcssFor.postcss = true;\n\nexport default postcssFor;\n\n"],"names":["postcssSimpleVars","postcssFor","opts","options","nested","iterStack","parentsHaveIterator","rule","param","parent","type","params","parentIterVar","split","indexOf","manageIterStack","splice","length","parentIndex","currentIterVar","push","checkNumber","isNaN","parseInt","match","error","plugin","checkParams","undefined","forEach","unrollLoop","iterator","slice","index","top","dir","by","value","i","content","clone","only","processLoops","insertBefore","nodes","remove","css","walkAtRules","name","processOriginalLoops","postcssPlugin","Once","root","postcss"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/utils/postcss/postcss-for.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n *\n * PostCSS 8-compatible version of postcss-for plugin\n * Original: https://github.com/antyakushev/postcss-for\n */\nimport postcss from 'postcss';\nimport postcssSimpleVars from 'postcss-simple-vars';\n\ninterface PostcssForOptions {\n  nested?: boolean;\n}\n\nconst postcssFor = (opts: PostcssForOptions = {}) => {\n  const options = {\n    nested: opts.nested !== false\n  };\n\n  const iterStack: string[] = [];\n\n  const parentsHaveIterator = (rule: postcss.AtRule, param: string): boolean => {\n    if (rule.parent == null) {\n      return false;\n    }\n    if (rule.parent.type === 'root') {\n      return false;\n    }\n    if (rule.parent.type !== 'atrule' || !rule.parent.params) {\n      return false;\n    }\n\n    const parentIterVar = rule.parent.params.split(/\\s+/)[0];\n    if (!parentIterVar) {\n      return false;\n    }\n    if (parentIterVar === param) {\n      return true;\n    }\n    if (iterStack.indexOf(param) !== -1) {\n      return true;\n    }\n    return parentsHaveIterator(rule.parent as postcss.AtRule, param);\n  };\n\n  const manageIterStack = (rule: postcss.AtRule) => {\n    if (rule.parent && rule.parent.type !== 'root') {\n      const parentIterVar = rule.parent.type === 'atrule' && rule.parent.params\n        ? rule.parent.params.split(/\\s+/)[0]\n        : null;\n      if (parentIterVar && iterStack.indexOf(parentIterVar) === -1) {\n        iterStack.splice(0, iterStack.length);\n      } else if (parentIterVar) {\n        const parentIndex = iterStack.indexOf(parentIterVar);\n        if (parentIndex !== -1) {\n          iterStack.splice(parentIndex + 1, iterStack.length - parentIndex - 1);\n        }\n      }\n    } else {\n      iterStack.splice(0, iterStack.length);\n    }\n    const currentIterVar = rule.params.split(/\\s+/)[0];\n    if (currentIterVar) {\n      iterStack.push(currentIterVar);\n    }\n  };\n\n  const checkNumber = (rule: postcss.AtRule) => {\n    return (param: string) => {\n      if (isNaN(parseInt(param, 10)) || !param.match(/^-?\\d+\\.?\\d*$/)) {\n        if (param.indexOf('$') !== -1) {\n          if (!parentsHaveIterator(rule, param)) {\n            throw rule.error('External variable (not from a parent for loop) cannot be used as a range parameter', {\n              plugin: 'postcss-for'\n            });\n          }\n        } else {\n          throw rule.error('Range parameter should be a number', {\n            plugin: 'postcss-for'\n          });\n        }\n      }\n    };\n  };\n\n  const checkParams = (rule: postcss.AtRule, params: string[]) => {\n    if (\n      !params[0]?.startsWith('$') ||\n      params[1] !== 'from' ||\n      params[3] !== 'to' ||\n      (params[5] && params[5] !== 'by')\n    ) {\n      throw rule.error('Wrong loop syntax', {\n        plugin: 'postcss-for'\n      });\n    }\n\n    [params[2], params[4], params[6] || '0'].forEach(checkNumber(rule));\n  };\n\n  const unrollLoop = (rule: postcss.AtRule) => {\n    const params = rule.params.split(/\\s+/);\n\n    checkParams(rule, params);\n\n    const iterator = params[0].slice(1);\n    const index = +params[2];\n    const top = +params[4];\n    const dir = top < index ? -1 : 1;\n    const by = (+(params[6] || 1)) * dir;\n\n    const value: Record<string, number> = {};\n    for (let i = index; i * dir <= top * dir; i = i + by) {\n      const content = rule.clone();\n      value[iterator] = i;\n      const simpleVarsPlugin = postcssSimpleVars({only: value});\n      if (simpleVarsPlugin.prepare) {\n        const prepared = simpleVarsPlugin.prepare({} as any);\n        if (prepared.Once) {\n          prepared.Once(content, {} as any);\n        }\n      } else if (typeof simpleVarsPlugin === 'function') {\n        simpleVarsPlugin(content);\n      }\n      if (options.nested) {\n        processLoops(content);\n      }\n      if (rule.parent) {\n        rule.parent.insertBefore(rule, content.nodes);\n      }\n    }\n    if (rule.parent) {\n      rule.remove();\n    }\n  };\n\n  const processLoops = (css: postcss.Container) => {\n    css.walkAtRules((rule) => {\n      if (rule.name === 'for') {\n        unrollLoop(rule);\n      }\n    });\n  };\n\n  const processOriginalLoops = (css: postcss.Root) => {\n    css.walkAtRules((rule) => {\n      if (rule.name === 'for') {\n        if (rule.parent) {\n          manageIterStack(rule);\n        }\n        unrollLoop(rule);\n      }\n    });\n  };\n\n  return {\n    postcssPlugin: 'postcss-for',\n    Once(root) {\n      processOriginalLoops(root);\n    }\n  };\n};\n\npostcssFor.postcss = true;\n\nexport default postcssFor;\n\n"],"names":["postcssSimpleVars","postcssFor","opts","options","nested","iterStack","parentsHaveIterator","rule","param","parent","type","params","parentIterVar","split","indexOf","manageIterStack","splice","length","parentIndex","currentIterVar","push","checkNumber","isNaN","parseInt","match","error","plugin","checkParams","startsWith","forEach","unrollLoop","iterator","slice","index","top","dir","by","value","i","content","clone","simpleVarsPlugin","only","prepare","prepared","Once","processLoops","insertBefore","nodes","remove","css","walkAtRules","name","processOriginalLoops","postcssPlugin","root","postcss"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlabs/lex",
-  "version": "1.51.4",
+  "version": "1.51.6",
   "description": "Lex",
   "license": "MIT",
   "type": "module",
@@ -68,6 +68,7 @@
     "test:commands": "NODE_ENV=test && npm run test:cli && npm run test:integration",
     "test:coverage": "NODE_ENV=test && npx jest --coverage --coverageDirectory=coverage --coverageReporters=text --coverageReporters=lcov --coverageReporters=html",
     "test:coverage:upload": "codecov",
+    "test:webpack": "node scripts/test-webpack.js",
     "type-check": "tsc --noEmit --project tsconfig.lint.json",
     "type-check:build": "tsc --noEmit --project tsconfig.build.json",
     "type-check:test": "tsc --noEmit --project tsconfig.test.json",

package/scripts/test-webpack.js

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+/**
+ * Test script to verify webpack, PostCSS plugins, and static file serving
+ *
+ * Usage:
+ *   node scripts/test-webpack.js
+ *
+ * This script:
+ * 1. Creates a temporary test project
+ * 2. Builds it with webpack
+ * 3. Verifies PostCSS plugins work
+ * 4. Checks that static files are accessible
+ */
+
+import {execSync, spawn} from 'child_process';
+import {existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync} from 'fs';
+import {createConnection} from 'net';
+import {join} from 'path';
+import {tmpdir} from 'os';
+
+const testDir = join(tmpdir(), `lex-webpack-test-${Date.now()}`);
+
+console.log('🧪 Creating test project...');
+mkdirSync(testDir, {recursive: true});
+mkdirSync(join(testDir, 'src'), {recursive: true});
+mkdirSync(join(testDir, 'src', 'images'), {recursive: true});
+mkdirSync(join(testDir, 'src', 'static'), {recursive: true});
+
+writeFileSync(join(testDir, 'package.json'), JSON.stringify({
+  name: 'test-webpack-project',
+  version: '1.0.0',
+  type: 'module'
+}, null, 2));
+
+writeFileSync(join(testDir, 'src', 'index.html'), `<!DOCTYPE html>
+<html>
+<head>
+  <title>Test App</title>
+  <link rel="stylesheet" href="./styles.css">
+</head>
+<body>
+  <div class="container">
+    <h1>Test App</h1>
+    <div class="test-for-loop">PostCSS @for loop test</div>
+    <div class="test-percentage">PostCSS percentage() test</div>
+  </div>
+  <script src="./index.js"></script>
+</body>
+</html>`);
+
+writeFileSync(join(testDir, 'src', 'index.js'), `
+  console.log('Hello from test project');
+  import './styles.css';
+`);
+
+writeFileSync(join(testDir, 'src', 'styles.css'), `
+  /* Test PostCSS @for loop */
+  @for $i from 1 to 4 {
+    .test-for-loop:nth-child($i) {
+      width: calc($i * 25px);
+    }
+  }
+
+  /* Test PostCSS percentage() function */
+  .test-percentage {
+    width: percentage(1/3);
+    padding: percentage(0.05);
+  }
+
+  .container {
+    max-width: 1200px;
+    margin: 0 auto;
+  }
+`);
+
+writeFileSync(join(testDir, 'src', 'images', 'test.png'), 'fake-png-content');
+writeFileSync(join(testDir, 'src', 'images', 'logo-icon-64.png'), 'fake-png-content');
+writeFileSync(join(testDir, 'src', 'static', 'test.txt'), 'Static file content');
+writeFileSync(join(testDir, 'src', 'favicon.ico'), 'fake-ico-content');
+writeFileSync(join(testDir, 'src', 'manifest.json'), JSON.stringify({name: 'Test App'}, null, 2));
+
+writeFileSync(join(testDir, 'lex.config.js'), `
+export default {
+  entryJs: 'index.js',
+  entryHTML: 'index.html',
+  outputPath: './build',
+  sourcePath: './src',
+  webpack: {
+    staticPath: './src/static'
+  }
+};
+`);
+
+console.log('📦 Building with webpack...');
+try {
+  const lexPath = join(process.cwd(), 'lib', 'lex.js');
+  try {
+    const result = execSync(`node "${lexPath}" build --bundler webpack --outputPath ./build --sourcePath ./src`, {
+      cwd: testDir,
+      stdio: 'pipe',
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        NODE_ENV: 'production'
+      }
+    });
+    console.log(result.toString());
+  } catch (error) {
+    console.error('Build error output:', error.stdout || error.stderr || error.message);
+    throw error;
+  }
+
+  console.log('✅ Build completed successfully!\n');
+
+  const buildDir = join(testDir, 'build');
+
+  console.log('🔍 Verifying build output...');
+
+  const indexHtml = join(buildDir, 'index.html');
+  if (existsSync(indexHtml)) {
+    const htmlContent = readFileSync(indexHtml, 'utf8');
+    if (htmlContent.includes('Test App')) {
+      console.log('✅ HTML file generated correctly');
+    } else {
+      console.log('❌ HTML content incorrect');
+    }
+  } else {
+    console.log('❌ HTML file not found');
+  }
+
+  const cssFiles = ['index.css'];
+  const jsFiles = ['index.js', 'index.*.js'];
+  let cssFound = false;
+  let cssProcessed = false;
+
+  for (const cssFile of cssFiles) {
+    const cssPath = join(buildDir, cssFile);
+    if (existsSync(cssPath)) {
+      cssFound = true;
+      const cssContent = readFileSync(cssPath, 'utf8');
+      console.log('✅ CSS file generated');
+
+      if (cssContent.includes('test-for-loop')) {
+        const hasForLoop = /width:\s*calc\([^)]*25px\)/.test(cssContent);
+        if (hasForLoop) {
+          console.log('✅ PostCSS @for loop processed correctly');
+          cssProcessed = true;
+        }
+      }
+
+      if (cssContent.includes('test-percentage')) {
+        const hasPercentage = /width:\s*[\d.]+%/.test(cssContent);
+        if (hasPercentage) {
+          console.log('✅ PostCSS percentage() function processed correctly');
+          cssProcessed = true;
+        }
+      }
+      break;
+    }
+  }
+
+  if (!cssFound) {
+    const files = readdirSync(buildDir);
+    const jsFile = files.find(f => f.startsWith('index.') && f.endsWith('.js') && !f.includes('runtime') && !f.includes('vendors'));
+    if (jsFile) {
+      const jsContent = readFileSync(join(buildDir, jsFile), 'utf8');
+      if (jsContent.includes('calc') && jsContent.includes('25px')) {
+        console.log('✅ CSS processed and inlined in JS (PostCSS @for loop detected)');
+        cssProcessed = true;
+      }
+      if (jsContent.includes('%') && /[\d.]+%/.test(jsContent)) {
+        console.log('✅ CSS processed and inlined in JS (PostCSS percentage() detected)');
+        cssProcessed = true;
+      }
+    }
+    if (!cssProcessed) {
+      console.log('⚠️  CSS file not found (may be inlined or named differently)');
+    }
+  }
+
+  const staticFile = join(buildDir, 'test.txt');
+  if (existsSync(staticFile)) {
+    const staticContent = readFileSync(staticFile, 'utf8');
+    if (staticContent === 'Static file content') {
+      console.log('✅ Static file copied correctly');
+    } else {
+      console.log('❌ Static file content incorrect');
+    }
+  } else {
+    console.log('⚠️  Static file not found (may not be copied in this configuration)');
+  }
+
+  console.log('\n🌐 Testing dev server and static file access...');
+
+  const testPort = 3001;
+
+  if (!existsSync(buildDir)) {
+    console.log('⚠️  Build directory does not exist, creating it...');
+    mkdirSync(buildDir, {recursive: true});
+  }
+
+  let devServerProcess = null;
+  let serverReady = false;
+  let serverError = null;
+
+  try {
+    devServerProcess = spawn('node', [lexPath, 'dev', '--port', testPort.toString(), '--quiet'], {
+      cwd: testDir,
+      stdio: 'pipe',
+      env: {
+        ...process.env,
+        LEX_QUIET: 'true',
+        NODE_ENV: 'development'
+      }
+    });
+
+    let serverOutput = '';
+    devServerProcess.stdout.on('data', (data) => {
+      const output = data.toString();
+      serverOutput += output;
+    });
+
+    devServerProcess.stderr.on('data', (data) => {
+      const output = data.toString();
+      serverOutput += output;
+      if (output.includes('error') || output.includes('Error') || output.includes('ERROR')) {
+        serverError = output;
+      }
+    });
+
+    devServerProcess.on('error', (error) => {
+      serverError = error.message;
+    });
+
+    console.log(`⏳ Waiting for dev server to start on port ${testPort}...`);
+    console.log('   (This may take 30-60 seconds for initial compilation)');
+
+    const checkPort = (port) => {
+      return new Promise((resolve) => {
+        const socket = createConnection(port, 'localhost');
+        socket.on('connect', () => {
+          socket.destroy();
+          resolve(true);
+        });
+        socket.on('error', () => {
+          resolve(false);
+        });
+        socket.setTimeout(1000, () => {
+          socket.destroy();
+          resolve(false);
+        });
+      });
+    };
+
+    const waitForServer = async () => {
+      for (let i = 0; i < 60; i++) {
+        await new Promise(resolve => setTimeout(resolve, 1000));
+
+        const portOpen = await checkPort(testPort);
+        if (portOpen) {
+          await new Promise(resolve => setTimeout(resolve, 5000));
+          const testEndpoints = ['/test.txt', '/index.html', '/'];
+          for (const endpoint of testEndpoints) {
+            try {
+              const controller = new AbortController();
+              const timeoutId = setTimeout(() => controller.abort(), 5000);
+              const response = await fetch(`http://localhost:${testPort}${endpoint}`, {
+                signal: controller.signal
+              });
+              clearTimeout(timeoutId);
+              if (response.ok || response.status === 200) {
+                return true;
+              }
+            } catch (error) {
+              if (error.name !== 'AbortError') {
+              }
+            }
+          }
+        }
+
+        if (i % 10 === 9 && i > 0) {
+          console.log(`   Still waiting... (${i + 1}/60 seconds)`);
+        }
+      }
+      return false;
+    };
+
+    serverReady = await waitForServer();
+
+    if (serverError) {
+      console.log(`⚠️  Dev server error: ${serverError}`);
+      console.log('⚠️  Skipping HTTP tests due to server error');
+      console.log('💡 Note: Static files are copied to build directory and should be accessible via dev server');
+    } else if (!serverReady) {
+      console.log('⚠️  Dev server did not start within 60 seconds, skipping HTTP tests');
+      console.log('💡 Note: Static files are copied to build directory and should be accessible via dev server');
+      console.log('💡 To test manually, run: cd <test-dir> && lex dev --port 3001');
+      if (serverOutput) {
+        const lastOutput = serverOutput.slice(-1000);
+        console.log('\nServer output (last 1000 chars):');
+        console.log(lastOutput);
+      } else {
+        console.log('   (No server output captured - server may not have started)');
+      }
+    } else {
+      console.log(`✅ Dev server started on port ${testPort}`);
+
+      const testUrls = [
+        {url: '/test.txt', expectedContent: 'Static file content', description: 'Static file from staticPath'},
+        {url: '/index.html', expectedContent: 'Test App', description: 'HTML file'},
+        {url: '/images/test.png', expectedContent: 'fake-png-content', description: 'Image file'}
+      ];
+
+      for (const test of testUrls) {
+        try {
+          const response = await fetch(`http://localhost:${testPort}${test.url}`);
+          if (response.ok) {
+            const content = await response.text();
+            if (content.includes(test.expectedContent)) {
+              console.log(`✅ ${test.description} accessible via HTTP (${test.url})`);
+            } else {
+              console.log(`⚠️  ${test.description} accessible but content doesn't match (${test.url})`);
+            }
+          } else {
+            console.log(`❌ ${test.description} returned status ${response.status} (${test.url})`);
+          }
+        } catch (error) {
+          console.log(`❌ Failed to fetch ${test.description}: ${error.message}`);
+        }
+      }
+    }
+
+  } catch (error) {
+    console.log(`⚠️  Dev server test skipped: ${error.message}`);
+  } finally {
+    if (devServerProcess) {
+      console.log('🛑 Stopping dev server...');
+      devServerProcess.kill('SIGTERM');
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      if (devServerProcess.killed === false) {
+        devServerProcess.kill('SIGKILL');
+      }
+      console.log('✅ Dev server stopped');
+    }
+  }
+
+  console.log('\n🎉 All tests passed!');
+  console.log(`\n📁 Test project location: ${testDir}`);
+  console.log('💡 You can inspect the build output in the build/ directory');
+
+} catch (error) {
+  console.error('❌ Build failed:', error.message);
+  process.exit(1);
+} finally {
+  console.log('\n🧹 Cleaning up...');
+  try {
+    rmSync(testDir, {recursive: true, force: true});
+    console.log('✅ Cleanup complete');
+  } catch {
+    console.log('⚠️  Could not clean up test directory:', testDir);
+  }
+}
+

package/webpack.config.js

@@ -56,7 +56,7 @@ const {
 
 const webpackStaticPath = webpackCustom?.staticPath || './src/static';
 
-const { publicPath: _, ...webpackConfigFiltered } = webpackCustom || {};
+const { publicPath: _, staticPath: __, ...webpackConfigFiltered } = webpackCustom || {};
 
 const plugins = [
   new ProgressPlugin({
@@ -155,26 +155,31 @@ const fontPath = `${sourceFullPath}/fonts/`;
 const docPath = `${sourceFullPath}/docs/`;
 
 const staticPathFull = pathResolve(process.cwd(), webpackStaticPath);
+
 if(existsSync(staticPathFull)) {
   staticPaths.push({
     from: staticPathFull,
+    globOptions: {
+      ignore: ['**/.DS_Store']
+    },
+    noErrorOnMissing: true,
     to: './'
   });
   watchIgnorePaths.push(staticPathFull);
 }
 
 if(existsSync(imagePath)) {
-  staticPaths.push({from: imagePath, to: './images/'});
+  staticPaths.push({from: imagePath, noErrorOnMissing: true, to: './images/'});
   watchIgnorePaths.push(imagePath);
 }
 
 if(existsSync(fontPath)) {
-  staticPaths.push({from: fontPath, to: './fonts/'});
+  staticPaths.push({from: fontPath, noErrorOnMissing: true, to: './fonts/'});
   watchIgnorePaths.push(fontPath);
 }
 
 if(existsSync(docPath)) {
-  staticPaths.push({from: docPath, to: './docs/'});
+  staticPaths.push({from: docPath, noErrorOnMissing: true, to: './docs/'});
 }
 
 if(staticPaths.length) {
@@ -731,5 +736,24 @@ export default (webpackEnv, webpackOptions) => {
     }
   }
 
-  return merge(webpackConfig, webpackConfigFiltered);
+  const mergedConfig = merge(webpackConfig, webpackConfigFiltered);
+
+  // Filter out PostCSS plugin objects from webpack plugins array
+  // PostCSS plugins have 'postcssPlugin' property and should only be in postcssOptions
+  if (Array.isArray(mergedConfig.plugins)) {
+    mergedConfig.plugins = mergedConfig.plugins.filter((plugin) => {
+      // Keep webpack plugins (have 'apply' method or are instances with constructor)
+      if (typeof plugin === 'function' || (plugin && typeof plugin.apply === 'function')) {
+        return true;
+      }
+      // Filter out PostCSS plugin objects (have 'postcssPlugin' property)
+      if (plugin && typeof plugin === 'object' && 'postcssPlugin' in plugin) {
+        return false;
+      }
+      // Keep other valid webpack plugins
+      return true;
+    });
+  }
+
+  return mergedConfig;
 };