@swissjs/swite 0.3.0

package/__tests__/css-extraction.test.ts

@@ -0,0 +1,261 @@
+/**
+ * Test CSS extraction and injection into HTML
+ */
+
+import { test, describe } from "node:test";
+import { strict as assert } from "node:assert";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const testDir = path.join(__dirname, "..", "..", "..", "test-css-extraction");
+
+describe("CSS Extraction", () => {
+  test("should extract CSS imports from entry point file", async () => {
+    // Create test directory
+    try {
+      await fs.mkdir(testDir, { recursive: true });
+    } catch (e) {
+      // Directory might already exist
+    }
+
+    try {
+    // Create test files
+    const srcDir = path.join(testDir, "src");
+    await fs.mkdir(srcDir, { recursive: true });
+    await fs.mkdir(path.join(srcDir, "styles"), { recursive: true });
+
+    // Create index.ui that imports App.uix
+    const indexUi = `import { SwissApp } from '@swissjs/core'
+import { App } from './App.uix'
+
+SwissApp.mount(App, '#root')`;
+
+    // Create App.uix with CSS imports
+    const appUix = `import { SwissComponent } from '@swissjs/core'
+import './styles/globals.css'
+import './styles/cyber-theme.css'
+
+export class App extends SwissComponent {
+  render() {
+    return <div>Test</div>
+  }
+}`;
+
+    // Create CSS files
+    const globalsCss = `body { margin: 0; }`;
+    const cyberCss = `:root { --color: #00ff00; }`;
+
+    await fs.writeFile(path.join(srcDir, "index.ui"), indexUi);
+    await fs.writeFile(path.join(srcDir, "App.uix"), appUix);
+    await fs.writeFile(path.join(srcDir, "styles", "globals.css"), globalsCss);
+    await fs.writeFile(path.join(srcDir, "styles", "cyber-theme.css"), cyberCss);
+
+    // Test CSS extraction logic
+    const entryPointPath = path.join(srcDir, "index.ui");
+    const entryPointContent = await fs.readFile(entryPointPath, "utf-8");
+
+    // Extract CSS imports using regex
+    const cssImportPattern = /import\s+['"](.*?\.css)['"];?/g;
+    const cssImports = new Set<string>();
+    let match;
+
+    // Check entry point
+    while ((match = cssImportPattern.exec(entryPointContent)) !== null) {
+      cssImports.add(match[1]);
+    }
+
+    // Also check imported files (like App.uix) for CSS imports
+    const importPattern = /import\s+.*?from\s+['"](.*?)['"];?/g;
+    const importedFiles: string[] = [];
+    let importMatch;
+    cssImportPattern.lastIndex = 0; // Reset regex
+    while ((importMatch = importPattern.exec(entryPointContent)) !== null) {
+      const importPath = importMatch[1];
+      // Skip node_modules and absolute imports
+      if (!importPath.startsWith("@") && !importPath.startsWith("/") && !importPath.startsWith(".")) {
+        continue;
+      }
+      // Resolve relative imports
+      if (importPath.startsWith(".")) {
+        importedFiles.push(importPath);
+      }
+    }
+
+    // Check imported files for CSS
+    for (const importedFile of importedFiles) {
+      try {
+        const importedFilePath = path.resolve(path.dirname(entryPointPath), importedFile);
+        // Try different extensions
+        const extensions = [".uix", ".ui", ".ts", ".js"];
+        let found = false;
+        for (const ext of extensions) {
+          const testPath = importedFilePath.endsWith(ext) ? importedFilePath : importedFilePath + ext;
+          try {
+            const importedContent = await fs.readFile(testPath, "utf-8");
+            found = true;
+            // Extract CSS imports from this file
+            cssImportPattern.lastIndex = 0; // Reset regex
+            let cssMatch2;
+            while ((cssMatch2 = cssImportPattern.exec(importedContent)) !== null) {
+              // Resolve relative CSS path
+              const cssPath = cssMatch2[1];
+              if (cssPath.startsWith(".")) {
+                const resolvedCssPath = path.resolve(path.dirname(testPath), cssPath);
+                const relativeCssPath = path.relative(srcDir, resolvedCssPath);
+                const normalizedPath = relativeCssPath.replace(/\\/g, "/");
+                cssImports.add(normalizedPath);
+              } else {
+                cssImports.add(cssPath);
+              }
+            }
+            break;
+          } catch (err) {
+            // File doesn't exist with this extension, try next
+          }
+        }
+      } catch (error) {
+        // Could not read imported file, skip
+      }
+    }
+
+      // Verify CSS imports were found
+      assert.strictEqual(cssImports.size, 2);
+      assert.strictEqual(cssImports.has("styles/globals.css"), true);
+      assert.strictEqual(cssImports.has("styles/cyber-theme.css"), true);
+    } finally {
+      // Clean up test directory
+      try {
+        await fs.rm(testDir, { recursive: true, force: true });
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    }
+  });
+
+  test("should inject CSS links into HTML", async () => {
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Test</title>
+</head>
+<body>
+  <div id="root"></div>
+</body>
+</html>`;
+
+    const cssImports = ["styles/globals.css", "styles/cyber-theme.css"];
+    const cssLinks = cssImports.map(cssPath => {
+      const url = cssPath.startsWith("/") ? cssPath : `/src/${cssPath}`;
+      return `    <link rel="stylesheet" href="${url}">`;
+    }).join("\n");
+
+    const beforeReplace = html;
+    const modifiedHtml = html.replace(/\s*<\/head>/i, `${cssLinks}\n  </head>`);
+
+    assert.notStrictEqual(modifiedHtml, beforeReplace);
+    assert.ok(modifiedHtml.includes('<link rel="stylesheet" href="/src/styles/globals.css">'));
+    assert.ok(modifiedHtml.includes('<link rel="stylesheet" href="/src/styles/cyber-theme.css">'));
+  });
+
+  test("should handle CSS imports in nested files", async () => {
+    // Create test directory
+    try {
+      await fs.mkdir(testDir, { recursive: true });
+    } catch (e) {
+      // Directory might already exist
+    }
+
+    try {
+    // Create test files with nested imports
+    const srcDir = path.join(testDir, "src");
+    await fs.mkdir(srcDir, { recursive: true });
+    await fs.mkdir(path.join(srcDir, "styles"), { recursive: true });
+    await fs.mkdir(path.join(srcDir, "components"), { recursive: true });
+
+    const indexUi = `import { SwissApp } from '@swissjs/core'
+import { App } from './App.uix'
+
+SwissApp.mount(App, '#root')`;
+
+    const appUix = `import { SwissComponent } from '@swissjs/core'
+import { Header } from './components/Header.uix'
+
+export class App extends SwissComponent {
+  render() {
+    return <div><Header /></div>
+  }
+}`;
+
+    const headerUix = `import { SwissComponent } from '@swissjs/core'
+import '../styles/globals.css'
+import '../styles/cyber-theme.css'
+
+export class Header extends SwissComponent {
+  render() {
+    return <header>Header</header>
+  }
+}`;
+
+    const globalsCss = `body { margin: 0; }`;
+    const cyberCss = `:root { --color: #00ff00; }`;
+
+    await fs.writeFile(path.join(srcDir, "index.ui"), indexUi);
+    await fs.writeFile(path.join(srcDir, "App.uix"), appUix);
+    await fs.writeFile(path.join(srcDir, "components", "Header.uix"), headerUix);
+    await fs.writeFile(path.join(srcDir, "styles", "globals.css"), globalsCss);
+    await fs.writeFile(path.join(srcDir, "styles", "cyber-theme.css"), cyberCss);
+
+    // Test extraction (simplified - would need recursive traversal in real implementation)
+    const entryPointPath = path.join(srcDir, "index.ui");
+    const entryPointContent = await fs.readFile(entryPointPath, "utf-8");
+
+    const cssImportPattern = /import\s+['"](.*?\.css)['"];?/g;
+    const cssImports = new Set<string>();
+
+    // Check entry point
+    let match;
+    while ((match = cssImportPattern.exec(entryPointContent)) !== null) {
+      cssImports.add(match[1]);
+    }
+
+    // Check App.uix
+    const appPath = path.join(srcDir, "App.uix");
+    const appContent = await fs.readFile(appPath, "utf-8");
+    cssImportPattern.lastIndex = 0;
+    while ((match = cssImportPattern.exec(appContent)) !== null) {
+      cssImports.add(match[1]);
+    }
+
+    // Check Header.uix
+    const headerPath = path.join(srcDir, "components", "Header.uix");
+    const headerContent = await fs.readFile(headerPath, "utf-8");
+    cssImportPattern.lastIndex = 0;
+    while ((match = cssImportPattern.exec(headerContent)) !== null) {
+      const cssPath = match[1];
+      if (cssPath.startsWith("..")) {
+        // Resolve relative path from Header.uix location
+        const resolvedCssPath = path.resolve(path.dirname(headerPath), cssPath);
+        const relativeCssPath = path.relative(srcDir, resolvedCssPath);
+        const normalizedPath = relativeCssPath.replace(/\\/g, "/");
+        cssImports.add(normalizedPath);
+      } else {
+        cssImports.add(cssPath);
+      }
+    }
+
+      assert.strictEqual(cssImports.size, 2);
+      assert.strictEqual(cssImports.has("styles/globals.css"), true);
+      assert.strictEqual(cssImports.has("styles/cyber-theme.css"), true);
+    } finally {
+      // Clean up test directory
+      try {
+        await fs.rm(testDir, { recursive: true, force: true });
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    }
+  });
+});

package/__tests__/css-injection-integration.test.ts

@@ -0,0 +1,247 @@
+/**
+ * Integration test for CSS injection in HTML middleware
+ */
+
+import { test, describe } from "node:test";
+import { strict as assert } from "node:assert";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const testDir = path.join(__dirname, "..", "..", "..", "test-css-injection");
+
+// Simulate the CSS extraction logic from static-files.ts
+async function extractAndInjectCSS(
+  configRoot: string,
+  html: string
+): Promise<string> {
+  const entryPointPath = path.join(configRoot, "src", "index.ui");
+  
+  try {
+    const entryPointContent = await fs.readFile(entryPointPath, "utf-8");
+    
+    // Extract CSS imports using regex
+    const cssImportPattern = /import\s+['"](.*?\.css)['"];?/g;
+    const cssImports = new Set<string>();
+    let match;
+    
+    // Check entry point
+    while ((match = cssImportPattern.exec(entryPointContent)) !== null) {
+      cssImports.add(match[1]);
+    }
+    
+    // Also check imported files (like App.uix) for CSS imports
+    const importPattern = /import\s+.*?from\s+['"](.*?)['"];?/g;
+    const importedFiles: string[] = [];
+    let importMatch;
+    cssImportPattern.lastIndex = 0; // Reset regex
+    while ((importMatch = importPattern.exec(entryPointContent)) !== null) {
+      const importPath = importMatch[1];
+      // Skip node_modules and absolute imports
+      if (!importPath.startsWith("@") && !importPath.startsWith("/") && !importPath.startsWith(".")) {
+        continue;
+      }
+      // Resolve relative imports
+      if (importPath.startsWith(".")) {
+        importedFiles.push(importPath);
+      }
+    }
+    
+    // Check imported files for CSS
+    for (const importedFile of importedFiles) {
+      try {
+        const importedFilePath = path.resolve(path.dirname(entryPointPath), importedFile);
+        // Try different extensions
+        const extensions = [".uix", ".ui", ".ts", ".js"];
+        let found = false;
+        for (const ext of extensions) {
+          const testPath = importedFilePath.endsWith(ext) ? importedFilePath : importedFilePath + ext;
+          try {
+            const importedContent = await fs.readFile(testPath, "utf-8");
+            found = true;
+            // Extract CSS imports from this file
+            cssImportPattern.lastIndex = 0; // Reset regex
+            let cssMatch2;
+            while ((cssMatch2 = cssImportPattern.exec(importedContent)) !== null) {
+              // Resolve relative CSS path
+              const cssPath = cssMatch2[1];
+              if (cssPath.startsWith(".")) {
+                const resolvedCssPath = path.resolve(path.dirname(testPath), cssPath);
+                const relativeCssPath = path.relative(path.join(configRoot, "src"), resolvedCssPath);
+                const normalizedPath = relativeCssPath.replace(/\\/g, "/");
+                cssImports.add(normalizedPath);
+              } else {
+                cssImports.add(cssPath);
+              }
+            }
+            break;
+          } catch (err) {
+            // File doesn't exist with this extension, try next
+          }
+        }
+      } catch (error) {
+        // Could not read imported file, skip
+      }
+    }
+    
+    if (cssImports.size > 0) {
+      const cssArray = Array.from(cssImports);
+      
+      // Convert relative paths to absolute URLs
+      const cssLinks = cssArray.map(cssPath => {
+        // If it's already absolute (starts with /), use as-is
+        // Otherwise, make it relative to /src
+        const url = cssPath.startsWith("/") ? cssPath : `/src/${cssPath}`;
+        return `    <link rel="stylesheet" href="${url}">`;
+      }).join("\n");
+      
+      // Inject CSS links before </head>
+      const beforeReplace = html;
+      html = html.replace(/\s*<\/head>/i, `${cssLinks}\n  </head>`);
+      if (html === beforeReplace) {
+        throw new Error("Failed to inject CSS links - </head> not found");
+      }
+    }
+    
+    return html;
+  } catch (error) {
+    // If entry point doesn't exist or can't be read, return HTML as-is
+    return html;
+  }
+}
+
+describe("CSS Injection Integration", () => {
+  test("should extract and inject CSS from real project structure", async () => {
+    // Create test directory structure matching pos-site
+    const srcDir = path.join(testDir, "src");
+    const stylesDir = path.join(srcDir, "styles");
+    const publicDir = path.join(testDir, "public");
+    
+    await fs.mkdir(srcDir, { recursive: true });
+    await fs.mkdir(stylesDir, { recursive: true });
+    await fs.mkdir(publicDir, { recursive: true });
+
+    try {
+      // Create index.ui (entry point)
+      const indexUi = `import { SwissApp } from '@swissjs/core'
+import { App } from './App.uix'
+
+SwissApp.mount(App, '#root')`;
+
+      // Create App.uix with CSS imports (matching pos-site structure)
+      const appUix = `import { SwissComponent } from '@swissjs/core'
+import './styles/globals.css'
+import './styles/cyber-theme.css'
+
+export class App extends SwissComponent {
+  render() {
+    return <div>Test App</div>
+  }
+}`;
+
+      // Create CSS files
+      const globalsCss = `body { margin: 0; padding: 0; }`;
+      const cyberCss = `:root { --cyber-color: #00ff00; }`;
+
+      // Create HTML file
+      const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Test</title>
+</head>
+<body>
+  <div id="root"></div>
+</body>
+</html>`;
+
+      await fs.writeFile(path.join(srcDir, "index.ui"), indexUi);
+      await fs.writeFile(path.join(srcDir, "App.uix"), appUix);
+      await fs.writeFile(path.join(stylesDir, "globals.css"), globalsCss);
+      await fs.writeFile(path.join(stylesDir, "cyber-theme.css"), cyberCss);
+      await fs.writeFile(path.join(publicDir, "index.html"), html);
+
+      // Test the extraction and injection
+      const resultHtml = await extractAndInjectCSS(testDir, html);
+
+      // Verify CSS links were injected
+      assert.ok(resultHtml.includes('<link rel="stylesheet" href="/src/styles/globals.css">'));
+      assert.ok(resultHtml.includes('<link rel="stylesheet" href="/src/styles/cyber-theme.css">'));
+      assert.ok(resultHtml.includes('</head>'));
+      
+      // Verify HTML structure is intact
+      assert.ok(resultHtml.includes('<div id="root"></div>'));
+      assert.ok(resultHtml.includes('<!DOCTYPE html>'));
+      
+      console.log("\n=== HTML WITH CSS INJECTED ===");
+      console.log(resultHtml);
+    } finally {
+      // Clean up
+      try {
+        await fs.rm(testDir, { recursive: true, force: true });
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    }
+  });
+
+  test("should handle missing entry point gracefully", async () => {
+    const html = `<!DOCTYPE html>
+<html>
+<head>
+  <title>Test</title>
+</head>
+<body></body>
+</html>`;
+
+    // Should not throw even if entry point doesn't exist
+    const resultHtml = await extractAndInjectCSS("/nonexistent/path", html);
+    
+    // Should return HTML unchanged
+    assert.strictEqual(resultHtml, html);
+  });
+
+  test("should handle entry point without CSS imports", async () => {
+    const srcDir = path.join(testDir, "src");
+    await fs.mkdir(srcDir, { recursive: true });
+
+    try {
+      const indexUi = `import { SwissApp } from '@swissjs/core'
+import { App } from './App.uix'
+
+SwissApp.mount(App, '#root')`;
+
+      const appUix = `import { SwissComponent } from '@swissjs/core'
+
+export class App extends SwissComponent {
+  render() {
+    return <div>No CSS</div>
+  }
+}`;
+
+      const html = `<!DOCTYPE html>
+<html>
+<head>
+  <title>Test</title>
+</head>
+<body></body>
+</html>`;
+
+      await fs.writeFile(path.join(srcDir, "index.ui"), indexUi);
+      await fs.writeFile(path.join(srcDir, "App.uix"), appUix);
+
+      const resultHtml = await extractAndInjectCSS(testDir, html);
+      
+      // Should return HTML unchanged (no CSS to inject)
+      assert.strictEqual(resultHtml, html);
+    } finally {
+      try {
+        await fs.rm(testDir, { recursive: true, force: true });
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    }
+  });
+});

package/__tests__/css-middleware.test.ts

@@ -0,0 +1,191 @@
+/**
+ * Test CSS extraction middleware function directly
+ */
+
+import { test, describe } from "node:test";
+import { strict as assert } from "node:assert";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { fileURLToPath } from "node:url";
+import type { Request, Response } from "express";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const testDir = path.join(__dirname, "..", "..", "..", "test-css-middleware");
+
+// Extract the CSS extraction logic as a testable function
+async function extractCSSImports(configRoot: string): Promise<string[]> {
+  const entryPointPath = path.join(configRoot, "src", "index.ui");
+  
+  try {
+    const entryPointContent = await fs.readFile(entryPointPath, "utf-8");
+    
+    const cssImportPattern = /import\s+['"](.*?\.css)['"];?/g;
+    const cssImports = new Set<string>();
+    let match;
+    
+    // Check entry point
+    while ((match = cssImportPattern.exec(entryPointContent)) !== null) {
+      cssImports.add(match[1]);
+    }
+    
+    // Check imported files
+    const importPattern = /import\s+.*?from\s+['"](.*?)['"];?/g;
+    const importedFiles: string[] = [];
+    let importMatch;
+    cssImportPattern.lastIndex = 0;
+    while ((importMatch = importPattern.exec(entryPointContent)) !== null) {
+      const importPath = importMatch[1];
+      if (!importPath.startsWith("@") && !importPath.startsWith("/") && !importPath.startsWith(".")) {
+        continue;
+      }
+      if (importPath.startsWith(".")) {
+        importedFiles.push(importPath);
+      }
+    }
+    
+    // Check imported files for CSS
+    for (const importedFile of importedFiles) {
+      try {
+        const importedFilePath = path.resolve(path.dirname(entryPointPath), importedFile);
+        const extensions = [".uix", ".ui", ".ts", ".js"];
+        let found = false;
+        for (const ext of extensions) {
+          const testPath = importedFilePath.endsWith(ext) ? importedFilePath : importedFilePath + ext;
+          try {
+            const importedContent = await fs.readFile(testPath, "utf-8");
+            found = true;
+            cssImportPattern.lastIndex = 0;
+            let cssMatch2;
+            while ((cssMatch2 = cssImportPattern.exec(importedContent)) !== null) {
+              const cssPath = cssMatch2[1];
+              if (cssPath.startsWith(".")) {
+                const resolvedCssPath = path.resolve(path.dirname(testPath), cssPath);
+                const relativeCssPath = path.relative(path.join(configRoot, "src"), resolvedCssPath);
+                const normalizedPath = relativeCssPath.replace(/\\/g, "/");
+                cssImports.add(normalizedPath);
+              } else {
+                cssImports.add(cssPath);
+              }
+            }
+            break;
+          } catch (err) {
+            // File doesn't exist with this extension, try next
+          }
+        }
+      } catch (error) {
+        // Could not read imported file, skip
+      }
+    }
+    
+    return Array.from(cssImports);
+  } catch (error) {
+    // If entry point doesn't exist or can't be read, return empty array
+    return [];
+  }
+}
+
+function injectCSSLinks(html: string, cssImports: string[]): string {
+  if (cssImports.length === 0) {
+    return html;
+  }
+  
+  const cssLinks = cssImports.map(cssPath => {
+    const url = cssPath.startsWith("/") ? cssPath : `/src/${cssPath}`;
+    return `    <link rel="stylesheet" href="${url}">`;
+  }).join("\n");
+  
+  const beforeReplace = html;
+  html = html.replace(/\s*<\/head>/i, `${cssLinks}\n  </head>`);
+  if (html === beforeReplace) {
+    throw new Error("Failed to inject CSS links - </head> not found");
+  }
+  
+  return html;
+}
+
+describe("CSS Middleware Function", () => {
+  test("should extract CSS from pos-site structure", async () => {
+    const srcDir = path.join(testDir, "src");
+    const stylesDir = path.join(srcDir, "styles");
+    
+    await fs.mkdir(srcDir, { recursive: true });
+    await fs.mkdir(stylesDir, { recursive: true });
+
+    try {
+      // Create files matching pos-site structure
+      const indexUi = `import { SwissApp } from '@swissjs/core'
+import { App } from './App.uix'
+
+SwissApp.mount(App, '#root')`;
+
+      const appUix = `import { SwissComponent } from '@swissjs/core'
+import './styles/globals.css'
+import './styles/cyber-theme.css'
+
+export class App extends SwissComponent {
+  render() {
+    return <div>App</div>
+  }
+}`;
+
+      await fs.writeFile(path.join(srcDir, "index.ui"), indexUi);
+      await fs.writeFile(path.join(srcDir, "App.uix"), appUix);
+      await fs.writeFile(path.join(stylesDir, "globals.css"), "body { margin: 0; }");
+      await fs.writeFile(path.join(stylesDir, "cyber-theme.css"), ":root { --color: #00ff00; }");
+
+      // Test extraction
+      const cssImports = await extractCSSImports(testDir);
+      
+      assert.strictEqual(cssImports.length, 2);
+      assert.ok(cssImports.includes("styles/globals.css"));
+      assert.ok(cssImports.includes("styles/cyber-theme.css"));
+
+      // Test injection
+      const html = `<!DOCTYPE html>
+<html>
+<head>
+  <title>Test</title>
+</head>
+<body></body>
+</html>`;
+
+      const resultHtml = injectCSSLinks(html, cssImports);
+      
+      assert.ok(resultHtml.includes('<link rel="stylesheet" href="/src/styles/globals.css">'));
+      assert.ok(resultHtml.includes('<link rel="stylesheet" href="/src/styles/cyber-theme.css">'));
+      
+      console.log("\n=== EXTRACTED CSS IMPORTS ===");
+      console.log(cssImports);
+      console.log("\n=== HTML WITH CSS ===");
+      console.log(resultHtml);
+    } finally {
+      try {
+        await fs.rm(testDir, { recursive: true, force: true });
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    }
+  });
+
+  test("should match actual pos-site file structure", async () => {
+    // Test with actual pos-site structure
+    const posSiteRoot = path.join(__dirname, "..", "..", "..", "websites", "pos-site");
+    
+    try {
+      const cssImports = await extractCSSImports(posSiteRoot);
+      
+      console.log("\n=== POS SITE CSS IMPORTS ===");
+      console.log(`Found ${cssImports.length} CSS import(s):`, cssImports);
+      
+      // Should find the CSS imports from App.uix
+      assert.ok(cssImports.length >= 2, "Should find at least 2 CSS imports");
+      assert.ok(
+        cssImports.some(css => css.includes("globals.css") || css.includes("cyber-theme.css")),
+        "Should find globals.css or cyber-theme.css"
+      );
+    } catch (error) {
+      // If pos-site doesn't exist, skip this test
+      console.log("Skipping pos-site test - directory not found");
+    }
+  });
+});