@devscholar/node-ps1-dotnet 0.0.1 → 0.0.2

package/src/proxy.ts

@@ -0,0 +1,330 @@
+import { getIpc, setIpc, getProc, setProc, getInitialized, setInitialized, getCachedRuntimeInfo, setCachedRuntimeInfo } from './state.js';
+
+export let node_ps1_dotnetGetter: (() => any) | null = null;
+
+export function setNodePs1Dotnet(fn: () => any) {
+    node_ps1_dotnetGetter = fn;
+}
+
+export function getNodePs1Dotnet() {
+    if (node_ps1_dotnetGetter) {
+        return node_ps1_dotnetGetter();
+    }
+    throw new Error('node_ps1_dotnet not initialized');
+}
+
+const gcRegistry = new FinalizationRegistry((id: string) => {
+    try { getNodePs1Dotnet()._release(id); } catch {}
+});
+
+export const callbackRegistry = new Map<string, Function>();
+export const typeMetadataCache = new Map<string, Map<string, string>>();
+export const globalTypeCache = new Map<string, Map<string, string>>();
+export const pendingInspectRequests = new Map<string, string[]>();
+export const pendingInspectTimeout = new Map<string, NodeJS.Timeout>();
+export const typeNameCache = new Map<string, string>();
+export const LARGE_ARRAY_THRESHOLD = 50;
+
+export function getObjectTypeName(id: string): string | null {
+    const ipc = getIpc();
+    if (typeNameCache.has(id)) {
+        return typeNameCache.get(id)!;
+    }
+    try {
+        const res = ipc!.send({ action: 'GetTypeName', targetId: id });
+        if (res && res.typeName) {
+            typeNameCache.set(id, res.typeName);
+            return res.typeName;
+        }
+    } catch {}
+    return null;
+}
+
+export function getTypeMembers(typeName: string, memberNames: string[]): Map<string, string> | null {
+    const ipc = getIpc();
+    if (globalTypeCache.has(typeName)) {
+        const cached = globalTypeCache.get(typeName)!;
+        const result = new Map<string, string>();
+        let allFound = true;
+        for (const name of memberNames) {
+            if (cached.has(name)) {
+                result.set(name, cached.get(name)!);
+            } else {
+                allFound = false;
+            }
+        }
+        if (allFound) return result;
+    }
+
+    try {
+        const res = ipc!.send({ action: 'InspectType', typeName, memberNames });
+        if (res && res.members) {
+            if (!globalTypeCache.has(typeName)) {
+                globalTypeCache.set(typeName, new Map());
+            }
+            const cache = globalTypeCache.get(typeName)!;
+            for (const [name, type] of Object.entries(res.members as Record<string, string>)) {
+                cache.set(name, type);
+            }
+            return new Map(Object.entries(res.members as Record<string, string>));
+        }
+    } catch {}
+    return null;
+}
+
+export function ensureMemberTypeCached(id: string, memberName: string, memberCache: Map<string, string>) {
+    if (memberCache.has(memberName)) return;
+
+    const typeName = getObjectTypeName(id);
+    if (typeName) {
+        const members = getTypeMembers(typeName, [memberName]);
+        if (members && members.has(memberName)) {
+            memberCache.set(memberName, members.get(memberName)!);
+            return;
+        }
+    }
+
+    const ipc = getIpc();
+    try {
+        const inspectRes = ipc!.send({ action: 'Inspect', targetId: id, memberName });
+        memberCache.set(memberName, inspectRes.memberType);
+    } catch {
+        memberCache.set(memberName, 'property');
+    }
+}
+
+export function createLazyArray(arr: any[]): any {
+    return new Proxy(arr, {
+        get(target, prop) {
+            if (typeof prop === 'symbol') return target[prop];
+            const index = Number(prop);
+            if (!isNaN(index) && index >= 0 && index < target.length) {
+                return createProxy(target[index]);
+            }
+            if (prop === 'length') return target.length;
+            if (prop === 'map' || prop === 'filter' || prop === 'forEach' || prop === 'reduce') {
+                return (...args: any[]) => {
+                    const transformed = target.map((item: any) => createProxy(item));
+                    const method = (transformed as any)[prop];
+                    return method.call(transformed, ...args);
+                };
+            }
+            if (prop === 'slice') {
+                return (...args: any[]) => {
+                    const sliced = target.slice(...args);
+                    return sliced.map((item: any) => createProxy(item));
+                };
+            }
+            return undefined;
+        }
+    });
+}
+
+export function createProxyWithInlineProps(meta: any): any {
+    if (meta.type !== 'ref') return createProxy(meta);
+
+    const ipc = getIpc();
+    const id = meta.id!;
+    const inlineProps = meta.props || {};
+
+    if (!typeMetadataCache.has(id)) {
+        typeMetadataCache.set(id, new Map());
+    }
+    const memberCache = typeMetadataCache.get(id)!;
+
+    class Stub {}
+
+    const proxy = new Proxy(Stub, {
+        get: (target: any, prop: string) => {
+            if (prop === '__ref') return id;
+            if (prop === '__inlineProps') return inlineProps;
+            if (typeof prop !== 'string') return undefined;
+
+            if (inlineProps.hasOwnProperty(prop)) {
+                memberCache.set(prop, 'property');
+                return inlineProps[prop];
+            }
+
+            if (prop.startsWith('add_')) {
+                const eventName = prop.substring(4);
+                return (callback: Function) => {
+                    const cbId = `cb_${Date.now()}_${Math.random()}`;
+                    callbackRegistry.set(cbId, callback);
+                    ipc!.send({ action: 'AddEvent', targetId: id, eventName, callbackId: cbId });
+                };
+            }
+
+            let memType = memberCache.get(prop);
+
+            if (!memType) {
+                ensureMemberTypeCached(id, prop, memberCache);
+                memType = memberCache.get(prop);
+            }
+
+            if (memType === 'property') {
+                const res = ipc!.send({ action: 'Invoke', targetId: id, methodName: prop, args: [] });
+                return createProxy(res);
+            } else {
+                return (...args: any[]) => {
+                    const netArgs = args.map((a: any) => {
+                        if (a && a.__ref) return { __ref: a.__ref };
+                        if (typeof a === 'function') {
+                            const cbId = `cb_arg_${Date.now()}_${Math.random()}`;
+                            callbackRegistry.set(cbId, a);
+                            return { type: 'callback', callbackId: cbId };
+                        }
+                        return a;
+                    });
+                    const res = ipc!.send({ action: 'Invoke', targetId: id, methodName: prop, args: netArgs });
+                    return createProxy(res);
+                };
+            }
+        },
+
+        set: (target: any, prop: string, value: any) => {
+            if (typeof prop !== 'string') return false;
+            const netArg = (value && value.__ref) ? { __ref: value.__ref } : value;
+            ipc!.send({ action: 'Invoke', targetId: id, methodName: prop, args: [netArg] });
+            memberCache.set(prop, 'property');
+            return true;
+        },
+
+        construct: (target: any, args: any[]) => {
+            const netArgs = args.map((a: any) => {
+                if (a && a.__ref) return { __ref: a.__ref };
+                if (typeof a === 'function') {
+                    const cbId = `cb_ctor_${Date.now()}_${Math.random()}`;
+                    callbackRegistry.set(cbId, a);
+                    return { type: 'callback', callbackId: cbId };
+                }
+                return a;
+            });
+            const res = ipc!.send({ action: 'New', typeId: id, args: netArgs });
+            return createProxy(res);
+        },
+
+        apply: () => { throw new Error("Cannot call .NET object as a function. Need 'new'?"); }
+    });
+
+    gcRegistry.register(proxy, id);
+    return proxy;
+}
+
+export function createProxy(meta: any): any {
+    const ipc = getIpc();
+    
+    if (meta.type === 'primitive' || meta.type === 'null') return meta.value;
+
+    if (meta.type === 'array') {
+        const arr = meta.value;
+        if (arr.length <= LARGE_ARRAY_THRESHOLD) {
+            return arr.map((item: any) => createProxy(item));
+        }
+        return createLazyArray(arr);
+    }
+
+    if (meta.type === 'task') {
+        const taskId = meta.id;
+        return new Promise((resolve, reject) => {
+            try {
+                const res = ipc!.send({ action: 'AwaitTask', taskId: taskId });
+                resolve(createProxy(res));
+            } catch (e) {
+                reject(e);
+            } finally {
+                try { ipc!.send({ action: 'Release', targetId: taskId }); } catch {}
+            }
+        });
+    }
+
+    if (meta.type === 'namespace') {
+        const nsName = meta.value;
+        const dotnet = getNodePs1Dotnet();
+        return new Proxy({}, {
+            get: (target: any, prop: string) => {
+                if (typeof prop !== 'string') return undefined;
+                return dotnet._load(`${nsName}.${prop}`);
+            }
+        });
+    }
+
+    if (meta.type !== 'ref') return null;
+
+    const id = meta.id!;
+
+    if (!typeMetadataCache.has(id)) {
+        typeMetadataCache.set(id, new Map());
+    }
+    const memberCache = typeMetadataCache.get(id)!;
+
+    class Stub {}
+
+    const proxy = new Proxy(Stub, {
+        get: (target: any, prop: string) => {
+            if (prop === '__ref') return id;
+            if (typeof prop !== 'string') return undefined;
+
+            if (prop.startsWith('add_')) {
+                const eventName = prop.substring(4);
+                return (callback: Function) => {
+                    const cbId = `cb_${Date.now()}_${Math.random()}`;
+                    callbackRegistry.set(cbId, callback);
+                    ipc!.send({ action: 'AddEvent', targetId: id, eventName, callbackId: cbId });
+                };
+            }
+
+            let memType = memberCache.get(prop);
+
+            if (!memType) {
+                ensureMemberTypeCached(id, prop, memberCache);
+                memType = memberCache.get(prop);
+            }
+
+            if (memType === 'property') {
+                const res = ipc!.send({ action: 'Invoke', targetId: id, methodName: prop, args: [] });
+                return createProxy(res);
+            } else {
+                return (...args: any[]) => {
+                    const netArgs = args.map((a: any) => {
+                        if (a && a.__ref) return { __ref: a.__ref };
+                        if (typeof a === 'function') {
+                            const cbId = `cb_arg_${Date.now()}_${Math.random()}`;
+                            callbackRegistry.set(cbId, a);
+                            return { type: 'callback', callbackId: cbId };
+                        }
+                        return a;
+                    });
+                    const res = ipc!.send({ action: 'Invoke', targetId: id, methodName: prop, args: netArgs });
+                    return createProxy(res);
+                };
+            }
+        },
+
+        set: (target: any, prop: string, value: any) => {
+            if (typeof prop !== 'string') return false;
+            const netArg = (value && value.__ref) ? { __ref: value.__ref } : value;
+            ipc!.send({ action: 'Invoke', targetId: id, methodName: prop, args: [netArg] });
+            memberCache.set(prop, 'property');
+            return true;
+        },
+
+        construct: (target: any, args: any[]) => {
+            const netArgs = args.map((a: any) => {
+                if (a && a.__ref) return { __ref: a.__ref };
+                if (typeof a === 'function') {
+                    const cbId = `cb_ctor_${Date.now()}_${Math.random()}`;
+                    callbackRegistry.set(cbId, a);
+                    return { type: 'callback', callbackId: cbId };
+                }
+                return a;
+            });
+            const res = ipc!.send({ action: 'New', typeId: id, args: netArgs });
+            return createProxy(res);
+        },
+
+        apply: () => { throw new Error("Cannot call .NET object as a function. Need 'new'?"); }
+    });
+
+    gcRegistry.register(proxy, id);
+    return proxy;
+}

