@swissjs/swite 0.3.0

package/dist/resolver.js

@@ -0,0 +1,191 @@
+/*
+ * Module Resolver for SWITE
+ */
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import chalk from "chalk";
+import { findSwissLibMonorepo } from "./utils/package-finder.js";
+import { toUrl } from "./resolver/url-resolver.js";
+import { resolveWorkspacePackage } from "./resolver/workspace-package-resolver.js";
+import { resolveBareImport } from "./resolver/bare-import-resolver.js";
+export class ModuleResolver {
+    constructor(root) {
+        this.root = root;
+        this.workspaceRoot = null;
+        this.importMap = null;
+    }
+    /**
+     * Set pre-resolved import map (from build-time generation)
+     */
+    setImportMap(importMap) {
+        this.importMap = importMap;
+        if (importMap) {
+            console.log(chalk.green(`[Resolver] Loaded import map with ${Object.keys(importMap).length - 2} entries`));
+        }
+    }
+    async getWorkspaceRoot() {
+        if (this.workspaceRoot)
+            return this.workspaceRoot;
+        const findWorkspaceRoot = async (startDir) => {
+            let current = startDir;
+            for (let i = 0; i < 5; i++) {
+                const workspaceFile = path.join(current, "pnpm-workspace.yaml");
+                const packageJson = path.join(current, "package.json");
+                if ((await this.fileExists(workspaceFile)) ||
+                    ((await this.fileExists(packageJson)) &&
+                        JSON.parse(await fs.readFile(packageJson, "utf-8")).workspaces)) {
+                    return current;
+                }
+                const parent = path.dirname(current);
+                if (parent === current)
+                    break;
+                current = parent;
+            }
+            return null;
+        };
+        this.workspaceRoot = await findWorkspaceRoot(this.root);
+        return this.workspaceRoot;
+    }
+    async resolve(specifier, importer) {
+        console.log(`[SWITE] resolve CALLED: specifier: ${specifier}, importer: ${importer}`);
+        // Check import map first (fast path)
+        if (this.importMap && !specifier.startsWith(".") && !specifier.startsWith("/")) {
+            const mapped = this.importMap.imports[specifier];
+            if (mapped) {
+                console.log(chalk.green(`[Resolver] ✅ Import map hit: ${specifier} -> ${mapped}`));
+                return mapped;
+            }
+        }
+        // CRITICAL: Skip variable references - they should never be resolved as modules
+        // Variables like def.componentUrl, someVar, etc. should be left as-is
+        // Only resolve actual module specifiers (bare imports starting with @ or valid package names)
+        if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+            // Check if this looks like a variable reference (property access, camelCase without @, etc.)
+            // Valid module specifiers: @scope/name, package-name, ./relative, /absolute
+            // Variable references: def.componentUrl, someVar, obj.prop, etc.
+            if (specifier.includes(".") && !specifier.startsWith("@")) {
+                // Property access pattern (def.componentUrl) - this is a variable, not a module
+                console.warn(`[SWITE] resolve: Skipping variable reference: ${specifier}`);
+                return specifier; // Return as-is, don't try to resolve
+            }
+            // Additional check: if it doesn't look like a valid package name, it might be a variable
+            // Valid package names: start with letter or @, contain only alphanumeric, -, _, /
+            // Also allow file extensions at the end: .js, .ts, .ui, .uix, etc.
+            if (!/^[@a-zA-Z][a-zA-Z0-9_/@-]*(\.(js|ts|ui|uix|mjs|cjs|jsx|tsx))?$/.test(specifier)) {
+                console.warn(`[SWITE] resolve: Invalid module specifier (likely variable): ${specifier}`);
+                return specifier; // Return as-is
+            }
+            const context = {
+                root: this.root,
+                getWorkspaceRoot: () => this.getWorkspaceRoot(),
+                fileExists: (p) => this.fileExists(p),
+                resolveWorkspacePackage: (pkgName) => this.resolveWorkspacePackage(pkgName),
+            };
+            const result = await resolveBareImport(specifier, context);
+            console.log(`[SWITE] resolve RESULT: ${specifier} -> ${result}`);
+            return result;
+        }
+        // Handle absolute paths (already URLs)
+        if (specifier.startsWith("/")) {
+            return specifier;
+        }
+        // Handle relative imports
+        // importer might be a URL path (/src/modules/index.ui) or file path
+        // Convert URL to file path if needed
+        let importerPath = importer;
+        if (importer.startsWith("/")) {
+            // URL path - convert to file path
+            // Prioritize app root for app files (src/, public/, assets/)
+            if (importer.startsWith("/src/") ||
+                importer.startsWith("/public/") ||
+                importer.startsWith("/assets/")) {
+                // App-specific paths - resolve from app root
+                importerPath = path.join(this.root, importer);
+            }
+            else {
+                // Other paths - try workspace root first (for libraries/, packages/)
+                const workspaceRoot = await this.getWorkspaceRoot();
+                if (workspaceRoot) {
+                    const workspacePath = path.join(workspaceRoot, importer);
+                    if (await this.fileExists(workspacePath)) {
+                        importerPath = workspacePath;
+                    }
+                    else {
+                        // Fallback to app root
+                        importerPath = path.join(this.root, importer);
+                    }
+                }
+                else {
+                    // No workspace root, use app root
+                    importerPath = path.join(this.root, importer);
+                }
+            }
+        }
+        const importerDir = path.dirname(importerPath);
+        // If specifier already has an extension (.ui, .uix, .ts, .js, etc.), try it first
+        // This preserves .ui/.uix extensions for SWISS files
+        const hasExtension = /\.(ui|uix|ts|tsx|js|jsx|mjs)$/.test(specifier);
+        if (hasExtension) {
+            // Specifier has extension, resolve it directly
+            const resolved = path.resolve(importerDir, specifier);
+            console.log(`[SWITE] resolve relative (hasExt): ${specifier}, importerDir: ${importerDir}, resolved: ${resolved}, exists: ${await this.fileExists(resolved)}`);
+            if (await this.fileExists(resolved)) {
+                const url = await this.toUrl(resolved);
+                console.log(`[SWITE] resolve relative: ${specifier} -> ${resolved} -> ${url}`);
+                return url;
+            }
+        }
+        // If no extension or file not found, try adding extensions
+        // Strip any existing extension from specifier (but preserve .ui/.uix if present)
+        const specifierWithoutExt = specifier.replace(/\.(js|ts|jsx|tsx|mjs)$/, "");
+        const resolved = path.resolve(importerDir, specifierWithoutExt);
+        console.log(`[SWITE] resolve relative (trying extensions): specifierWithoutExt: ${specifierWithoutExt}, resolved: ${resolved}`);
+        // Try adding extensions (prioritize .ui and .uix for SWISS files)
+        const extensions = [".ui", ".uix", ".ts", ".tsx", ".js", ".jsx", ".mjs"];
+        for (const ext of extensions) {
+            const withExt = resolved + ext;
+            const exists = await this.fileExists(withExt);
+            console.log(`[SWITE] trying extension ${ext}: ${withExt}, exists: ${exists}`);
+            if (exists) {
+                const url = await this.toUrl(withExt);
+                console.log(`[SWITE] found with ${ext}: ${url}`);
+                return url;
+            }
+        }
+        // Try index files
+        for (const ext of extensions) {
+            const indexFile = path.join(resolved, `index${ext}`);
+            if (await this.fileExists(indexFile)) {
+                return await this.toUrl(indexFile);
+            }
+        }
+        // Return as-is if nothing found
+        return await this.toUrl(resolved);
+    }
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async resolveWorkspacePackage(pkgName) {
+        const context = {
+            root: this.root,
+            getWorkspaceRoot: () => this.getWorkspaceRoot(),
+            fileExists: (p) => this.fileExists(p),
+        };
+        return resolveWorkspacePackage(pkgName, context);
+    }
+    // OLD IMPLEMENTATION REMOVED - now uses resolver/workspace-package-resolver.ts
+    async toUrl(filePath) {
+        const context = {
+            root: this.root,
+            getWorkspaceRoot: () => this.getWorkspaceRoot(),
+            fileExists: (p) => this.fileExists(p),
+        };
+        return toUrl(filePath, context);
+    }
+}

