@swissjs/swite 0.3.0

package/src/resolution/bare-import-resolver.ts

@@ -0,0 +1,400 @@
+/*
+ * Bare Import Resolver - Resolves bare module specifiers (@swissjs/core, etc.)
+ * Extracted from resolver.ts for modularity
+ */
+
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import chalk from "chalk";
+import { findSwissLibMonorepo } from "../kernel/package-finder.js";
+import { shouldUseCdnFallback } from "./cdn/cdn-fallback.js";
+import type { UrlResolverContext, WorkspacePackageResolverContext } from "./url-resolver.js";
+import { resolveWorkspacePackage } from "./workspace-package-resolver.js";
+import { toUrl } from "./url-resolver.js";
+
+export interface BareImportResolverContext extends UrlResolverContext {
+  resolveWorkspacePackage: (pkgName: string) => Promise<string | null>;
+}
+
+/**
+ * Resolve bare import specifier (e.g., @swissjs/core, react, etc.)
+ */
+export async function resolveBareImport(
+  specifier: string,
+  context: BareImportResolverContext
+): Promise<string> {
+
+  // Extract package name outside the try/catch so fallback logic can reference it.
+  // This must stay project-agnostic: works for both scoped and unscoped packages.
+  const parts = specifier.split("/");
+  const isScoped = specifier.startsWith("@");
+  const pkgName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
+  const subPath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
+
+  try {
+    // Find package.json - check multiple node_modules locations
+    let pkgDir: string | null = null;
+    let pkgJsonPath: string | null = null;
+
+    const nodeModulesLocations: string[] = [
+      path.join(context.root, "node_modules"),
+      path.join(path.dirname(context.root), "node_modules"),
+    ];
+
+    // Add workspace root node_modules
+    const workspaceRoot = await context.getWorkspaceRoot();
+    if (workspaceRoot) {
+      nodeModulesLocations.push(path.join(workspaceRoot, "node_modules"));
+    }
+
+    // Add swiss-lib monorepo node_modules
+    const swissLib = await findSwissLibMonorepo(context.root);
+    if (swissLib) {
+      const swissNodeModules = path.join(swissLib, "node_modules");
+      if (await context.fileExists(swissNodeModules)) {
+        nodeModulesLocations.push(swissNodeModules);
+      }
+    }
+
+    // Try each location
+    for (const nodeModulesPath of nodeModulesLocations) {
+      const testPkgDir = path.join(nodeModulesPath, pkgName);
+      const testPkgJsonPath = path.join(testPkgDir, "package.json");
+      if (await context.fileExists(testPkgJsonPath)) {
+        pkgDir = testPkgDir;
+        pkgJsonPath = testPkgJsonPath;
+        break;
+      }
+    }
+
+    if (!pkgJsonPath || !pkgDir) {
+      const workspacePkg = await context.resolveWorkspacePackage(pkgName);
+      if (workspacePkg) {
+        return await resolveWorkspacePackageEntry(
+          workspacePkg,
+          pkgName,
+          subPath,
+          specifier,
+          context,
+        );
+      }
+
+      if (!shouldUseCdnFallback(pkgName)) {
+        console.warn(
+          `[SWITE] Package ${pkgName} not found anywhere. Scoped package detected; CDN fallback is disabled by default.`,
+        );
+        return `/node_modules/${specifier}`;
+      }
+
+      console.warn(`[SWITE] Package ${pkgName} not found anywhere, using CDN fallback`);
+      return `https://cdn.jsdelivr.net/npm/${specifier}/+esm`;
+    }
+
+    // Continue with normal resolution if we found it
+    if (pkgJsonPath && pkgDir) {
+      return await resolveWorkspacePackageEntry(pkgDir, pkgName, subPath, specifier, context);
+    }
+
+    // Check if this is a workspace package (symlinked)
+    let realPkgDir: string;
+    try {
+      realPkgDir = await fs.realpath(pkgDir);
+    } catch {
+      realPkgDir = pkgDir;
+    }
+
+    const workspacePkg = await context.resolveWorkspacePackage(pkgName);
+    if (workspacePkg) {
+      const normalizedWorkspacePkg = path
+        .resolve(workspacePkg)
+        .replace(/\\/g, "/")
+        .toLowerCase();
+      const normalizedRealPkgDir = path
+        .resolve(realPkgDir)
+        .replace(/\\/g, "/")
+        .toLowerCase();
+
+      // If the real path is the workspace package, use workspace resolution
+      if (
+        normalizedRealPkgDir === normalizedWorkspacePkg ||
+        normalizedRealPkgDir.includes(normalizedWorkspacePkg)
+      ) {
+        return await resolveWorkspacePackageEntry(
+          workspacePkg,
+          pkgName,
+          subPath,
+          specifier,
+          context,
+        );
+      }
+    }
+
+    // Read package.json for exports/main resolution
+    const pkgJson = JSON.parse(await fs.readFile(pkgJsonPath!, "utf-8"));
+
+    // Handle exports field if present
+    if (pkgJson.exports) {
+      const exportKey = subPath ? `./${subPath}` : ".";
+      const exportEntry = pkgJson.exports[exportKey];
+
+      if (exportEntry) {
+        let entryPoint: string;
+        if (typeof exportEntry === "string") {
+          entryPoint = exportEntry;
+        } else if (exportEntry.import) {
+          entryPoint = exportEntry.import;
+        } else if (exportEntry.default) {
+          entryPoint = exportEntry.default;
+        } else {
+          entryPoint = exportEntry as unknown as string;
+        }
+
+        const fullPath = path.join(pkgDir, entryPoint);
+
+        // Prefer source over dist
+        const normalizedFullPath = fullPath.replace(/\\/g, "/");
+        if (normalizedFullPath.includes("/dist/")) {
+          const srcFullPath = normalizedFullPath
+            .replace("/dist/", "/src/")
+            .replace(/\.js$/, ".ts");
+          if (await context.fileExists(srcFullPath)) {
+            return await toUrl(srcFullPath, context);
+          }
+        }
+
+        if (await context.fileExists(fullPath)) {
+          return await toUrl(fullPath, context);
+        }
+
+        // Try extensions
+        for (const ext of [".js", ".mjs", ".ts", ".ui", ".uix"]) {
+          const withExt = fullPath.replace(/\.(js|mjs|ts|ui|uix)$/, ext);
+          if (await context.fileExists(withExt)) {
+            return await toUrl(withExt, context);
+          }
+        }
+
+        // Try case-insensitive match
+        const dir = path.dirname(fullPath);
+        const fileName = path.basename(fullPath);
+        try {
+          const files = await fs.readdir(dir);
+          const caseInsensitiveMatch = files.find(
+            (f) => f.toLowerCase() === fileName.toLowerCase(),
+          );
+          if (caseInsensitiveMatch) {
+            const correctedPath = path.join(dir, caseInsensitiveMatch);
+            if (await context.fileExists(correctedPath)) {
+              console.log(
+                chalk.yellow(
+                  `[SWITE] Case-insensitive match for ${pkgName}: ${fileName} -> ${caseInsensitiveMatch}`,
+                ),
+              );
+              return await toUrl(correctedPath, context);
+            }
+          }
+        } catch {
+          // Directory doesn't exist, continue to fallback
+        }
+      }
+    }
+
+    // Determine entry point
+    let entryPoint: string;
+    if (subPath) {
+      entryPoint = subPath;
+    } else {
+      entryPoint = pkgJson.module || pkgJson.main || "index.js";
+    }
+
+    const fullPath = path.join(pkgDir, entryPoint);
+
+    // Try the exact path first
+    if (await context.fileExists(fullPath)) {
+      return await toUrl(fullPath, context);
+    }
+
+    // Try with extensions
+    for (const ext of [".js", ".mjs", ".ts", ".ui", ".uix"]) {
+      if (await context.fileExists(fullPath + ext)) {
+        return await toUrl(fullPath + ext, context);
+      }
+    }
+
+    // Fallback to CDN (jsDelivr; esm.sh returns 500 for some packages) when allowed.
+    console.warn(`[SWITE] Could not resolve ${specifier}, using fallback`);
+    return shouldUseCdnFallback(pkgName)
+      ? `https://cdn.jsdelivr.net/npm/${specifier}/+esm`
+      : `/node_modules/${specifier}`;
+  } catch (error) {
+    console.warn(`[SWITE] Error resolving ${specifier}:`, error);
+    return shouldUseCdnFallback(pkgName)
+      ? `https://cdn.jsdelivr.net/npm/${specifier}/+esm`
+      : `/node_modules/${specifier}`;
+  }
+}
+
+/**
+ * Resolve entry point for workspace package
+ */
+async function resolveWorkspacePackageEntry(
+  workspacePkg: string,
+  pkgName: string,
+  subPath: string,
+  specifier: string,
+  context: BareImportResolverContext,
+): Promise<string> {
+  const workspacePkgJson = JSON.parse(
+    await fs.readFile(path.join(workspacePkg, "package.json"), "utf-8"),
+  );
+
+  // Handle exports field if present
+  if (workspacePkgJson.exports) {
+    const subPathWithoutExt = subPath
+      ? subPath.replace(/\.(js|ts|ui|uix)$/, "")
+      : "";
+    let exportKey = subPathWithoutExt ? `./${subPathWithoutExt}` : ".";
+
+    // Try to find matching export
+    if (subPath && !workspacePkgJson.exports[exportKey]) {
+      if (subPathWithoutExt) {
+        const withoutExtKey = `./${subPathWithoutExt}`;
+        if (workspacePkgJson.exports[withoutExtKey]) {
+          exportKey = withoutExtKey;
+        }
+      }
+
+      if (!workspacePkgJson.exports[exportKey]) {
+        const subPathParts = subPathWithoutExt.split("/");
+        if (subPathParts.length > 1) {
+          const dirPath = subPathParts.slice(0, -1).join("/");
+          const dirExportKey = `./${dirPath}`;
+          if (workspacePkgJson.exports[dirExportKey]) {
+            exportKey = dirExportKey;
+          } else {
+            const firstDir = subPathParts[0];
+            const firstDirExportKey = `./${firstDir}`;
+            if (workspacePkgJson.exports[firstDirExportKey]) {
+              exportKey = firstDirExportKey;
+            } else {
+              const lastDir = subPathParts[subPathParts.length - 2];
+              const lastDirExportKey = `./${lastDir}`;
+              if (workspacePkgJson.exports[lastDirExportKey]) {
+                exportKey = lastDirExportKey;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    const exportEntry = workspacePkgJson.exports[exportKey];
+
+    if (exportEntry) {
+      let entryPoint: string;
+      if (typeof exportEntry === "string") {
+        entryPoint = exportEntry;
+      } else if (exportEntry.import) {
+        entryPoint = exportEntry.import;
+      } else if (exportEntry.default) {
+        entryPoint = exportEntry.default;
+      } else {
+        entryPoint = exportEntry;
+      }
+
+      const normalizedEntryPoint = entryPoint.startsWith("./")
+        ? entryPoint.slice(2)
+        : entryPoint;
+      const fullPath = path.join(workspacePkg, normalizedEntryPoint);
+
+      // Dev: prefer src over dist for workspace packages (unbuilt or dev mode)
+      const normalizedFull = fullPath.replace(/\\/g, "/");
+      if (normalizedFull.includes("/dist/")) {
+        const srcPath = fullPath.replace(/[/\\]dist[/\\]/, path.sep + "src" + path.sep).replace(/\.js$/i, ".ts");
+        if (await context.fileExists(srcPath)) {
+          return await toUrl(srcPath, context);
+        }
+      }
+
+      if (await context.fileExists(fullPath)) {
+        return await toUrl(fullPath, context);
+      }
+
+      // Try extensions
+      for (const ext of [".ui", ".uix", ".ts", ".js"]) {
+        const withExt = fullPath.replace(/\.(js|ts|ui|uix)$/, ext);
+        if (await context.fileExists(withExt)) {
+          return await toUrl(withExt, context);
+        }
+      }
+    }
+  }
+
+  // Fallback to old logic
+  let entryPoint: string;
+  if (subPath) {
+    entryPoint = subPath;
+  } else {
+    entryPoint =
+      workspacePkgJson.module || workspacePkgJson.main || "index.js";
+  }
+
+  const fullPath = path.join(workspacePkg, entryPoint);
+
+  // Dev: prefer src over dist for workspace packages
+  const normalizedFull = fullPath.replace(/\\/g, "/");
+  if (normalizedFull.includes("/dist/")) {
+    const srcPath = fullPath.replace(/[/\\]dist[/\\]/, path.sep + "src" + path.sep).replace(/\.js$/i, ".ts");
+    if (await context.fileExists(srcPath)) {
+      return await toUrl(srcPath, context);
+    }
+  }
+
+  if (await context.fileExists(fullPath)) {
+    return await toUrl(fullPath, context);
+  }
+
+  // Try extensions
+  const ext = path.extname(entryPoint);
+  if (ext) {
+    const basePath = fullPath.slice(0, -ext.length);
+    for (const tryExt of [".js", ".mjs", ".ts", ".ui", ".uix"]) {
+      if (await context.fileExists(basePath + tryExt)) {
+        return await toUrl(basePath + tryExt, context);
+      }
+    }
+  } else {
+    for (const tryExt of [".js", ".mjs", ".ts", ".ui", ".uix"]) {
+      if (await context.fileExists(fullPath + tryExt)) {
+        return await toUrl(fullPath + tryExt, context);
+      }
+    }
+  }
+
+  // Try index files
+  for (const tryExt of [".js", ".ts", ".ui", ".uix"]) {
+    const indexFile = path.join(fullPath, `index${tryExt}`);
+    if (await context.fileExists(indexFile)) {
+      return await toUrl(indexFile, context);
+    }
+  }
+
+  // Try src/ directory
+  const srcDir = path.join(workspacePkg, "src");
+  for (const ext of [".ts", ".ui", ".uix", ".js"]) {
+    const srcIndex = path.join(srcDir, `index${ext}`);
+    if (await context.fileExists(srcIndex)) {
+      console.log(
+        `[SWITE] Found unbuilt workspace package ${pkgName} at ${srcIndex}`,
+      );
+      return await toUrl(srcIndex, context);
+    }
+  }
+
+  console.warn(
+    `[SWITE] Entry point not found for ${pkgName} at ${fullPath}, using fallback`,
+  );
+  return shouldUseCdnFallback(pkgName)
+    ? `https://cdn.jsdelivr.net/npm/${specifier}/+esm`
+    : `/node_modules/${specifier}`;
+}

package/src/resolution/cdn/cdn-fallback.ts

@@ -0,0 +1,37 @@
+/**
+ * CDN fallback policy.
+ *
+ * Swite can fall back to jsDelivr (+esm) for packages it can't resolve locally.
+ * This must be safe and project-agnostic:
+ * - Unscoped packages (e.g. "react") are usually public on npm; allow by default.
+ * - Scoped packages (e.g. "@scope/pkg") may be private; do NOT CDN-fallback by default.
+ *
+ * Opt-in:
+ * - Set `SWITE_CDN_FALLBACK_SCOPES` to a comma-separated list of scopes to allow,
+ *   e.g. "@types,@tanstack".
+ */
+
+function getScope(specifierOrPkg: string): string | null {
+  if (!specifierOrPkg.startsWith("@")) return null;
+  const firstSlash = specifierOrPkg.indexOf("/");
+  if (firstSlash === -1) return null;
+  return specifierOrPkg.slice(0, firstSlash); // "@scope"
+}
+
+function parseAllowList(): Set<string> {
+  const raw = process.env.SWITE_CDN_FALLBACK_SCOPES || "";
+  const scopes = raw
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .map((s) => (s.startsWith("@") ? s : `@${s}`));
+  return new Set(scopes);
+}
+
+export function shouldUseCdnFallback(specifierOrPkg: string): boolean {
+  const scope = getScope(specifierOrPkg);
+  if (!scope) return true; // unscoped: allow by default
+  const allow = parseAllowList();
+  return allow.has(scope);
+}
+

package/src/resolution/path/file-path-resolver.ts

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { findWorkspaceRoot } from "../../kernel/workspace.js";
+import { findSwissLibMonorepo } from "../../kernel/package-finder.js";
+
+export interface PathResolverContext {
+  root: string;
+  workspaceRoot: string | null;
+}
+
+/**
+ * Resolve file path from URL, handling SWISS packages, workspace packages, and app files
+ */
+export async function resolveFilePath(
+  url: string,
+  root: string,
+  workspaceRoot: string | null = null,
+): Promise<string> {
+  // /node_modules/ URLs: walk up from app root until we find the package.
+  // pnpm may place deps at the app root, one level up (workspace pkg), or at
+  // the monorepo root depending on hoisting config and pnpm version.
+  if (url.startsWith("/node_modules/")) {
+    const urlPath = url.startsWith("/") ? url.slice(1) : url;
+
+    // Walk up the directory tree from root, trying node_modules at each level
+    let current = path.resolve(root);
+    const visited = new Set<string>();
+    for (let i = 0; i < 8; i++) {
+      const candidate = path.join(current, urlPath);
+      if (!visited.has(candidate)) {
+        visited.add(candidate);
+        try {
+          const resolved = await fs.realpath(candidate);
+          await fs.access(resolved);
+          return resolved;
+        } catch {
+          // try parent level
+        }
+      }
+      const parent = path.dirname(current);
+      if (parent === current) break; // filesystem root
+      current = parent;
+    }
+
+    // Explicit workspace root (covers hoisted-to-root installs)
+    const wsRoot = workspaceRoot || (await findWorkspaceRoot(root));
+    if (wsRoot) {
+      const wsPath = path.join(wsRoot, urlPath);
+      if (!visited.has(wsPath)) {
+        try {
+          const resolved = await fs.realpath(wsPath);
+          await fs.access(resolved);
+          return resolved;
+        } catch {
+          // not found there either
+        }
+      }
+    }
+
+    return path.join(path.resolve(root), urlPath); // fallback; handler will 404
+  }
+
+  // /swiss-packages/ URLs point to files in the co-located framework monorepo's packages/ dir
+  if (url.startsWith("/swiss-packages/")) {
+    const relativePath = url.replace(/^\/swiss-packages\//, "");
+    const monorepo = await findSwissLibMonorepo(root);
+    if (monorepo) {
+      const fullPath = path.join(monorepo, "packages", relativePath);
+      try {
+        await fs.access(fullPath);
+        return fullPath;
+      } catch {
+        return fullPath; // Return anyway; handler will 404 if missing
+      }
+    }
+    // No co-located monorepo found — return a path that will 404 cleanly
+    console.warn(`[file-path-resolver] No framework monorepo found for /swiss-packages/${relativePath}`);
+    return path.join(root, "node_modules", relativePath);
+  }
+
+  // Workspace-level directories: always resolve from workspace root
+  // Updated: lib/ now contains all packages (moved from packages/)
+  if (
+    url.startsWith("/lib/") ||
+    url.startsWith("/libraries/") ||
+    url.startsWith("/packages/") ||
+    url.startsWith("/modules/")
+  ) {
+    let wsRoot = workspaceRoot;
+    if (!wsRoot) {
+      wsRoot = await findWorkspaceRoot(root);
+      console.log(`[file-path-resolver] Detected workspace root: ${wsRoot} (from app root: ${root})`);
+    }
+    
+    // Normalize URL: path.join with leading slash is wrong on Windows (treats as drive root)
+    const urlPath = url.startsWith("/") ? url.slice(1) : url;
+
+    // CRITICAL: For /lib/ paths, we MUST find the SWS root (which has lib/ directory)
+    // Start from app root and walk up until we find a directory with both pnpm-workspace.yaml AND lib/
+    if (url.startsWith("/lib/")) {
+      let current = root;
+      for (let i = 0; i < 10; i++) {
+        const workspaceFile = path.join(current, "pnpm-workspace.yaml");
+        const libDir = path.join(current, "lib");
+        try {
+          await fs.access(workspaceFile);
+          await fs.access(libDir);
+          // Found SWS root!
+          const resolved = path.join(current, urlPath);
+          console.log(`[file-path-resolver] Found SWS root with lib/: ${current}`);
+          console.log(`[file-path-resolver] Resolving ${url} from SWS root: ${current} -> ${resolved}`);
+          return resolved;
+        } catch {
+          // Continue searching up
+        }
+        const parent = path.dirname(current);
+        if (parent === current) break;
+        current = parent;
+      }
+    }
+    
+    // For other paths, use detected workspace root
+    if (wsRoot) {
+      let resolved = path.join(wsRoot, urlPath);
+      // Dev fallback: if URL is /packages/.../dist/... and file doesn't exist, try src/ (unbuilt workspace packages)
+      if (
+        (url.startsWith("/packages/") || url.startsWith("/lib/")) &&
+        url.includes("/dist/")
+      ) {
+        try {
+          await fs.access(resolved);
+        } catch {
+          const srcUrl = urlPath.replace("/dist/", "/src/").replace(/\.js$/, ".ts");
+          const srcResolved = path.join(wsRoot, srcUrl);
+          try {
+            await fs.access(srcResolved);
+            console.log(`[file-path-resolver] dist not found, serving src: ${resolved} -> ${srcResolved}`);
+            return srcResolved;
+          } catch {
+            // Keep original resolved; handler will 404
+          }
+        }
+      }
+      console.log(`[file-path-resolver] Resolving ${url} from workspace root: ${wsRoot} -> ${resolved}`);
+      return resolved;
+    } else {
+      console.warn(`[file-path-resolver] No workspace root found, using app root: ${root}`);
+      return path.join(root, urlPath);
+    }
+  }
+
+  // For app files, check if URL already includes the app path
+  const wsRoot = workspaceRoot || (await findWorkspaceRoot(root));
+  if (wsRoot) {
+    const appRelativeToWorkspace = path
+      .relative(wsRoot, root)
+      .replace(/\\/g, "/");
+    if (url.startsWith(`/${appRelativeToWorkspace}/`)) {
+      // URL already includes app path, use workspace root
+      return path.join(wsRoot, url);
+    } else if (
+      url.startsWith("/src/") ||
+      url.startsWith("/public/") ||
+      url.startsWith("/assets/")
+    ) {
+      // App-specific paths (src/, public/, assets/) - resolve from app root
+      return path.join(root, url);
+    } else if (url.startsWith("/")) {
+      // Other absolute URLs, try workspace root first, then app root
+      const workspacePath = path.join(wsRoot, url);
+      try {
+        await fs.access(workspacePath);
+        return workspacePath;
+      } catch {
+        return path.join(root, url);
+      }
+    } else {
+      // Relative to app root
+      return path.join(root, url);
+    }
+  } else {
+    return path.join(root, url);
+  }
+}

package/src/resolution/path/path-fixup.ts

@@ -0,0 +1,19 @@
+/**
+ * Centralised /swiss-lib/ → /swiss-packages/ path fixup.
+ *
+ * Root cause: the UiCompiler emits absolute `/swiss-lib/` paths in some code
+ * paths (compiler was written against an older directory structure). Until the
+ * compiler is fixed at source this single function is the authoritative fixup.
+ * Apply it once per compilation, before passing code to the import rewriter.
+ *
+ * All seven previous fixup locations across ui-handler, uix-handler, and
+ * import-rewriter have been removed in favour of this call.
+ */
+export function fixSwissLibPaths(code: string): string {
+  if (!code.includes('/swiss-lib/')) return code;
+  // More-specific pattern first so `/swiss-lib/packages/` doesn't leave a
+  // dangling `/swiss-packages/packages/` if the replacement ran twice.
+  return code
+    .replace(/\/swiss-lib\/packages\//g, '/swiss-packages/')
+    .replace(/\/swiss-lib\//g, '/swiss-packages/');
+}