@swissjs/swite 0.3.0

package/src/resolution/url-resolver.ts

@@ -0,0 +1,231 @@
+/*
+ * URL Resolver - Converts file paths to URLs
+ * Extracted from resolver.ts for modularity
+ */
+
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { findSwissLibMonorepo } from "../kernel/package-finder.js";
+import { lookupInSymlinkRegistry } from "./symlink-registry.js";
+
+export interface UrlResolverContext {
+  root: string;
+  getWorkspaceRoot: () => Promise<string | null>;
+  fileExists: (filePath: string) => Promise<boolean>;
+}
+
+export type WorkspacePackageResolverContext = UrlResolverContext;
+
+function normalizeResult(result: string): string {
+  return result.replace(/\\/g, '/');
+}
+
+/**
+ * Convert file path to URL for browser
+ */
+export async function toUrl(
+  filePath: string,
+  context: UrlResolverContext
+): Promise<string> {
+  const normalized = filePath.replace(/\\/g, "/");
+
+  // CG-03: Check symlink registry FIRST.
+  // Absolute filesystem paths (both realpath-resolved and unresolved symlinks)
+  // must be mapped back to browser URLs before the startsWith("/") early-return
+  // fires and mangled by normalizeResult().
+  // The registry maps realpath → /node_modules/<pkg> browser URL prefix.
+  if (path.isAbsolute(filePath)) {
+    // Direct lookup (path is already a realpath, e.g. from fs.realpath() in ts-handler)
+    let registryUrl = lookupInSymlinkRegistry(normalized);
+
+    // Fallback: resolve symlinks and retry (path may still contain symlink segments,
+    // e.g. app/node_modules/@alpine/core/... where app/node_modules is itself a symlink)
+    if (!registryUrl) {
+      try {
+        const realPath = (await fs.realpath(filePath)).replace(/\\/g, "/");
+        if (realPath !== normalized) {
+          registryUrl = lookupInSymlinkRegistry(realPath);
+        }
+      } catch {
+        // file may not exist yet; ignore
+      }
+    }
+
+    if (registryUrl) {
+      console.log(
+        `[SWITE] toUrl: symlink registry hit: ${filePath} → ${registryUrl}`
+      );
+      return registryUrl;
+    }
+
+    // If the absolute filesystem path contains /node_modules/, convert it to a
+    // browser-relative URL (/node_modules/...) before the startsWith("/") early
+    // return below swallows it as an already-resolved URL.
+    if (normalized.toLowerCase().includes("/node_modules/")) {
+      const nodeModulesIndex = normalized.toLowerCase().indexOf("/node_modules/");
+      const afterNodeModules = normalized.slice(nodeModulesIndex + "/node_modules/".length);
+      const url = "/node_modules/" + afterNodeModules;
+      console.log(`[SWITE] toUrl: abs→node_modules URL: ${filePath} → ${url}`);
+      return normalizeResult(url);
+    }
+
+    // Convert absolute workspace/app paths to browser-relative URLs before the
+    // startsWith("/") early-return below treats them as already-resolved URLs.
+    // e.g. /app/modules/pos/src/index.ui → /modules/pos/src/index.ui
+    const workspaceRootForAbs = await context.getWorkspaceRoot();
+    const normalizedLower = normalized.toLowerCase();
+    if (workspaceRootForAbs) {
+      const wsRoot = path.resolve(workspaceRootForAbs).replace(/\\/g, "/");
+      if (normalizedLower.startsWith(wsRoot.toLowerCase() + "/") || normalizedLower === wsRoot.toLowerCase()) {
+        const relative = normalized.slice(wsRoot.length);
+        const url = relative.startsWith("/") ? relative : "/" + relative;
+        console.log(`[SWITE] toUrl: abs→workspace URL: ${filePath} → ${url}`);
+        return normalizeResult(url);
+      }
+    }
+    const appRoot = path.resolve(context.root).replace(/\\/g, "/");
+    if (normalizedLower.startsWith(appRoot.toLowerCase() + "/") || normalizedLower === appRoot.toLowerCase()) {
+      const relative = normalized.slice(appRoot.length);
+      const url = relative.startsWith("/") ? relative : "/" + relative;
+      console.log(`[SWITE] toUrl: abs→approot URL: ${filePath} → ${url}`);
+      return normalizeResult(url);
+    }
+  }
+
+  // If path is already a URL (starts with / or http), prefer src over dist for workspace packages
+  if (normalized.startsWith("/") || normalized.startsWith("http")) {
+    // Only prefer src over dist for workspace packages — never for node_modules
+    if (normalized.includes("/dist/") && !normalized.includes("/src/") && !normalized.includes("/node_modules/")) {
+      const srcPath = normalized.replace("/dist/", "/src/").replace(/\.js$/, ".ts");
+      const { resolveFilePath } = await import("../path/file-path-resolver.js");
+      const workspaceRoot = await context.getWorkspaceRoot();
+      const srcFilePath = await resolveFilePath(srcPath, context.root, workspaceRoot);
+      if (await context.fileExists(srcFilePath)) {
+        return normalizeResult(srcPath);
+      }
+    }
+    return normalizeResult(normalized);
+  }
+
+  // If path is absolute, convert to a browser-relative URL
+  if (path.isAbsolute(filePath)) {
+    const workspaceRoot = await context.getWorkspaceRoot();
+
+    // Check if the file lives in a co-located framework monorepo's packages/ directory.
+    // Serve those files under /swiss-packages/ so the browser can request them distinctly
+    // from the app's own files. Works for any framework at any directory name.
+    const monorepo = await findSwissLibMonorepo(context.root);
+    if (monorepo) {
+      const packagesPath = path.join(monorepo, "packages");
+
+      let resolvedPackages: string;
+      let resolvedFilePath: string;
+      try {
+        resolvedPackages = await fs.realpath(packagesPath);
+        resolvedFilePath = await fs.realpath(filePath);
+      } catch {
+        resolvedPackages = path.resolve(packagesPath);
+        resolvedFilePath = path.resolve(filePath);
+      }
+
+      const normalizedPackages = resolvedPackages.replace(/\\/g, "/").toLowerCase();
+      const normalizedResolved = resolvedFilePath.replace(/\\/g, "/").toLowerCase();
+
+      if (normalizedResolved.startsWith(normalizedPackages)) {
+        const origPackages = resolvedPackages.replace(/\\/g, "/");
+        const origFile = resolvedFilePath.replace(/\\/g, "/");
+        const relative = origFile.slice(origPackages.length);
+        const url = "/swiss-packages" + (relative.startsWith("/") ? relative : "/" + relative);
+
+        if (url.includes("/dist/") && !url.includes("/src/")) {
+          const srcUrl = url.replace("/dist/", "/src/").replace(/\.js$/, ".ts");
+          const srcRelative = srcUrl.replace("/swiss-packages/", "");
+          const srcFilePath = path.join(packagesPath, srcRelative);
+          if (await context.fileExists(srcFilePath)) {
+            return normalizeResult(srcUrl);
+          }
+        }
+
+        return normalizeResult(url);
+      }
+    }
+
+    // node_modules absolute path → browser /node_modules/... URL
+    const origFilePathNormalized = path.resolve(filePath).replace(/\\/g, "/");
+    if (origFilePathNormalized.toLowerCase().includes("/node_modules/")) {
+      const nodeModulesIndex = origFilePathNormalized.toLowerCase().indexOf("/node_modules/");
+      const afterNodeModules = origFilePathNormalized.slice(nodeModulesIndex + "/node_modules/".length);
+      return normalizeResult("/node_modules/" + afterNodeModules);
+    }
+
+    const normalizedFilePath = path.resolve(filePath).replace(/\\/g, "/").toLowerCase();
+
+    // Try relative to app root first
+    const normalizedRoot = path.resolve(context.root).replace(/\\/g, "/").toLowerCase();
+    if (normalizedFilePath.startsWith(normalizedRoot)) {
+      const origRoot = path.resolve(context.root).replace(/\\/g, "/");
+      const origFilePath = path.resolve(filePath).replace(/\\/g, "/");
+      const relative = origFilePath.slice(origRoot.length);
+      return normalizeResult(relative.startsWith("/") ? relative : "/" + relative);
+    }
+
+    // Try workspace root
+    if (workspaceRoot) {
+      const normalizedWorkspaceRoot = path.resolve(workspaceRoot).replace(/\\/g, "/").toLowerCase();
+
+      if (normalizedFilePath.startsWith(normalizedWorkspaceRoot)) {
+        const origWorkspaceRoot = path.resolve(workspaceRoot).replace(/\\/g, "/");
+        const origFilePath = path.resolve(filePath).replace(/\\/g, "/");
+        const relative = origFilePath.slice(origWorkspaceRoot.length);
+        let url = relative.startsWith("/") ? relative : "/" + relative;
+
+        // Prefer src over dist for workspace packages in dev
+        if (url.includes("/packages/") && url.includes("/dist/") && !(await context.fileExists(filePath))) {
+          const srcPath = filePath
+            .replace(/[/\\]dist[/\\]/, path.sep + "src" + path.sep)
+            .replace(/\.js$/i, ".ts");
+          if (await context.fileExists(srcPath)) {
+            const srcRelative = path.relative(workspaceRoot, srcPath).replace(/\\/g, "/");
+            url = "/" + srcRelative;
+          }
+        }
+
+        return normalizeResult(url);
+      }
+    }
+
+    // Fallback
+    const baseRoot = workspaceRoot || context.root;
+    const rawRelative = path.relative(baseRoot, filePath);
+    // CG-03: guard against absolute result from path.relative() on cross-drive/WSL paths
+    let url: string;
+    if (path.isAbsolute(rawRelative) || rawRelative.startsWith("..")) {
+      const normalizedBase = path.resolve(baseRoot).replace(/\\/g, "/");
+      const normalizedFile = path.resolve(filePath).replace(/\\/g, "/");
+      const stripped = normalizedFile.startsWith(normalizedBase)
+        ? normalizedFile.slice(normalizedBase.length)
+        : "/" + normalizedFile;
+      url = stripped.startsWith("/") ? stripped : "/" + stripped;
+    } else {
+      url = "/" + rawRelative.replace(/\\/g, "/");
+    }
+    console.warn(`[SWITE] toUrl fallback: ${filePath} -> ${url}`);
+    return normalizeResult(url);
+  }
+
+  // Default: make relative to root
+  const rawRelative = path.relative(context.root, filePath);
+  // CG-03: guard against absolute result from path.relative() on cross-drive/WSL paths.
+  let defaultUrl: string;
+  if (path.isAbsolute(rawRelative) || rawRelative.startsWith("..")) {
+    const normalizedRoot = path.resolve(context.root).replace(/\\/g, "/");
+    const normalizedFile = path.resolve(filePath).replace(/\\/g, "/");
+    const stripped = normalizedFile.startsWith(normalizedRoot)
+      ? normalizedFile.slice(normalizedRoot.length)
+      : "/" + normalizedFile;
+    defaultUrl = stripped.startsWith("/") ? stripped : "/" + stripped;
+  } else {
+    defaultUrl = "/" + rawRelative.replace(/\\/g, "/");
+  }
+  return normalizeResult(defaultUrl);
+}

