@devscholar/node-ps1-dotnet 0.0.1 → 0.0.2

package/__tests__/winforms.test.ts

@@ -0,0 +1,136 @@
+import { jest } from '@jest/globals';
+
+const isWindows = process.platform === 'win32';
+
+(isWindows ? describe : describe.skip)('WinForms GUI Tests', () => {
+  let dotnet: any;
+  let System: any;
+  let Forms: any;
+  let Drawing: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+      dotnet.default.load('System.Windows.Forms');
+      dotnet.default.load('System.Drawing');
+      System = dotnet.System;
+      Forms = System.Windows.Forms;
+      Drawing = System.Drawing;
+    } catch (e) {
+      console.log('Skipping WinForms tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should load System.Windows.Forms assembly', () => {
+    expect(Forms).toBeDefined();
+    expect(Forms.Form).toBeDefined();
+  });
+
+  it('should load System.Drawing assembly', () => {
+    expect(Drawing).toBeDefined();
+    expect(Drawing.Color).toBeDefined();
+    expect(Drawing.Font).toBeDefined();
+    expect(Drawing.Point).toBeDefined();
+  });
+
+  it('should create a Form instance', () => {
+    const form = new Forms.Form();
+    expect(form).toBeDefined();
+    expect(form.__ref).toBeDefined();
+  });
+
+  it('should set Form properties', () => {
+    const form = new Forms.Form();
+    form.Text = 'Test Form';
+    form.Width = 800;
+    form.Height = 600;
+    form.StartPosition = 1;
+    
+    expect(form.Text).toBe('Test Form');
+    expect(form.Width).toBe(800);
+    expect(form.Height).toBe(600);
+  });
+
+  it('should create a Label control', () => {
+    const label = new Forms.Label();
+    expect(label).toBeDefined();
+    
+    label.Text = 'Test Label';
+    label.Font = new Drawing.Font('Arial', 14);
+    label.AutoSize = true;
+    
+    expect(label.Text).toBe('Test Label');
+    expect(label.AutoSize).toBe(true);
+  });
+
+  it('should create a Button control', () => {
+    const button = new Forms.Button();
+    expect(button).toBeDefined();
+    
+    button.Text = 'Click Me';
+    button.AutoSize = true;
+    
+    expect(button.Text).toBe('Click Me');
+  });
+
+  it('should create a Panel control', () => {
+    const panel = new Forms.Panel();
+    expect(panel).toBeDefined();
+    
+    panel.Width = 100;
+    panel.Height = 100;
+    panel.BackColor = Drawing.Color.Red;
+    
+    expect(panel.Width).toBe(100);
+    expect(panel.Height).toBe(100);
+  });
+
+  it('should create a Point for location', () => {
+    const point = new Drawing.Point(100, 200);
+    expect(point).toBeDefined();
+    expect(point.X).toBe(100);
+    expect(point.Y).toBe(200);
+  });
+
+  it('should create a Font', () => {
+    const font = new Drawing.Font('Arial', 12);
+    expect(font).toBeDefined();
+    expect(font.Name).toContain('Arial');
+  });
+
+  it('should add controls to form', () => {
+    const form = new Forms.Form();
+    const label = new Forms.Label();
+    const button = new Forms.Button();
+    
+    form.Controls.Add(label);
+    form.Controls.Add(button);
+    
+    expect(form.Controls.Count).toBeGreaterThanOrEqual(2);
+  });
+
+  it('should register click event handler', () => {
+    const button = new Forms.Button();
+    let clicked = false;
+    
+    button.add_Click(() => {
+      clicked = true;
+    });
+    
+    expect(button).toBeDefined();
+  });
+
+  it('should create Color constants', () => {
+    expect(Drawing.Color.Red).toBeDefined();
+    expect(Drawing.Color.Green).toBeDefined();
+    expect(Drawing.Color.Blue).toBeDefined();
+    expect(Drawing.Color.Black).toBeDefined();
+    expect(Drawing.Color.White).toBeDefined();
+  });
+});

package/__tests__/wpf.test.ts

