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

package/framework/dotnet-bridge/Bridge.Dispatch.cs

@@ -245,11 +245,20 @@ public static partial class Bridge
     {
         const BindingFlags inst = BindingFlags.Public | BindingFlags.Instance;
         const BindingFlags stat = BindingFlags.Public | BindingFlags.Static;
+
+        var instProps = t.GetProperties(inst);
+        var statProps = t.GetProperties(stat);
+
         return DispatchResult.Members(
-            t.GetMethods(inst).Where(m => !m.IsSpecialName).Select(m => m.Name).Distinct().ToArray(),
-            t.GetProperties(inst).Select(p => p.Name).Distinct().ToArray(),
-            t.GetMethods(stat).Where(m => !m.IsSpecialName).Select(m => m.Name).Distinct().ToArray(),
-            t.GetProperties(stat).Select(p => p.Name).Distinct().ToArray());
+            methods:               t.GetMethods(inst).Where(m => !m.IsSpecialName).Select(m => m.Name).Distinct().ToArray(),
+            props:                 instProps.Where(p => p.GetGetMethod() != null).Select(p => p.Name).Distinct().ToArray(),
+            staticMethods:         t.GetMethods(stat).Where(m => !m.IsSpecialName).Select(m => m.Name).Distinct().ToArray(),
+            staticProps:           statProps.Where(p => p.GetGetMethod() != null).Select(p => p.Name).Distinct().ToArray(),
+            readonlyProps:         instProps.Where(p => p.GetGetMethod() != null && p.GetSetMethod() == null).Select(p => p.Name).Distinct().ToArray(),
+            readonlyStaticProps:   statProps.Where(p => p.GetGetMethod() != null && p.GetSetMethod() == null).Select(p => p.Name).Distinct().ToArray(),
+            writeonlyProps:        instProps.Where(p => p.GetGetMethod() == null && p.GetSetMethod() != null).Select(p => p.Name).Distinct().ToArray(),
+            writeonlyStaticProps:  statProps.Where(p => p.GetGetMethod() == null && p.GetSetMethod() != null).Select(p => p.Name).Distinct().ToArray()
+        );
     }
 
     internal static Type? ResolveType(string? assemblyName, string? typeName)
@@ -288,12 +297,14 @@ public static partial class Bridge
                 // we catch and continue.
                 foreach (var ty in asm.GetTypes())
                 {
-                    if (string.Equals(ty.FullName, typeName, StringComparison.Ordinal)
-                        || string.Equals(ty.Name, shortName, StringComparison.Ordinal)
-                        || (lastDot < 0 && ty.Namespace != null && ty.Namespace == typeName))
-                    {
+                    if (string.Equals(ty.FullName, typeName, StringComparison.Ordinal))
+                        return ty;
+                    // Short-name match only when input has no namespace prefix (e.g. "Stopwatch").
+                    // Guarding on lastDot < 0 prevents matching unrelated types in other namespaces
+                    // (e.g. "NativeScript.Widgets.FlexboxLayout" must not match a different
+                    //  FlexboxLayout that happens to live in another namespace).
+                    if (lastDot < 0 && string.Equals(ty.Name, shortName, StringComparison.Ordinal))
                         return ty;
-                    }
                 }
             }
             catch (ReflectionTypeLoadException) { }