package/src/state.ts

@@ -0,0 +1,17 @@
+import { IpcSync } from './ipc.js';
+import * as cp from 'node:child_process';
+
+let _ipc: IpcSync | null = null;
+let _proc: cp.ChildProcess | null = null;
+let _initialized = false;
+let _cachedRuntimeInfo: { frameworkMoniker: string; runtimeVersion: string } | null = null;
+
+export function getIpc() { return _ipc; }
+export function getProc() { return _proc; }
+export function getInitialized() { return _initialized; }
+export function getCachedRuntimeInfo() { return _cachedRuntimeInfo; }
+
+export function setIpc(val: IpcSync | null) { _ipc = val; }
+export function setProc(val: cp.ChildProcess | null) { _proc = val; }
+export function setInitialized(val: boolean) { _initialized = val; }
+export function setCachedRuntimeInfo(val: { frameworkMoniker: string; runtimeVersion: string } | null) { _cachedRuntimeInfo = val; }

package/src/types.ts

@@ -13,6 +13,8 @@ export interface ProtocolResponse {
     runtimeVersion?: string;
     resolvedPath?: string;
     props?: Record<string, any>;
+    typeName?: string;
+    members?: Record<string, string>;
 }
 
 export interface CommandRequest {

package/test-utils.ts

@@ -0,0 +1,64 @@
+import { jest } from '@jest/globals';
+
+let cachedDotnet: any = null;
+let isInitialized = false;
+
+export async function setupDotnet(): Promise<any> {
+  if (cachedDotnet && isInitialized) {
+    return cachedDotnet;
+  }
+
+  try {
+    cachedDotnet = await import('../src/index.js');
+    await cachedDotnet.node_ps1_dotnet._load('System');
+    isInitialized = true;
+    return cachedDotnet;
+  } catch (e) {
+    console.log('Failed to setup dotnet:', e);
+    return null;
+  }
+}
+
+export function teardownDotnet(dotnet: any): void {
+  try {
+    dotnet?.node_ps1_dotnet?._close();
+  } catch {}
+  isInitialized = false;
+  cachedDotnet = null;
+}
+
+export function skipIfNotWindows(): void {
+  if (process.platform !== 'win32') {
+    throw new Error('Skipped: Windows only test');
+  }
+}
+
+export function createDotnetTests(name: string, testFn: (dotnet: any, System: any) => void): void {
+  describe(name, () => {
+    let dotnet: any;
+    let System: any;
+
+    beforeAll(async () => {
+      dotnet = await setupDotnet();
+      if (dotnet) {
+        System = dotnet.System;
+      }
+    });
+
+    afterAll(() => {
+      teardownDotnet(dotnet);
+    });
+
+    if (process.platform !== 'win32') {
+      it('should skip on non-Windows', () => {
+        expect(true).toBe(true);
+      });
+    } else {
+      testFn(dotnet, System);
+    }
+  });
+}
+
+export function isWindows(): boolean {
+  return process.platform === 'win32';
+}

package/tsconfig.json

@@ -1,13 +1,21 @@
 {
   "compilerOptions": {
-    "module": "NodeNext",
-    "target": "esnext",
-    "moduleResolution": "nodenext",
-    "allowImportingTsExtensions": true,
-    "noEmit": true,
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022"],
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "declarationDir": "./types",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": false,
     "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": false,
+    "allowSyntheticDefaultImports": true
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/index.ts","./src/ipc.ts","./src/types.ts","./src/utils.ts"],"version":"5.9.3"}

package/types/index.d.ts

@@ -0,0 +1,17 @@
+export declare const __filename: string;
+export declare const __dirname: string;
+export declare const node_ps1_dotnet: {
+    _load(typeName: string): any;
+    _release(id: string): void;
+    _close(): void;
+    _getAssembly(assemblyName: string): any;
+    _loadAssembly(assemblyName: string): any;
+    _getRuntimeInfo(): {
+        frameworkMoniker: string;
+        runtimeVersion: string;
+    };
+};
+declare const dotnetProxy: any;
+export default dotnetProxy;
+export declare function getSystem(): any;
+export declare const System: any;

package/types/ipc.d.ts

@@ -0,0 +1,17 @@
+import type { ProtocolResponse, CommandRequest } from './types.ts';
+export declare class IpcSync {
+    private pipeName;
+    private onEvent;
+    fd: number;
+    private exited;
+    private readBuffer;
+    private resultBuffer;
+    private bufferOffset;
+    private bufferLength;
+    constructor(pipeName: string, onEvent: (msg: ProtocolResponse) => any);
+    private readLineSync;
+    private tryConnect;
+    connect(): void;
+    send(cmd: CommandRequest): ProtocolResponse;
+    close(): void;
+}

package/types/namespace.d.ts

@@ -0,0 +1,2 @@
+export declare function createNamespaceProxy(assemblyName: string, dotnet: any): any;
+export declare function createExportNamespaceProxy(namespacePrefix: string, dotnet: any): any;

package/types/proxy.d.ts

@@ -0,0 +1,16 @@
+export declare let node_ps1_dotnetGetter: (() => any) | null;
+export declare function setNodePs1Dotnet(fn: () => any): void;
+export declare function getNodePs1Dotnet(): any;
+export declare const callbackRegistry: Map<string, Function>;
+export declare const typeMetadataCache: Map<string, Map<string, string>>;
+export declare const globalTypeCache: Map<string, Map<string, string>>;
+export declare const pendingInspectRequests: Map<string, string[]>;
+export declare const pendingInspectTimeout: Map<string, NodeJS.Timeout>;
+export declare const typeNameCache: Map<string, string>;
+export declare const LARGE_ARRAY_THRESHOLD = 50;
+export declare function getObjectTypeName(id: string): string | null;
+export declare function getTypeMembers(typeName: string, memberNames: string[]): Map<string, string> | null;
+export declare function ensureMemberTypeCached(id: string, memberName: string, memberCache: Map<string, string>): void;
+export declare function createLazyArray(arr: any[]): any;
+export declare function createProxyWithInlineProps(meta: any): any;
+export declare function createProxy(meta: any): any;

package/types/state.d.ts

@@ -0,0 +1,16 @@
+import { IpcSync } from './ipc.js';
+import * as cp from 'node:child_process';
+export declare function getIpc(): IpcSync;
+export declare function getProc(): cp.ChildProcess;
+export declare function getInitialized(): boolean;
+export declare function getCachedRuntimeInfo(): {
+    frameworkMoniker: string;
+    runtimeVersion: string;
+};
+export declare function setIpc(val: IpcSync | null): void;
+export declare function setProc(val: cp.ChildProcess | null): void;
+export declare function setInitialized(val: boolean): void;
+export declare function setCachedRuntimeInfo(val: {
+    frameworkMoniker: string;
+    runtimeVersion: string;
+} | null): void;

package/types/types.d.ts

@@ -0,0 +1,21 @@
+export interface ProtocolResponse {
+    type: string;
+    value?: any;
+    id?: string;
+    message?: string;
+    args?: any[];
+    callbackId?: string;
+    memberType?: 'property' | 'method';
+    assemblyName?: string;
+    assemblyVersion?: string;
+    frameworkMoniker?: string;
+    runtimeVersion?: string;
+    resolvedPath?: string;
+    props?: Record<string, any>;
+    typeName?: string;
+    members?: Record<string, string>;
+}
+export interface CommandRequest {
+    action: string;
+    [key: string]: any;
+}

package/types/utils.d.ts

@@ -0,0 +1 @@
+export declare function getPowerShellPath(): string;