feat: enable path aliases if specified in paths or js/tsconfig json

- Update RunEsbuildJs to optionally include tsconfig in the command arguments.

Author: AngelMunoz

src/Perla/Build.fs

@@ -341,23 +341,14 @@ module BuildService =
               ex.Message
             )
 
-        member _.LoadPlugins(config, vfsOutputDir) =
-          let config = config |> AVal.force
+        member _.LoadPlugins(configA, vfsOutputDir) =
+          let config = configA |> AVal.force
           let plugins = args.FsManager.ResolvePluginPaths()
 
           let isEsbuildPluginPresent =
             config.plugins |> List.contains Constants.PerlaEsbuildPluginName
 
-          let isPathsReplacerPresent =
-            config.plugins
-            |> List.contains Constants.PerlaPathsReplacerPluginName
-
           let defaultPlugins = seq {
-            if isPathsReplacerPresent || not(Map.isEmpty config.paths) then
-              ImportMaps.createPathsReplacerPlugin
-                (AVal.constant config.paths)
-                vfsOutputDir
-
             if isEsbuildPluginPresent then
               args.EsbuildService.GetPlugin config.esbuild
           }

src/Perla/Esbuild.fs

@@ -46,6 +46,7 @@ type EsbuildService =
 
 [<RequireQualifiedAccess>]
 module Esbuild =
+  open FsToolkit.ErrorHandling
 
   let singleFileCmd
     (
@@ -82,6 +83,45 @@ module Esbuild =
     }
 
   let Create(serviceArgs: EsbuildServiceArgs) =