@@ -0,0 +1,135 @@
+import { jest } from '@jest/globals';
+
+const isWindows = process.platform === 'win32';
+
+(isWindows ? describe : describe.skip)('WPF GUI Tests', () => {
+  let dotnet: any;
+  let System: any;
+  let Windows: any;
+  let Controls: any;
+  let Media: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+      dotnet.default.load('PresentationFramework');
+      dotnet.default.load('PresentationCore');
+      dotnet.default.load('WindowsBase');
+      System = dotnet.System;
+      Windows = System.Windows;
+      Controls = Windows.Controls;
+      Media = Windows.Media;
+    } catch (e) {
+      console.log('Skipping WPF tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should load PresentationFramework assembly', () => {
+    expect(Controls).toBeDefined();
+    expect(Windows).toBeDefined();
+  });
+
+  it('should load PresentationCore assembly', () => {
+    expect(Media).toBeDefined();
+    expect(Media.FontFamily).toBeDefined();
+  });
+
+  it('should create a Window instance', () => {
+    const window = new Windows.Window();
+    expect(window).toBeDefined();
+    expect(window.__ref).toBeDefined();
+  });
+
+  it('should set Window properties', () => {
+    const window = new Windows.Window();
+    window.Title = 'Test Window';
+    window.Width = 400;
+    window.Height = 300;
+    window.WindowStartupLocation = Windows.WindowStartupLocation.CenterScreen;
+    
+    expect(window.Title).toBe('Test Window');
+    expect(window.Width).toBe(400);
+    expect(window.Height).toBe(300);
+  });
+
+  it('should create a StackPanel', () => {
+    const stackPanel = new Controls.StackPanel();
+    expect(stackPanel).toBeDefined();
+    
+    stackPanel.HorizontalAlignment = Windows.HorizontalAlignment.Center;
+    stackPanel.VerticalAlignment = Windows.VerticalAlignment.Center;
+    
+    expect(stackPanel.HorizontalAlignment).toBeDefined();
+  });
+
+  it('should create a Label control', () => {
+    const label = new Controls.Label();
+    expect(label).toBeDefined();
+    label.Content = 'Test Label';
+    label.FontSize = 24;
+    label.Margin = new Windows.Thickness(10);
+    
+    expect(label.Content).toBe('Test Label');
+    expect(label.FontSize).toBe(24);
+  });
+
+  it('should create a Button control', () => {
+    const button = new Controls.Button();
+    expect(button).toBeDefined();
+    
+    button.Content = 'Click Me';
+    button.FontSize = 14;
+    button.Padding = new Windows.Thickness(5);
+    
+    expect(button.Content).toBe('Click Me');
+  });
+
+  it('should add children to StackPanel', () => {
+    const stackPanel = new Controls.StackPanel();
+    const label = new Controls.Label();
+    const button = new Controls.Button();
+    
+    stackPanel.Children.Add(label);
+    stackPanel.Children.Add(button);
+    
+    expect(stackPanel.Children.Count).toBeGreaterThanOrEqual(2);
+  });
+
+  it('should set Window Content to StackPanel', () => {
+    const window = new Windows.Window();
+    const stackPanel = new Controls.StackPanel();
+    
+    window.Content = stackPanel;
+    
+    expect(window.Content).toBeDefined();
+  });
+
+  it('should register button click event handler', () => {
+    const button = new Controls.Button();
+    
+    button.add_Click((sender: any, e: any) => {
+      console.log('Button clicked');
+    });
+    
+    expect(button).toBeDefined();
+  });
+
+  it('should create FontFamily', () => {
+    const fontFamily = new Media.FontFamily('Arial');
+    expect(fontFamily).toBeDefined();
+  });
+
+  it('should create Thickness', () => {
+    const thickness = new Windows.Thickness(10);
+    expect(thickness).toBeDefined();
+    
+    const thickness2 = new Windows.Thickness(5, 10, 15, 20);
+    expect(thickness2).toBeDefined();
+  });
+});

package/docs/testing.md

@@ -0,0 +1,30 @@
+# Testing
+Run all tests:
+
+```bash
+npm test
+```
+
+Run specific test files:
+
+```bash
+npm test -- --testPathPatterns=winforms
+npm test -- --testPathPatterns=wpf
+npm test -- --testPathPatterns=dotnet
+```
+
+Test files are located in the `__tests__` directory:
+
+- `basic.test.ts` - Basic module functionality tests
+- `ipc.test.ts` - IPC communication tests
+- `winforms.test.ts` - WinForms GUI component tests
+- `wpf.test.ts` - WPF GUI component tests
+- `gui-events.test.ts` - GUI event handling tests
+- `dotnet-enums.test.ts` - .NET enum tests
+- `dotnet-console.test.ts` - Console class tests
+- `dotnet-io.test.ts` - System.IO tests
+- `dotnet-task.test.ts` - Task asynchronous tests
+- `dotnet-misc.test.ts` - String, Array, Environment tests
+- `dotnet-runtime.test.ts` - Runtime info and type loading tests
+
+Note: GUI tests will not display windows - they only create objects in memory for verification.

package/jest.config.js

@@ -0,0 +1,31 @@
+export default {
+  preset: 'ts-jest/presets/default-esm',
+  testEnvironment: 'node',
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    '^.+\\.ts$': [
+      'ts-jest',
+      {
+        useESM: true,
+        tsconfig: {
+          module: 'ESNext',
+          moduleResolution: 'bundler',
+        },
+      },
+    ],
+  },
+  testMatch: [
+    '**/__tests__/**/*.ts',
+    '**/?(*.)+(spec|test).ts',
+  ],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  testTimeout: 30000,
+};

package/package.json

@@ -1,21 +1,32 @@
 {
   "name": "@devscholar/node-ps1-dotnet",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Node.js to .NET interop via IPC",
-  "main": "./src/index.ts",
+  "main": "./dist/index.js",
   "type": "module",
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./dist/index.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch",
+    "test:coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage",
     "build": "tsc"
   },
-  "keywords": ["dotnet", "winforms", "interop", "bridge", "ipc"],
+  "keywords": [
+    "dotnet",
+    "winforms",
+    "interop",
+    "bridge",
+    "ipc"
+  ],
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@types/jest": "^30.0.0",
     "@types/node": "^25.0.10",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.9.3"
   }
 }

package/scripts/PsBridge/Reflection.cs

@@ -380,6 +380,20 @@ public static class Reflection
                                 var intValue = value is long ? (int)(long)value : (int)value;
                                 value = Enum.ToObject(prop.PropertyType, intValue);
                             }
+                            else if (prop.PropertyType.IsValueType && !prop.PropertyType.IsPrimitive)
+                            {
+                                // Handle structs like FontWeight - try to create from integer
+                                var intValue = value is long ? (int)(long)value : (int)value;
+                                var ctor = prop.PropertyType.GetConstructor(new[] { typeof(int) });
+                                if (ctor != null)
+                                {
+                                    value = ctor.Invoke(new object[] { intValue });
+                                }
+                                else if (value is IConvertible)
+                                {
+                                    value = Convert.ChangeType(value, prop.PropertyType);
+                                }
+                            }
                             else if (value is IConvertible)
                             {
                                 value = Convert.ChangeType(value, prop.PropertyType);