package/src/resolution/workspace-package-resolver.ts

@@ -0,0 +1,94 @@
+/*
+ * Workspace Package Resolver - Finds packages in workspace
+ * Uses dynamic package registry instead of hardcoded paths
+ */
+
+import path from "node:path";
+import { findSwissLibMonorepo } from "../kernel/package-finder.js";
+import { getPackageRegistry } from "../kernel/package-registry.js";
+
+export interface WorkspacePackageResolverContext {
+  root: string;
+  getWorkspaceRoot: () => Promise<string | null>;
+  fileExists: (filePath: string) => Promise<boolean>;
+}
+
+/**
+ * Resolve workspace package location
+ */
+export async function resolveWorkspacePackage(
+  pkgName: string,
+  context: WorkspacePackageResolverContext
+): Promise<string | null> {
+  // Build the ordered list of roots to scan for workspace packages.
+  // Works for any package name/scope — no hardcoded scope guards.
+  const workspaceRoots: string[] = [];
+
+  let workspaceRoot = await context.getWorkspaceRoot();
+  if (workspaceRoot) {
+    workspaceRoots.push(workspaceRoot);
+  } else {
+    // Walk up from app root looking for common workspace markers
+    for (const candidate of [
+      path.join(context.root, ".."),
+      path.join(context.root, "..", ".."),
+    ]) {
+      const normalized = path.resolve(candidate);
+      if (
+        (await context.fileExists(path.join(normalized, "pnpm-workspace.yaml"))) ||
+        (await context.fileExists(path.join(normalized, "modules"))) ||
+        (await context.fileExists(path.join(normalized, "libraries")))
+      ) {
+        workspaceRoot = normalized;
+        workspaceRoots.push(normalized);
+        break;
+      }
+    }
+    if (!workspaceRoots.length) {
+      workspaceRoots.push(path.join(context.root, "..", ".."));
+    }
+  }
+
+  // Also include any co-located framework monorepo (any workspace with packages/)
+  try {
+    const monorepo = await findSwissLibMonorepo(context.root);
+    if (monorepo && !workspaceRoots.includes(monorepo)) {
+      workspaceRoots.unshift(monorepo);
+    }
+    if (monorepo) {
+      const packagesDir = path.join(monorepo, "packages");
+      if (await context.fileExists(packagesDir) && !workspaceRoots.includes(packagesDir)) {
+        workspaceRoots.unshift(packagesDir);
+      }
+    }
+  } catch {
+    // monorepo not found — continue without it
+  }
+
+  const registry = getPackageRegistry();
+  const primaryRoot = workspaceRoots[0] ?? context.root;
+  const additionalRoots = workspaceRoots.slice(1);
+
+  if (!registry.getPackageCount() && primaryRoot) {
+    try {
+      await registry.scanWorkspace(primaryRoot, additionalRoots);
+    } catch (error: any) {
+      console.error(`[SWITE] Error scanning package registry:`, error.message);
+    }
+  }
+
+  let packageInfo = registry.findPackage(pkgName);
+  if (packageInfo) {
+    return packageInfo.path;
+  }
+
+  // Rescan in case the package was added after the initial scan
+  await registry.rescan();
+  packageInfo = registry.findPackage(pkgName);
+  if (packageInfo) {
+    return packageInfo.path;
+  }
+
+  console.log(`[SWITE] Package ${pkgName} not found in workspace (scanned ${registry.getPackageCount()} packages)`);
+  return null;
+}

package/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "extends": "../swiss-lib/tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "module": "Node16",
+    "moduleResolution": "node16",
+    "skipLibCheck": true,
+    "noEmitOnError": false,
+    "downlevelIteration": true,
+    "target": "ES2020",
+    "composite": true,
+    "tsBuildInfoFile": "./dist/.tsbuildinfo",
+    "noUnusedLocals": false,
+    "noUnusedParameters": false
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ],
+  "references": [
+    {
+      "path": "../swiss-lib/runtime"
+    },
+    {
+      "path": "../swiss-lib/compiler"
+    },
+    {
+      "path": "../swiss-lib/plugins/file-router"
+    }
+  ]
+}