@nativescript/windows 0.1.0-alpha.50 → 0.1.0-alpha.51

package/framework/dotnet-bridge/Bridge.cs

@@ -1,7 +1,11 @@
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Runtime.Loader;
 using System.Text.Json;
 
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("DotNetBridgeTests")]
@@ -24,6 +28,11 @@ public static partial class Bridge
     private static readonly ConcurrentDictionary<MethodKey, DispatchEntry> s_methodCache = new();
     private static readonly ConcurrentDictionary<PropKey, PropertyInfo?> s_propCache = new();
     private static readonly ConcurrentDictionary<CtorKey, CtorEntry> s_ctorCache = new();
+    // Cache of attempted assembly loads (simple name -> Assembly or null if not found).
+    private static readonly ConcurrentDictionary<string, Assembly?> s_assemblyLoadCache
+        = new(StringComparer.OrdinalIgnoreCase);
+    // Directories to search for assemblies (initialized once in static ctor).
+    private static readonly string[] s_assemblySearchDirs;
 
     private static readonly JsonSerializerOptions s_coerceOpts = new()
     {
@@ -40,6 +49,131 @@ public static partial class Bridge
         s_nextHandle = 0;
     }
 
+    // Returns a JSON object mapping top-level namespace roots (e.g. "NativeScript")
+    // to the assembly simple-name that most likely contains that namespace's types.
+    // This probes the application base directory and libs/ for assemblies and
+    // inspects exported types. The result is safe-to-call and tolerant of
+    // non-.NET DLLs.
+    public static string GetNamespaceAssemblyMapJson()
+    {
+        var map = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        try
+        {
+            var baseDir = AppContext.BaseDirectory ?? AppDomain.CurrentDomain.BaseDirectory;
+            var dirs = new List<string> { baseDir };
+            var libs = Path.Combine(baseDir, "libs");
+            if (Directory.Exists(libs))
+            {
+                dirs.Add(libs);
+                try { dirs.AddRange(Directory.GetDirectories(libs, "*", SearchOption.AllDirectories)); } catch { }
+            }
+
+            foreach (var dir in dirs.Where(d => !string.IsNullOrEmpty(d) && Directory.Exists(d)))
+            {
+                try
+                {
+                    foreach (var file in Directory.EnumerateFiles(dir, "*.dll", SearchOption.TopDirectoryOnly))
+                    {
+                        try
+                        {
+                            var simple = Path.GetFileNameWithoutExtension(file);
+                            if (string.IsNullOrEmpty(simple)) continue;
+
+                            Assembly asm = AppDomain.CurrentDomain.GetAssemblies()
+                                .FirstOrDefault(a => string.Equals(a.GetName().Name, simple, StringComparison.OrdinalIgnoreCase));
+                            if (asm is null)
+                            {
+                                try { asm = AssemblyLoadContext.Default.LoadFromAssemblyPath(file); }
+                                catch { continue; }
+                            }
+
+                            Type[] types;
+                            try { types = asm.GetExportedTypes(); }
+                            catch { types = Array.Empty<Type>(); }
+
+                            foreach (var t in types)
+                            {
+                                if (string.IsNullOrEmpty(t.Namespace)) continue;
+                                var root = t.Namespace.Split('.')[0];
+                                if (!map.ContainsKey(root)) map[root] = asm.GetName().Name;
+                            }
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
+            }
+        }
+        catch { }
+        try { return JsonSerializer.Serialize(map); } catch { return "{}"; }
+    }
+
+    // Static ctor: initialize assembly search directories and register resolver.
+    static Bridge()
+    {
+        try
+        {
+            var baseDir = AppContext.BaseDirectory ?? AppDomain.CurrentDomain.BaseDirectory;
+            var dirs = new List<string> { baseDir };
+            var libs = Path.Combine(baseDir, "libs");
+            if (Directory.Exists(libs))
+            {
+                dirs.Add(libs);
+                try { dirs.AddRange(Directory.GetDirectories(libs, "*", SearchOption.AllDirectories)); } catch { }
+            }
+            s_assemblySearchDirs = dirs.Where(d => !string.IsNullOrEmpty(d)).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
+            AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
+        }
+        catch
+        {
+            s_assemblySearchDirs = Array.Empty<string>();
+        }
+    }
+
+    private static Assembly? OnAssemblyResolve(object? sender, ResolveEventArgs args)
+    {
+        try
+        {
+            var requested = new AssemblyName(args.Name).Name;
+            if (string.IsNullOrEmpty(requested)) return null;
+
+            if (s_assemblyLoadCache.TryGetValue(requested, out var cached)) return cached;
+
+            // Check already-loaded assemblies first (avoid recursive Assembly.Load).
+            var loadedAsm = AppDomain.CurrentDomain.GetAssemblies()
+                .FirstOrDefault(a => string.Equals(a.GetName().Name, requested, StringComparison.OrdinalIgnoreCase));
+            if (loadedAsm is not null)
+            {
+                s_assemblyLoadCache[requested] = loadedAsm;
+                return loadedAsm;
+            }
+
+            // Try to locate a matching dll in known search directories.
+            foreach (var dir in s_assemblySearchDirs)
+            {
+                try
+                {
+                    var candidate = Path.Combine(dir, requested + ".dll");
+                    if (File.Exists(candidate))
+                    {
+                        try
+                        {
+                            var asm = AssemblyLoadContext.Default.LoadFromAssemblyPath(candidate);
+                            s_assemblyLoadCache[requested] = asm;
+                            return asm;
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
+            }
+
+            s_assemblyLoadCache[requested] = null;
+        }
+        catch { }
+        return null;
+    }
+
     [UnmanagedCallersOnly(EntryPoint = "RegisterJsCallback",
         CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
     public static unsafe int RegisterJsCallback(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nativescript/windows",
-  "version": "0.1.0-alpha.50",
+  "version": "0.1.0-alpha.51",
   "description": "NativeScript for using Windows v8",
   "repository": {
         "type": "git",