+    let extractedAliasedPaths =
+        serviceArgs.PerlaFsManager.PerlaConfiguration |> AVal.map (fun cfg ->
+          let customPaths =
+            cfg.paths |> Map.toSeq |> Seq.choose(fun (key: string<BareImport>, value: string<ResolutionUrl>) ->
+              result {
+                let key = UMX.untag key
+                let value = UMX.untag value
+                do!
+                    (System.IO.Path.IsPathRooted value || System.IO.Path.IsPathFullyQualified value)
+                    |> Result.requireFalse
+                      $"Path '{value}' must not be absolute or fully qualified."
+                do! (value.StartsWith "./" || value.StartsWith "../")
+                      |> Result.requireTrue
+                      $"Path '{value}' must be relative (starting with './' or '../')."
+
+                let key =
+                  if key.EndsWith "/" then $"{key}*" else key
+
+                let value = if value.EndsWith "/" then [$"{value}*"] else [value]
+
+                return key, value
+
+              }
+              |> Result.toOption
+            )
+          customPaths
+        )
+    let getOrBuildTsConfig paths =
+      serviceArgs.PerlaFsManager.ResolveTsConfig
+      |> AVal.map2
+          (fun paths tsconfig ->
+            match tsconfig with
+            | None ->
+              let paths = paths |> Map.ofSeq
+              if paths |> Map.isEmpty then None else
+                {| compilerOptions = {| paths = paths |} |} |> Json.Json.ToText |> Some
+            | Some config -> Some config)
+        paths
+
     { new EsbuildService with
         member this.GetPlugin(config: EsbuildConfig) : PluginInfo =
           let shouldTransform: FilePredicate =
@@ -101,8 +141,7 @@ module Esbuild =
                 | ".js" -> None
                 | _ -> None
 
-              let tsConfig =
-                serviceArgs.PerlaFsManager.ResolveTsConfig |> AVal.force
+              let tsConfig = getOrBuildTsConfig extractedAliasedPaths |> AVal.force
 
               let! result =
                 singleFileCmd(
@@ -152,13 +191,15 @@ module Esbuild =
           : CancellableTask<unit> =
           cancellableTask {
             let esbuildPath = serviceArgs.PerlaFsManager.ResolveEsbuildPath()
+            let tsConfig = getOrBuildTsConfig extractedAliasedPaths |> AVal.force
 
             do!
               serviceArgs.PlatformOps.RunEsbuildJs(
                 esbuildPath,
                 sourcesPath,
                 UMX.untag entrypoint,
                 UMX.untag outdir,
+                tsConfig,
                 config
               )
 

src/Perla/FileSystem.fs

@@ -235,10 +235,21 @@ module FileSystem =
         }
 
         member _.ResolveTsConfig = adaptive {
-          let path =
+          let tsConfigPath =
             args.PerlaDirectories.CurrentWorkingDirectory |/ "tsconfig.json"
 
-          let! content = AdaptiveFile.TryReadAllText(UMX.untag path)
+          let jsConfigPath =
+            args.PerlaDirectories.CurrentWorkingDirectory |/ "jsconfig.json"
+
+          let! content = adaptive {
+            let! tsconfig = AdaptiveFile.TryReadAllText(UMX.untag tsConfigPath)
+            match tsconfig with
+            | Some tsconfig -> return Some tsconfig
+            | None ->
+              let! jsconfig = AdaptiveFile.TryReadAllText(UMX.untag jsConfigPath)
+              return jsconfig
+
+          }
           return content
         }
 

src/Perla/ImportMaps.fs

@@ -17,6 +17,8 @@ type ImportMapResolution = {
 
 module ImportMaps =
   open System
+  open System.IO
+  open System.Collections.Generic
   // Checks if a path is a relative path (starts with ./ or ../ or similar patterns)
   let isRelativePath(path: string) =
     // Normalize separators to forward slashes for consistency
@@ -83,139 +85,6 @@ module ImportMaps =
             |> Map.filter(fun _k v -> not(isLocalImport mounts v))
     }
 
-  /// Replaces module names in import statements using the provided paths map.
-  /// Returns the modified code string with replacements applied.
-  let replaceImports
-    (paths: Map<string<BareImport>, string<ResolutionUrl>>)
-    (importingFile: string)
-    (sourcesRoot: string<SystemPath>)
-    (content: string)
-    : string =
-    let pattern =
-      "import\\s+(?:.+?\\s+from\\s+['\"]([^'\"]+)['\"]|['\"]([^'\"]+)['\"])|import\\s*\\(\\s*(['\"])([^'\"]+)\\3\\s*([,)])"
-
-    let extractModuleName(m: Match) : string =
-      if m.Groups[1].Success then m.Groups[1].Value
-      elif m.Groups[2].Success then m.Groups[2].Value
-      elif m.Groups[4].Success then m.Groups[4].Value
-      else ""
-
-    let computeRelativeImport
-      (importingDir: string)
-      (replacementStr: string)
-      (rest: string)
-      : string =
-      let target =
-        if replacementStr.StartsWith("./") then
-          replacementStr.Substring(2)
-        elif replacementStr.StartsWith("../") then
-          replacementStr
-        else
-          replacementStr
-      // Compute absolute paths
-      let importingDirAbs =
-        let dir =
-          if String.IsNullOrWhiteSpace(importingDir) then
-            UMX.untag sourcesRoot
-          elif System.IO.Path.IsPathRooted(importingDir) then
-            importingDir
-          else
-            System.IO.Path.Combine(UMX.untag sourcesRoot, importingDir)
-
-        System.IO.Path.GetFullPath(dir)
-
-      let targetAbs =
-        System.IO.Path.GetFullPath(
-          System.IO.Path.Combine(UMX.untag sourcesRoot, target)
-        )
-
-      let rel =
-        System.IO.Path
-          .GetRelativePath(importingDirAbs, targetAbs)
-          .Replace('\\', '/')
-
-      let rel =
-        if rel.StartsWith(".") || rel.StartsWith("/") then
-          rel
-        else
-          "./" + rel
-
-      let rel = rel.TrimEnd('/')
-      let rest = rest.TrimStart('/')
-      if rest = "" then rel else rel + "/" + rest
-
-    let computeNewImport
-      (importingDir: string)
-      (moduleName: string)
-      (prefixStr: string)
-      (replacementStr: string)
-      : string =
-      let rest = moduleName.Substring(prefixStr.Length)
-
-      if
-        isRelativePath replacementStr
-        && not(String.IsNullOrWhiteSpace importingDir)
-      then
-        computeRelativeImport importingDir replacementStr rest
-      else
-        replacementStr + rest
-
-    let replaceMatch(m: Match) : string =
-      let moduleName = extractModuleName m
-
-      // Ensure importingFile is absolute, fallback to sourcesRoot if not
-      let importingFileAbs =
-        if System.IO.Path.IsPathRooted(importingFile) then
-          importingFile
-        else
-          System.IO.Path.Combine(UMX.untag sourcesRoot, importingFile)
-          |> System.IO.Path.GetFullPath
-
-      let importingDir =
-        System.IO.Path.GetDirectoryName(importingFileAbs) |> nonNull
-
-      let tryReplace
-        (prefix: string<BareImport>, replacement: string<ResolutionUrl>)
-        : string option =
-        let prefixStr, replacementStr = UMX.untag prefix, UMX.untag replacement
-
-        if moduleName.StartsWith(prefixStr) then
-          let newImport =
-            computeNewImport importingDir moduleName prefixStr replacementStr
-
-          Some(m.Value.Replace(moduleName, newImport))
-        else
-          None
-
-      paths
-      |> Map.toSeq
-      |> Seq.tryPick tryReplace
-      |> Option.defaultValue m.Value
-
-    Regex.Replace(content, pattern, replaceMatch)
-
-  /// Creates a PluginInfo for the perla-paths-replacer-plugin
-  let createPathsReplacerPlugin
-    (pathsA: Map<string<BareImport>, string<ResolutionUrl>> aval)
-    (sourcesRoot: string<SystemPath>)
-    : Perla.Plugins.PluginInfo =
-    let shouldTransform ext =
-      [ ".js"; ".ts"; ".jsx"; ".tsx" ] |> List.contains ext
-
-    let transform: Plugins.Transform =
-      fun file ->
-        let paths = pathsA |> AVal.force
-
-        let replaced =
-          replaceImports paths file.fileLocation sourcesRoot file.content
-
-        { file with content = replaced }
-
-    plugin Constants.PerlaPathsReplacerPluginName {
-      should_process_file shouldTransform
-      with_transform transform
-    }
-
   /// Extracts all external import specifiers from an ImportMap (from both imports and scopes)
   let getExternals(importMap: ImportMap) =
     let importKeys = importMap.imports |> Map.toSeq |> Seq.map fst

src/Perla/PlatformOps.fs

@@ -79,6 +79,7 @@ type PlatformOps =
     workingDir: string<SystemPath> *
     entrypoint: string *
     outdir: string *
+    tsconfig: string option *
     config: EsbuildConfig ->
       CancellableTask<unit>
 
@@ -407,7 +408,7 @@ module PlatformOps =
           }
 
         member _.RunEsbuildJs
-          (esbuildPath, workingDir, entrypoint, outdir, config)
+          (esbuildPath, workingDir, entrypoint, outdir,tsconfig, config)
           =
           cancellableTask {
             let! token = CancellableTask.getCancellationToken()
@@ -420,6 +421,10 @@ module PlatformOps =
             )
 
             let output = Path.Combine(outdir, entrypoint)
+            let addTsConfig (args: Builders.ArgumentsBuilder) =
+              match tsconfig with
+              | Some tsConfig -> args.Add($"--tsconfig-raw={tsConfig}")
+              | None -> args
 
             let command =
               Cli
@@ -434,6 +439,7 @@ module PlatformOps =
                   |> buildEsbuildConfig config
                   |> _.Add($"--outfile={output}")
                   |> _.Add("--preserve-symlinks")
+                  |> addTsConfig
                   |> buildEsbuildFileLoaders config.fileLoaders
                   |> ignore)
                 .WithValidation

src/Perla/PlatformOps.fsi

@@ -71,6 +71,7 @@ type PlatformOps =
     workingDir: string<SystemPath> *
     entrypoint: string *
     outdir: string *
+    tsconfig: string option *
     config: EsbuildConfig ->
       CancellableTask<unit>