package/dist/router/file-router.d.ts

@@ -0,0 +1,19 @@
+import type { RouteDefinition } from "@kibologic/core";
+import { RouteScanner } from "@kibologic/plugin-file-router/core";
+import { createFileWatcher } from "@kibologic/plugin-file-router/dev";
+import { HMREngine } from "../hmr.js";
+export interface FileRouterConfig {
+    root: string;
+    hmr: HMREngine;
+}
+export interface FileRouterResult {
+    routeScanner: RouteScanner | null;
+    routeWatcher: Awaited<ReturnType<typeof createFileWatcher>> | null;
+    routes: RouteDefinition[];
+}
+/**
+ * Setup file-based routing
+ * Scans for route files in pages/ directories and watches for changes
+ */
+export declare function setupFileRouter(config: FileRouterConfig): Promise<FileRouterResult>;
+//# sourceMappingURL=file-router.d.ts.map

package/dist/router/file-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-router.d.ts","sourceRoot":"","sources":["../../src/router/file-router.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAGtC,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,SAAS,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAClC,YAAY,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,GAAG,IAAI,CAAC;IACnE,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAmI3B"}

package/dist/router/file-router.js

@@ -0,0 +1,114 @@
+/*
+ * 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 chalk from "chalk";
+import { RouteScanner } from "@kibologic/plugin-file-router/core";
+import { createFileWatcher } from "@kibologic/plugin-file-router/dev";
+import { HMREngine } from "../hmr.js";
+import { findWorkspaceRoot } from "../utils/workspace.js";
+/**
+ * Setup file-based routing
+ * Scans for route files in pages/ directories and watches for changes
+ */
+export async function setupFileRouter(config) {
+    const result = {
+        routeScanner: null,
+        routeWatcher: null,
+        routes: [],
+    };
+    try {
+        const workspaceRoot = await findWorkspaceRoot(config.root);
+        const appRoot = config.root;
+        // Initialize route scanner
+        result.routeScanner = new RouteScanner({
+            routesDir: "./src/pages",
+            extensions: [".ui", ".uix"],
+            layouts: true,
+            lazyLoading: true,
+        });
+        // Scan routes from multiple locations:
+        // 1. App's pages directory (apps/alpine/src/pages)
+        // 2. SKLTN's pages directory (framework/skltn/src/pages) - for reusable auth pages
+        const routesToScan = [];
+        // App pages
+        const appPagesDir = path.join(appRoot, "src", "pages");
+        try {
+            await fs.access(appPagesDir);
+            routesToScan.push(appPagesDir);
+            console.log(chalk.gray(`  📄 Scanning app routes from ${appPagesDir}`));
+        }
+        catch {
+            // pages directory doesn't exist, skip
+        }
+        // SKLTN pages (if workspace root exists)
+        if (workspaceRoot && workspaceRoot !== appRoot) {
+            // Try framework/skltn first (new location), then fallback to lib/skltn (legacy)
+            const skltnPagesDir = path.join(workspaceRoot, "framework", "skltn", "src", "pages");
+            const legacySkltnPagesDir = path.join(workspaceRoot, "lib", "skltn", "src", "pages");
+            try {
+                await fs.access(skltnPagesDir);
+                routesToScan.push(skltnPagesDir);
+                console.log(chalk.gray(`  📄 Scanning SKLTN routes from ${skltnPagesDir}`));
+            }
+            catch {
+                // Try legacy location
+                try {
+                    await fs.access(legacySkltnPagesDir);
+                    routesToScan.push(legacySkltnPagesDir);
+                    console.log(chalk.gray(`  📄 Scanning SKLTN routes from ${legacySkltnPagesDir} (legacy)`));
+                }
+                catch {
+                    // pages directory doesn't exist, skip
+                }
+            }
+        }
+        // Scan all route directories
+        for (const pagesDir of routesToScan) {
+            try {
+                const scannedRoutes = await result.routeScanner.scanRoutes(pagesDir);
+                result.routes.push(...scannedRoutes);
+                console.log(chalk.green(`  ✓ Found ${scannedRoutes.length} routes in ${pagesDir}`));
+            }
+            catch (error) {
+                console.warn(chalk.yellow(`  ⚠ Failed to scan routes from ${pagesDir}:`), error);
+            }
+        }
+        // Setup file watcher for route changes
+        if (routesToScan.length > 0) {
+            // Watch the first pages directory (can be extended to watch multiple)
+            result.routeWatcher = await createFileWatcher({
+                directory: routesToScan[0],
+                extensions: [".ui", ".uix"],
+            });
+            result.routeWatcher.on("change", async (filePath) => {
+                console.log(chalk.yellow(`  🔄 Route file changed: ${filePath}`));
+                // Rescan routes
+                result.routes = [];
+                for (const pagesDir of routesToScan) {
+                    try {
+                        const scannedRoutes = await result.routeScanner.scanRoutes(pagesDir);
+                        result.routes.push(...scannedRoutes);
+                    }
+                    catch (error) {
+                        console.warn(`Failed to rescan routes:`, error);
+                    }
+                }
+                // Notify HMR about route changes
+                config.hmr.notifyChange(filePath);
+            });
+            console.log(chalk.green(`  ✓ File router initialized with ${result.routes.length} routes`));
+        }
+        else {
+            console.log(chalk.gray(`  ⚠ No pages directories found, file router disabled`));
+        }
+    }
+    catch (error) {
+        console.warn(chalk.yellow(`  ⚠ File router setup failed:`), error);
+        // Continue without file router
+    }
+    return result;
+}