@@ -315,12 +326,10 @@ public static partial class Bridge
                     {
                         foreach (var ty in asm.GetTypes())
                         {
-                            if (string.Equals(ty.FullName, typeName, StringComparison.Ordinal)
-                                || string.Equals(ty.Name, shortName, StringComparison.Ordinal)
-                                || (lastDot < 0 && ty.Namespace != null && ty.Namespace == typeName))
-                            {
+                            if (string.Equals(ty.FullName, typeName, StringComparison.Ordinal))
+                                return ty;
+                            if (lastDot < 0 && string.Equals(ty.Name, shortName, StringComparison.Ordinal))
                                 return ty;
-                            }
                         }
                     }
                     catch (ReflectionTypeLoadException) { }

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,148 @@ 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.
+    // Reuses s_assemblySearchDirs so plugin and NuGet assemblies are included.
+    public static string GetNamespaceAssemblyMapJson()
+    {
+        var map = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        try
+        {
+            foreach (var dir in s_assemblySearchDirs.Where(Directory.Exists))
+            {
+                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 };
+
+            // libs/ subtree relative to the bridge's own directory.
+            var libs = Path.Combine(baseDir, "libs");
+            if (Directory.Exists(libs))
+            {
+                dirs.Add(libs);
+                try { dirs.AddRange(Directory.GetDirectories(libs, "*", SearchOption.AllDirectories)); } catch { }
+            }
+
+            // The bridge DLL lives at dotnet-bridge/publish/ inside the app output root.
+            // Plugin assemblies (added via plugin.props) land at plugins/**/*.dll and NuGet
+            // assemblies land at the app output root itself — both outside the bridge subtree.
+            // Use the host process directory to reach them.
+            try
+            {
+                var processDir = Path.GetDirectoryName(
+                    System.Diagnostics.Process.GetCurrentProcess().MainModule?.FileName);
+                if (!string.IsNullOrEmpty(processDir))
+                {
+                    dirs.Add(processDir);
+
+                    // plugins/ subtree: CLI-managed plugin DLLs live here.
+                    var pluginsDir = Path.Combine(processDir, "plugins");
+                    if (Directory.Exists(pluginsDir))
+                        try { dirs.AddRange(Directory.GetDirectories(pluginsDir, "*", SearchOption.AllDirectories)); } catch { }
+
+                    // libs/ relative to the app root (alternative convention).
+                    var processLibs = Path.Combine(processDir, "libs");
+                    if (Directory.Exists(processLibs))
+                        try { dirs.AddRange(Directory.GetDirectories(processLibs, "*", SearchOption.AllDirectories)); } catch { }
+                }
+            }
+            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/framework/dotnet-bridge/DispatchTypes.cs

@@ -71,14 +71,22 @@ internal readonly struct DispatchResult
     private readonly string[]?    _properties;
     private readonly string[]?    _staticMethods;
     private readonly string[]?    _staticProperties;
+    private readonly string[]?    _readonlyProperties;
+    private readonly string[]?    _readonlyStaticProperties;
+    private readonly string[]?    _writeonlyProperties;
+    private readonly string[]?    _writeonlyStaticProperties;
 
     private DispatchResult(DispatchKind kind, object? value, Type? type, int handle,
         string? typeName, string[]? methods, string[]? props,
-        string[]? staticMethods, string[]? staticProps)
+        string[]? staticMethods, string[]? staticProps,
+        string[]? readonlyProps = null, string[]? readonlyStaticProps = null,
+        string[]? writeonlyProps = null, string[]? writeonlyStaticProps = null)
     {
         _kind = kind; _value = value; _type = type; _handle = handle;
         _typeName = typeName; _methods = methods; _properties = props;
         _staticMethods = staticMethods; _staticProperties = staticProps;
+        _readonlyProperties = readonlyProps; _readonlyStaticProperties = readonlyStaticProps;
+        _writeonlyProperties = writeonlyProps; _writeonlyStaticProperties = writeonlyStaticProps;
     }
 
     public static DispatchResult Primitive(object value, Type type)
@@ -91,8 +99,12 @@ internal readonly struct DispatchResult
         => new(DispatchKind.Collection, items, null, 0, null, null, null, null, null);
 
     public static DispatchResult Members(
-        string[] methods, string[] props, string[] staticMethods, string[] staticProps)
-        => new(DispatchKind.Members, null, null, 0, null, methods, props, staticMethods, staticProps);
+        string[] methods, string[] props, string[] staticMethods, string[] staticProps,
+        string[] readonlyProps, string[] readonlyStaticProps,
+        string[] writeonlyProps, string[] writeonlyStaticProps)
+        => new(DispatchKind.Members, null, null, 0, null,
+               methods, props, staticMethods, staticProps,
+               readonlyProps, readonlyStaticProps, writeonlyProps, writeonlyStaticProps);
 
     internal int HandleId() => _handle;
 
@@ -126,10 +138,14 @@ internal readonly struct DispatchResult
 
             case DispatchKind.Members:
                 w.WriteStartObject();
-                WriteStringArray(w, "methods"u8,          _methods!);
-                WriteStringArray(w, "properties"u8,       _properties!);
-                WriteStringArray(w, "staticMethods"u8,    _staticMethods!);
-                WriteStringArray(w, "staticProperties"u8, _staticProperties!);
+                WriteStringArray(w, "methods"u8,                  _methods!);
+                WriteStringArray(w, "properties"u8,               _properties!);
+                WriteStringArray(w, "staticMethods"u8,            _staticMethods!);
+                WriteStringArray(w, "staticProperties"u8,         _staticProperties!);
+                WriteStringArray(w, "readonlyProperties"u8,       _readonlyProperties!);
+                WriteStringArray(w, "readonlyStaticProperties"u8, _readonlyStaticProperties!);
+                WriteStringArray(w, "writeonlyProperties"u8,      _writeonlyProperties!);
+                WriteStringArray(w, "writeonlyStaticProperties"u8,_writeonlyStaticProperties!);
                 w.WriteEndObject();
                 break;
         }
@@ -185,6 +201,10 @@ internal readonly struct DispatchResult
                 WriteStringArrayBin(ref w, _properties!);
                 WriteStringArrayBin(ref w, _staticMethods!);
                 WriteStringArrayBin(ref w, _staticProperties!);
+                WriteStringArrayBin(ref w, _readonlyProperties!);
+                WriteStringArrayBin(ref w, _readonlyStaticProperties!);
+                WriteStringArrayBin(ref w, _writeonlyProperties!);
+                WriteStringArrayBin(ref w, _writeonlyStaticProperties!);
                 break;
         }
     }

package/package.json

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