@swissjs/swite 0.3.0

package/dist/import-rewriter.js

@@ -0,0 +1,351 @@
+/*
+ * Import Rewriter for SWITE
+ *
+ * SIMPLIFIED APPROACH:
+ * - es-module-lexer ONLY returns static import specifiers (string literals)
+ * - If es-module-lexer found it, it's ALWAYS an import, never a variable
+ * - Trust the lexer and rewrite everything it finds (except relative imports)
+ * - Let the resolver handle resolution, fallback to CDN if needed
+ */
+import { init, parse } from "es-module-lexer";
+import { ModuleResolver } from "./resolver.js";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { shouldUseCdnFallback } from "./utils/cdn-fallback.js";
+export async function rewriteImports(code, importer, resolver) {
+    await init;
+    try {
+        const [imports] = parse(code);
+        console.log(`[SWITE] import-rewriter: Found ${imports.length} import(s) in ${importer}`);
+        if (imports.length === 0) {
+            console.log(`[SWITE] import-rewriter: No imports found, returning original code`);
+            return code;
+        }
+        let rewritten = code;
+        let offset = 0;
+        for (const imp of imports) {
+            let { s: start, e: end } = imp;
+            const specifier = code.slice(start, end);
+            console.log(`[SWITE] import-rewriter: Processing import: "${specifier}"`);
+            // Skip CSS imports - these should be handled as static assets, not modules
+            if (specifier.includes(".css")) {
+                console.log(`[SWITE] import-rewriter: Skipping CSS import: "${specifier}"`);
+                continue;
+            }
+            // Extract quote character and actual specifier
+            const firstChar = specifier[0];
+            const lastChar = specifier[specifier.length - 1];
+            const hasQuotes = (firstChar === '"' || firstChar === "'") && firstChar === lastChar;
+            let actualSpecifier;
+            let quoteChar = null;
+            if (hasQuotes) {
+                actualSpecifier = specifier.slice(1, -1);
+                quoteChar = firstChar;
+            }
+            else {
+                // Unquoted - check surrounding code for quotes
+                const codeBefore = code.slice(Math.max(0, start - 1), start);
+                const codeAfter = code.slice(end, Math.min(code.length, end + 1));
+                if ((codeBefore === '"' || codeBefore === "'") &&
+                    codeBefore === codeAfter) {
+                    quoteChar = codeBefore;
+                    actualSpecifier = specifier;
+                    start = start - 1;
+                    end = end + 1;
+                }
+                else {
+                    // No quotes found - this shouldn't happen with es-module-lexer for static imports
+                    // But if it does, try to find the quoted version in the code
+                    const escapedSpecifier = specifier.replace(/[.*+?^${}()|[\]\\-]/g, "\\$&");
+                    const quotedPattern = new RegExp(`(['"])${escapedSpecifier}\\1`);
+                    const match = quotedPattern.exec(code);
+                    if (match) {
+                        quoteChar = match[1];
+                        actualSpecifier = specifier;
+                        start = match.index;
+                        end = match.index + match[0].length;
+                    }
+                    else {
+                        // Can't find quotes, skip this import (shouldn't happen)
+                        console.warn(`[SWITE] import-rewriter: Could not find quotes for specifier: ${specifier}`);
+                        continue;
+                    }
+                }
+            }
+            // CRITICAL: Fix compiler bug where .uix/.ui imports are changed to .js or .tsx
+            // In dev mode, we need to preserve correct extensions for relative imports
+            // Context-aware: SWISS packages use .ts, app files use .uix/.ui
+            if (actualSpecifier.startsWith(".") && (actualSpecifier.endsWith(".js") || actualSpecifier.endsWith(".tsx")) && !actualSpecifier.includes("node_modules")) {
+                console.log(`[SWITE] import-rewriter: 🔧 Found relative .js import that needs fixing: "${actualSpecifier}"`);
+                // Determine correct extension based on context
+                // IMPORTANT: Check /lib/ and /swiss-packages/ FIRST before checking file extension
+                // Normalize path separators for Windows compatibility
+                const normalizedImporter = importer.replace(/\\/g, "/");
+                const isSwissPackage = normalizedImporter.includes("/swiss-packages/");
+                const isLibPath = normalizedImporter.includes("/lib/");
+                const isUixFile = normalizedImporter.endsWith(".uix") || normalizedImporter.endsWith(".ui");
+                let newExtension;
+                if (isSwissPackage) {
+                    // SWISS packages use .ts files
+                    newExtension = ".ts";
+                }
+                else if (isLibPath) {
+                    // /lib/ paths can have .ts, .ui, or .uix files
+                    // Default to .ts for /lib/ paths (most common - types, core logic, etc.)
+                    // Handlers will try .ui/.uix if .ts doesn't exist
+                    newExtension = ".ts";
+                    console.log(`[SWITE] import-rewriter: 🎯 /lib/ path detected - using .ts extension (importer: ${importer}, specifier: ${actualSpecifier})`);
+                }
+                else if (isUixFile) {
+                    // If importing from a .uix/.ui file, try to preserve the original extension
+                    // Check if the file exists with .ui extension first, then .uix
+                    const baseSpecifier = actualSpecifier.endsWith(".tsx") ? actualSpecifier.slice(0, -4) : actualSpecifier.slice(0, -3); // Remove .tsx or .js
+                    // Get the directory of the CURRENT file being rewritten (not project root)
+                    const currentDir = path.dirname(importer);
+                    // Clean the import path - remove leading './' if present
+                    const cleanImportPath = baseSpecifier.startsWith('./')
+                        ? baseSpecifier.slice(2)
+                        : baseSpecifier.startsWith('../')
+                            ? baseSpecifier
+                            : baseSpecifier;
+                    // Construct the absolute path to the potential .ui dependency
+                    const absoluteUiPath = path.resolve(currentDir, cleanImportPath + '.ui');
+                    const absoluteUixPath = path.resolve(currentDir, cleanImportPath + '.uix');
+                    console.log(`[SWITE] import-rewriter: Checking for .ui/.uix files: baseSpecifier="${baseSpecifier}", currentDir="${currentDir}", cleanImportPath="${cleanImportPath}"`);
+                    console.log(`[SWITE] import-rewriter: Checking paths: ${absoluteUiPath}, ${absoluteUixPath}`);
+                    // Check which file exists (prefer .ui since that's what source code uses)
+                    try {
+                        await fs.access(absoluteUiPath);
+                        newExtension = ".ui";
+                        console.log(`[SWITE] import-rewriter: ✅ Found .ui file: ${absoluteUiPath}`);
+                    }
+                    catch (err) {
+                        console.log(`[SWITE] import-rewriter: ❌ .ui file not found: ${absoluteUiPath} (${err instanceof Error ? err.message : String(err)})`);
+                        try {
+                            await fs.access(absoluteUixPath);
+                            newExtension = ".uix";
+                            console.log(`[SWITE] import-rewriter: ✅ Found .uix file: ${absoluteUixPath}`);
+                        }
+                        catch (err2) {
+                            // Neither exists, default to .ui (matches source code convention)
+                            newExtension = ".ui";
+                            console.log(`[SWITE] import-rewriter: ⚠️ Neither .ui nor .uix found, defaulting to .ui for ${baseSpecifier} (checked: ${absoluteUiPath}, ${absoluteUixPath})`);
+                        }
+                    }
+                }
+                else {
+                    // Default: TypeScript files use .ts
+                    newExtension = ".ts";
+                }
+                const baseSpecifier = actualSpecifier.endsWith(".tsx") ? actualSpecifier.slice(0, -4) : actualSpecifier.slice(0, -3); // Remove .tsx or .js
+                const newSpecifier = baseSpecifier + newExtension;
+                console.log(`[SWITE] import-rewriter: 🔧 Changing "${actualSpecifier}" -> "${newSpecifier}" (context: ${isSwissPackage ? 'swiss-pkg' : isUixFile ? 'uix' : 'ts'})`);
+                // Replace in the code using the original start/end positions
+                // If hasQuotes was true, start/end point to specifier WITHOUT quotes
+                // If hasQuotes was false but quotes found, start/end were adjusted to include quotes
+                const originalLength = end - start;
+                const before = rewritten.slice(0, start + offset);
+                const after = rewritten.slice(end + offset);
+                const finalSpecifier = quoteChar ? quoteChar + newSpecifier + quoteChar : `"${newSpecifier}"`;
+                rewritten = before + finalSpecifier + after;
+                offset += finalSpecifier.length - originalLength;
+                console.log(`[SWITE] import-rewriter: ✅ Fixed relative import: "${actualSpecifier}" -> "${newSpecifier}"`);
+                continue; // Don't process further (relative imports don't need module resolution)
+            }
+            // Skip other relative imports - they don't need rewriting
+            // BUT: Convert /swiss-lib/ paths to /swiss-packages/ paths
+            // Check for /swiss-lib/ anywhere in the path, not just at the start
+            if (actualSpecifier.includes("/swiss-lib/")) {
+                // Replace /swiss-lib/packages/ with /swiss-packages/ (not /swiss-packages/packages/)
+                const converted = actualSpecifier.replace(/\/swiss-lib\/packages\//g, "/swiss-packages/");
+                console.log(`[SWITE] import-rewriter: Converting /swiss-lib/ to /swiss-packages/: "${actualSpecifier}" -> "${converted}"`);
+                const originalLength = end - start;
+                const before = rewritten.slice(0, start + offset);
+                const after = rewritten.slice(end + offset);
+                const finalSpecifier = quoteChar ? quoteChar + converted + quoteChar : `"${converted}"`;
+                rewritten = before + finalSpecifier + after;
+                offset += finalSpecifier.length - originalLength;
+                continue;
+            }
+            if (actualSpecifier.startsWith(".") || actualSpecifier.startsWith("/")) {
+                continue;
+            }
+            // CRITICAL: es-module-lexer only returns static import specifiers
+            // If we got here, it's ALWAYS a module specifier, never a variable
+            // Just validate basic format (starts with letter or @)
+            if (!/^[@a-zA-Z]/.test(actualSpecifier)) {
+                console.warn(`[SWITE] import-rewriter: Invalid specifier format: ${actualSpecifier}`);
+                continue;
+            }
+            // Resolve the import
+            console.log(`[SWITE] import-rewriter: Resolving ${actualSpecifier} from ${importer}`);
+            let resolved;
+            try {
+                resolved = await resolver.resolve(actualSpecifier, importer);
+                console.log(`[SWITE] import-rewriter: Resolved ${actualSpecifier} -> ${resolved}`);
+                // CRITICAL: If resolver returns unchanged or invalid, use CDN fallback (when allowed).
+                if (!resolved ||
+                    resolved === actualSpecifier ||
+                    (!resolved.startsWith("/") && !resolved.startsWith("http"))) {
+                    console.warn(`[SWITE] import-rewriter: Resolver returned invalid/unchanged result for ${actualSpecifier}, using CDN fallback`);
+                    resolved = shouldUseCdnFallback(actualSpecifier)
+                        ? `https://cdn.jsdelivr.net/npm/${actualSpecifier}/+esm`
+                        : `/node_modules/${actualSpecifier}`;
+                }
+            }
+            catch (error) {
+                console.error(`[SWITE] import-rewriter: Error resolving ${actualSpecifier}:`, error);
+                resolved = shouldUseCdnFallback(actualSpecifier)
+                    ? `https://cdn.jsdelivr.net/npm/${actualSpecifier}/+esm`
+                    : `/node_modules/${actualSpecifier}`;
+            }
+            // For development: prefer src/ over dist/ for SWISS and workspace packages
+            if (resolved.includes("/dist/")) {
+                const isSwissOrPackages = resolved.includes("/swiss-packages/") || resolved.includes("/packages/");
+                if (isSwissOrPackages) {
+                    resolved = resolved.replace("/dist/", "/src/").replace(/\.js$/, ".ts");
+                }
+            }
+            // Replace the specifier
+            console.log(`[SWITE] import-rewriter: Replacing "${actualSpecifier}" with "${resolved}" (quoteChar: ${quoteChar})`);
+            if (quoteChar) {
+                const originalLength = end - start;
+                const before = rewritten.slice(0, start + offset);
+                const after = rewritten.slice(end + offset);
+                const finalResolved = quoteChar + resolved + quoteChar;
+                rewritten = before + finalResolved + after;
+                offset += finalResolved.length - originalLength;
+                console.log(`[SWITE] import-rewriter: ✅ Replaced "${actualSpecifier}" with "${finalResolved}"`);
+            }
+            else {
+                // No quote char (shouldn't happen, but handle it)
+                const before = rewritten.slice(0, start + offset);
+                const after = rewritten.slice(end + offset);
+                const finalResolved = `"${resolved}"`;
+                rewritten = before + finalResolved + after;
+                offset += finalResolved.length - (end - start);
+                console.log(`[SWITE] import-rewriter: ✅ Replaced (no quote) "${actualSpecifier}" with "${finalResolved}"`);
+            }
+            // CRITICAL: Verify the replacement worked
+            if (rewritten.includes(actualSpecifier) &&
+                !rewritten.includes(resolved)) {
+                console.error(`[SWITE] import-rewriter: ⚠️ WARNING - Replacement failed! Import "${actualSpecifier}" still in code but "${resolved}" not found`);
+                // FORCE replacement as last resort
+                console.error(`[SWITE] import-rewriter: 🔧 FORCING replacement of "${actualSpecifier}" with "${resolved}"`);
+                rewritten = rewritten.replace(new RegExp(actualSpecifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), resolved);
+            }
+        }
+        // FINAL CHECK: Ensure no bare imports remain
+        const bareImportPattern = /(?:import|from|export).*['"](@[^'"]+\/[^'"]+)[^'"]*['"]/;
+        if (bareImportPattern.test(rewritten)) {
+            const matches = Array.from(rewritten.matchAll(bareImportPattern));
+            for (const match of matches) {
+                const bareImport = match[1];
+                if (!bareImport.startsWith("/") &&
+                    !bareImport.startsWith("http") &&
+                    !bareImport.startsWith(".")) {
+                    console.error(`[SWITE] import-rewriter: ⚠️ CRITICAL - Bare import "${bareImport}" still in code after rewriting!`);
+                    const replacement = shouldUseCdnFallback(bareImport)
+                        ? `https://cdn.jsdelivr.net/npm/${bareImport}/+esm`
+                        : `/node_modules/${bareImport}`;
+                    rewritten = rewritten.replace(new RegExp(bareImport.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), replacement);
+                    console.error(`[SWITE] import-rewriter: 🔧 FORCED replacement of "${bareImport}" with "${replacement}"`);
+                }
+            }
+        }
+        // CRITICAL: Apply additional regex-based fix for relative .js imports
+        // This catches any cases the lexer-based approach might miss
+        // BUT: We need to be context-aware:
+        // - If importer is in /swiss-packages/, change .js to .ts (SWISS packages use .ts)
+        // - If importer is a .uix/.ui file, change .js to .uix (app files)
+        // - Otherwise, change .js to .ts (default for TypeScript files)
+        const relativeJsImportRegex = /from\s+(["'])(\.\.?\/[^"']*?)(\.js|\.tsx)(\1)/g;
+        const beforeRegexFix = rewritten;
+        let regexFixCount = 0;
+        // Normalize path separators for Windows compatibility
+        const normalizedImporter = importer.replace(/\\/g, "/");
+        const isSwissPackage = normalizedImporter.includes("/swiss-packages/");
+        const isUixFile = normalizedImporter.endsWith(".uix") || normalizedImporter.endsWith(".ui");
+        rewritten = rewritten.replace(relativeJsImportRegex, (match, quote, path, jsExt, endQuote) => {
+            // Skip if it's in node_modules or absolute paths
+            if (path.includes("node_modules") || !path.startsWith(".")) {
+                return match;
+            }
+            // Determine correct extension based on context
+            // IMPORTANT: Check /lib/ and /swiss-packages/ FIRST before checking file extension
+            // Normalize path separators for Windows compatibility (importer is a file system path)
+            const normalizedImporter = importer.replace(/\\/g, "/");
+            const isLibPath = normalizedImporter.includes("/lib/");
+            let newExtension;
+            if (isSwissPackage) {
+                // SWISS packages use .ts files
+                newExtension = ".ts";
+            }
+            else if (isLibPath) {
+                // /lib/ paths can have .ts, .ui, or .uix files
+                // Default to .ts for /lib/ paths (most common - types, core logic, etc.)
+                // Handlers will try .ui/.uix if .ts doesn't exist
+                newExtension = ".ts";
+                console.log(`[SWITE] import-rewriter: 🎯 Regex /lib/ path detected - using .ts extension (importer: ${importer})`);
+            }
+            else if (isUixFile) {
+                // If importing from a .uix/.ui file, check what the actual file extension is
+                // The source code uses .ui, so we should preserve that
+                // Only use .uix if the source file is actually .uix
+                if (normalizedImporter.endsWith(".ui")) {
+                    // Source is .ui, so imports should also be .ui (not .uix)
+                    newExtension = ".ui";
+                }
+                else {
+                    // Source is .uix, imports can be .uix
+                    newExtension = ".uix";
+                }
+            }
+            else {
+                // Default: TypeScript files use .ts
+                newExtension = ".ts";
+            }
+            const newPath = path + newExtension;
+            console.log(`[SWITE] import-rewriter: 🔧 Regex fix (context: ${isSwissPackage ? 'swiss-pkg' : isUixFile ? 'uix' : 'ts'}): ${match} -> from ${quote}${newPath}${endQuote}`);
+            regexFixCount++;
+            return `from ${quote}${newPath}${endQuote}`;
+        });
+        if (regexFixCount > 0) {
+            console.log(`[SWITE] import-rewriter: ✅ Regex fix applied ${regexFixCount} change(s)`);
+        }
+        else {
+            // Debug: Check if there are any relative .js imports that weren't caught
+            const testRegex = /from\s+["'](\.\.?\/[^"']+\.js)["']/g;
+            const testMatches = Array.from(rewritten.matchAll(testRegex));
+            if (testMatches.length > 0) {
+                console.log(`[SWITE] import-rewriter: ⚠️  Found ${testMatches.length} relative .js import(s) that weren't fixed:`);
+                testMatches.slice(0, 3).forEach(m => console.log(`  - ${m[0]}`));
+            }
+        }
+        // Final pass: Convert any remaining /swiss-lib/ paths to /swiss-packages/
+        // This catches paths that might have been generated by the compiler or resolver
+        // Use multiple passes to catch all variations
+        if (rewritten.includes("/swiss-lib/")) {
+            const beforeFinal = rewritten;
+            // Pass 1: Replace /swiss-lib/packages/ with /swiss-packages/
+            rewritten = rewritten.replace(/\/swiss-lib\/packages\//g, "/swiss-packages/");
+            // Pass 2: Replace any remaining /swiss-lib/ with /swiss-packages/
+            rewritten = rewritten.replace(/\/swiss-lib\//g, "/swiss-packages/");
+            // Pass 3: Fix in quoted strings (both single and double quotes)
+            rewritten = rewritten.replace(/(['"])\/swiss-lib\//g, '$1/swiss-packages/');
+            if (beforeFinal !== rewritten) {
+                console.log(chalk.yellow(`[SWITE] import-rewriter: Final pass converted /swiss-lib/ to /swiss-packages/ (${beforeFinal.split('/swiss-lib/').length - 1} occurrences)`));
+            }
+        }
+        console.log(`[SWITE] import-rewriter: Finished rewriting ${imports.length} import(s) in ${importer}`);
+        return rewritten;
+    }
+    catch (error) {
+        console.error(`[SWITE] import-rewriter: Error rewriting imports in ${importer}:`, error);
+        if (error instanceof Error) {
+            console.error(`[SWITE] import-rewriter: Error stack:`, error.stack);
+        }
+        return code; // Return original on error
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { SwiteServer } from "./server.js";
+export type { SwiteConfig } from "./server.js";
+export { SwiteBuilder, build } from "./builder.js";
+export type { BuildConfig } from "./builder.js";
+export { ModuleResolver } from "./resolver.js";
+export { HMREngine } from "./hmr.js";
+export { defineConfig } from "./config.js";
+export type { SwiteUserConfig, ServerConfig, ServicesConfig, PythonServiceConfig, } from "./config.js";
+export { proxyToPython, initPythonProxy, setProductionMode } from "./proxy/proxyToPython.js";
+export type { ProxyOptions } from "./proxy/proxyToPython.js";
+export { SwiteProxyError } from "./proxy/SwiteProxyError.js";
+export { loadUserConfig } from "./config-loader.js";
+export { startPythonDevService, stopPythonDevService, } from "./dev/pythonDevManager.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EACV,eAAe,EACf,YAAY,EACZ,cAAc,EACd,mBAAmB,GACpB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7F,YAAY,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EACL,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+/*
+ * SWITE - SWISS Development Server
+ * Main exports
+ */
+export { SwiteServer } from "./server.js";
+export { SwiteBuilder, build } from "./builder.js";
+export { ModuleResolver } from "./resolver.js";
+export { HMREngine } from "./hmr.js";
+export { defineConfig } from "./config.js";
+export { proxyToPython, initPythonProxy, setProductionMode } from "./proxy/proxyToPython.js";
+export { SwiteProxyError } from "./proxy/SwiteProxyError.js";
+export { loadUserConfig } from "./config-loader.js";
+export { startPythonDevService, stopPythonDevService, } from "./dev/pythonDevManager.js";

package/dist/middleware/hmr-routes.d.ts

@@ -0,0 +1,12 @@
+import type { Express } from "express";
+import type { RouteDefinition } from "@kibologic/core";
+import { HMREngine } from "../hmr.js";
+export interface HMRRoutesConfig {
+    hmr: HMREngine;
+    routes: RouteDefinition[];
+}
+/**
+ * Setup HMR client endpoint and routes endpoint
+ */
+export declare function setupHMRRoutes(app: Express, config: HMRRoutesConfig): void;
+//# sourceMappingURL=hmr-routes.d.ts.map

package/dist/middleware/hmr-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmr-routes.d.ts","sourceRoot":"","sources":["../../src/middleware/hmr-routes.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,SAAS,CAAC;IACf,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAqG1E"}

package/dist/middleware/hmr-routes.js

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+import { HMREngine } from "../hmr.js";
+/**
+ * Setup HMR client endpoint and routes endpoint
+ */
+export function setupHMRRoutes(app, config) {
+    // HMR client injection
+    app.get("/__swite_hmr_client", (req, res) => {
+        res.setHeader("Content-Type", "application/javascript");
+        res.send(config.hmr.getClientScript());
+    });
+    // Routes endpoint - expose route definitions to client
+    app.get("/__swite_routes", (req, res) => {
+        res.setHeader("Content-Type", "application/json");
+        // Serialize routes for client - functions can't be serialized, so we include httpUrl in meta
+        // The client will use httpUrl to dynamically import the component
+        const serializedRoutes = config.routes.map((route) => ({
+            path: route.path,
+            meta: route.meta,
+            // Include httpUrl from meta so client can import it
+            componentUrl: route.meta?.httpUrl || null,
+        }));
+        res.json({ routes: serializedRoutes });
+    });
+    // Diagnostic endpoint - check what the server is actually serving
+    app.get("/__swite_diagnose", async (req, res) => {
+        const url = req.query.url;
+        if (!url) {
+            res.json({ error: "Missing url query parameter" });
+            return;
+        }
+        try {
+            // Try to fetch what we would serve
+            const testRes = await fetch(`http://localhost:${req.socket.localPort}${url}`);
+            const content = await testRes.text();
+            const hasBareImport = /(?:import|from|export).*['"](@[^'"]+\/[^'"]+)(?!\/)[^'"]*['"]/.test(content);
+            res.json({
+                url,
+                status: testRes.status,
+                hasBareImport,
+                contentPreview: content.substring(0, 500),
+                imports: Array.from(content.matchAll(/(?:import|from|export).*['"]([^'"]+)['"]/g))
+                    .slice(0, 10)
+                    .map((m) => m[1]),
+            });
+        }
+        catch (error) {
+            res.json({ error: String(error) });
+        }
+    });
+    // Force cache clear endpoint - returns HTML with aggressive cache busting
+    app.get("/__swite_clear_cache", async (req, res) => {
+        res.setHeader("Content-Type", "text/html");
+        res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate, max-age=0");
+        res.setHeader("Pragma", "no-cache");
+        res.setHeader("Expires", "0");
+        res.send(`
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>Cache Cleared</title>
+          <meta http-equiv="Cache-Control" content="no-cache, no-store, must-revalidate">
+          <meta http-equiv="Pragma" content="no-cache">
+          <meta http-equiv="Expires" content="0">
+          <script>
+            // Clear all caches
+            if ('caches' in window) {
+              caches.keys().then(names => {
+                names.forEach(name => caches.delete(name));
+                console.log('All caches cleared');
+              });
+            }
+            // Clear service workers
+            if ('serviceWorker' in navigator) {
+              navigator.serviceWorker.getRegistrations().then(registrations => {
+                registrations.forEach(reg => reg.unregister());
+                console.log('Service workers unregistered');
+              });
+            }
+            // Redirect to home
+            setTimeout(() => {
+              window.location.href = '/?nocache=' + Date.now();
+            }, 1000);
+          </script>
+        </head>
+        <body>
+          <h1>Clearing cache...</h1>
+          <p>Redirecting in 1 second...</p>
+        </body>
+      </html>
+    `);
+    });
+}

package/dist/middleware/middleware-setup.d.ts

@@ -0,0 +1,23 @@
+import type { Express } from "express";
+import type { RouteDefinition } from "@kibologic/core";
+import { RouteScanner } from "@kibologic/plugin-file-router/core";
+import { createFileWatcher } from "@kibologic/plugin-file-router/dev";
+import { ModuleResolver } from "../resolver.js";
+import { HMREngine } from "../hmr.js";
+export interface MiddlewareConfig {
+    root: string;
+    workspaceRoot?: string | null;
+    publicDir: string;
+    resolver: ModuleResolver;
+    hmr: HMREngine;
+}
+export interface MiddlewareResult {
+    routes: RouteDefinition[];
+    routeScanner: RouteScanner | null;
+    routeWatcher: Awaited<ReturnType<typeof createFileWatcher>> | null;
+}
+/**
+ * Setup all middleware for the SWITE server
+ */
+export declare function setupMiddleware(app: Express, config: MiddlewareConfig): Promise<MiddlewareResult>;
+//# sourceMappingURL=middleware-setup.d.ts.map

package/dist/middleware/middleware-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-setup.d.ts","sourceRoot":"","sources":["../../src/middleware/middleware-setup.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAmC,MAAM,SAAS,CAAC;AAExE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAItE,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAahD,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAItC,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,cAAc,CAAC;IACzB,GAAG,EAAE,SAAS,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAClC,YAAY,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,GAAG,IAAI,CAAC;CACpE;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAw0B3B"}