package/dist/server.d.ts

@@ -0,0 +1,22 @@
+export interface SwiteConfig {
+    root: string;
+    rootDir?: string;
+    publicDir: string;
+    port: number;
+    host: string;
+    open: boolean;
+    hmrPort?: number;
+}
+export declare class SwiteServer {
+    private app;
+    private resolver;
+    private hmr;
+    private config;
+    private routeScanner;
+    private routeWatcher;
+    private routes;
+    constructor(config?: Partial<SwiteConfig>);
+    private findWorkspaceRoot;
+    start(): Promise<void>;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAmBA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IAKb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,GAAG,CAAY;IACvB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,YAAY,CACb;IACP,OAAO,CAAC,MAAM,CAAyB;gBAE3B,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM;YAe/B,iBAAiB;IAuBzB,KAAK;CAsEZ"}

package/dist/server.js

@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+import { RouteScanner } from "@kibologic/plugin-file-router/core";
+import { createFileWatcher } from "@kibologic/plugin-file-router/dev";
+import express from "express";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { ModuleResolver } from "./resolver.js";
+import { HMREngine } from "./hmr.js";
+import chalk from "chalk";
+import { setupMiddleware } from "./middleware/middleware-setup.js";
+import { buildSymlinkRegistry } from "./resolver/symlink-registry.js";
+import { findSwissLibMonorepo } from "./utils/package-finder.js";
+export class SwiteServer {
+    constructor(config = {}) {
+        this.app = express();
+        this.routeScanner = null;
+        this.routeWatcher = null;
+        this.routes = [];
+        this.config = {
+            root: process.cwd(),
+            publicDir: "public",
+            port: 3000,
+            host: "localhost",
+            open: true,
+            ...config,
+        };
+        this.resolver = new ModuleResolver(this.config.root);
+        this.hmr = new HMREngine(this.config.root, this.config.hmrPort);
+    }
+    // CG-03: find workspace root by walking up from startDir
+    async findWorkspaceRoot(startDir) {
+        if (this.config.rootDir) {
+            return path.resolve(this.config.rootDir);
+        }
+        let current = startDir;
+        for (let i = 0; i < 6; i++) {
+            try {
+                await fs.access(path.join(current, "pnpm-workspace.yaml"));
+                return current;
+            }
+            catch { }
+            try {
+                const pkgJson = JSON.parse(await fs.readFile(path.join(current, "package.json"), "utf-8"));
+                if (pkgJson.workspaces)
+                    return current;
+            }
+            catch { }
+            const parent = path.dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+        }
+        return null;
+    }
+    async start() {
+        const startTime = Date.now();
+        console.log(chalk.cyan("\n⚡ SWITE - SWISS Development Server\n"));
+        console.time("Startup");
+        // CG-03: Build symlink registry before serving any requests.
+        // Maps realpath(node_modules/pkg symlink) → /node_modules/pkg browser URL
+        // so toUrl() can map absolute filesystem paths back to browser URLs.
+        console.time("Symlink Registry");
+        try {
+            const nodeModulesDirs = [
+                path.join(this.config.root, "node_modules"),
+                // Also scan the server package's own node_modules (one level up from the
+                // app root, e.g. apps/server/node_modules) — pnpm places workspace package
+                // symlinks there, not in the app root's node_modules subfolder.
+                path.join(path.dirname(this.config.root), "node_modules"),
+            ];
+            const workspaceRoot = await this.findWorkspaceRoot(this.config.root);
+            if (workspaceRoot) {
+                nodeModulesDirs.push(path.join(workspaceRoot, "node_modules"));
+            }
+            const swissLib = await findSwissLibMonorepo(this.config.root);
+            if (swissLib) {
+                nodeModulesDirs.push(path.join(swissLib, "node_modules"));
+            }
+            await buildSymlinkRegistry(nodeModulesDirs);
+        }
+        catch (err) {
+            console.warn(`[SWITE] Symlink registry build failed: ${err.message}`);
+        }
+        console.timeEnd("Symlink Registry");
+        // Setup middleware
+        console.time("Middleware Setup");
+        const workspaceRoot = await this.findWorkspaceRoot(this.config.root);
+        const middlewareResult = await setupMiddleware(this.app, {
+            root: this.config.root,
+            workspaceRoot,
+            publicDir: this.config.publicDir,
+            resolver: this.resolver,
+            hmr: this.hmr,
+        });
+        this.routes = middlewareResult.routes;
+        this.routeScanner = middlewareResult.routeScanner;
+        this.routeWatcher = middlewareResult.routeWatcher;
+        console.timeEnd("Middleware Setup");
+        // Start HMR
+        console.time("HMR Start");
+        await this.hmr.initialize();
+        await this.hmr.start();
+        console.timeEnd("HMR Start");
+        // Start HTTP server
+        // Use 0.0.0.0 to bind to all interfaces (IPv4 and IPv6)
+        const bindHost = this.config.host === "localhost" ? "0.0.0.0" : this.config.host;
+        console.time("HTTP Listen");
+        await new Promise((resolve) => {
+            this.app.listen(this.config.port, bindHost, () => {
+                console.timeEnd("HTTP Listen");
+                console.timeEnd("Startup");
+                console.log(chalk.green(`  ➜ Local:   http://localhost:${this.config.port}/`));
+                console.log(chalk.gray(`  ➜ Ready in ${Date.now() - startTime}ms\n`));
+                resolve();
+            });
+        });
+    }
+}

package/dist/utils/cdn-fallback.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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".
+ */
+export declare function shouldUseCdnFallback(specifierOrPkg: string): boolean;
+//# sourceMappingURL=cdn-fallback.d.ts.map

package/dist/utils/cdn-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdn-fallback.d.ts","sourceRoot":"","sources":["../../src/utils/cdn-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAmBH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAKpE"}

package/dist/utils/cdn-fallback.js

@@ -0,0 +1,36 @@
+/**
+ * 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) {
+    if (!specifierOrPkg.startsWith("@"))
+        return null;
+    const firstSlash = specifierOrPkg.indexOf("/");
+    if (firstSlash === -1)
+        return null;
+    return specifierOrPkg.slice(0, firstSlash); // "@scope"
+}
+function parseAllowList() {
+    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) {
+    const scope = getScope(specifierOrPkg);
+    if (!scope)
+        return true; // unscoped: allow by default
+    const allow = parseAllowList();
+    return allow.has(scope);
+}

package/dist/utils/file-path-resolver.d.ts

@@ -0,0 +1,9 @@
+export interface PathResolverContext {
+    root: string;
+    workspaceRoot: string | null;
+}
+/**
+ * Resolve file path from URL, handling SWISS packages, workspace packages, and app files
+ */
+export declare function resolveFilePath(url: string, root: string, workspaceRoot?: string | null): Promise<string>;
+//# sourceMappingURL=file-path-resolver.d.ts.map

package/dist/utils/file-path-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-path-resolver.d.ts","sourceRoot":"","sources":["../../src/utils/file-path-resolver.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,aAAa,GAAE,MAAM,GAAG,IAAW,GAClC,OAAO,CAAC,MAAM,CAAC,CAmLjB"}