@arcticnotes/node-wsh 0.0.11 → 0.0.12

package/lib/index.js

@@ -1 +1,2 @@
 export { WindowsScriptingHost} from './node/node-wsh.js';
+export { Collection} from './node/utils.js';

package/lib/node/node-wsh.js

@@ -12,73 +12,24 @@ export class WindowsScriptingHost extends EventEmitter {
 		const command = options.command || COMMAND;
 		const args = options.args || ARGS;
 		const scriptFile = options.scriptFile || SCRIPT_FILE;
-		const trace = options.trace || 0;
-		return new WindowsScriptingHost( await Syncline.spawn( command, [ ...args, scriptFile], { trace}));
+		return new WindowsScriptingHost( await Syncline.spawn( command, [ ...args, scriptFile], options.syncline), options);
 	}
 
 	#syncline;
 	#closed = false;
 	#finalizer = new FinalizationRegistry( this.#finalized.bind( this));
-	#ref2proxy = new Map();
-	#proxy2ref = new WeakMap();
-	#handler = {
-
-		wsh: this,
-	
-		get( target, prop) {
-			if( prop === Symbol.toPrimitive)
-				return () => `ref#${ target.ref}`;
-			const encodedTarget = this.wsh.#encode( target.proxy);
-			const encodedProp = this.wsh.#encode( prop);
-			const output = JSON.parse( this.wsh.#syncline.exchange( JSON.stringify( [ 'get', encodedTarget, encodedProp])));
-			switch( output[ 0]) {
-				case 'value': return this.wsh.#decode( output[ 1]);
-				case 'error': throw new Error( output[ 1]);
-				default: throw new Error( `unknown status: ${ output[ 0]}`);
-			}
-		},
-
-		set( target, prop, value) {
-			const encodedTarget = this.wsh.#encode( target.proxy);
-			const encodedProp = this.wsh.#encode( prop);
-			const encodedValue = this.wsh.#encode( value);
-			const output = JSON.parse( this.wsh.#syncline.exchange( JSON.stringify( [ 'set', encodedTarget, encodedProp, encodedValue])));
-			switch( output[ 0]) {
-				case 'set': return;
-				case 'error': throw new Error( output[ 1]);
-				default: throw new Error( `unknown status: ${ output[ 0]}`);
-			}
-		},
-
-		apply( target, thisArg, argumentsList) {
-			const encodedTarget = this.wsh.#encode( target.proxy);
-			const encodedThisArg = this.wsh.#encode( thisArg);
-			const encodedArgumentList = this.wsh.#encode( [ ...argumentsList]); // argumentsList may not be instanceof Array
-			const output = JSON.parse( this.wsh.#syncline.exchange( JSON.stringify( [ 'apply', encodedTarget, encodedThisArg, encodedArgumentList])));
-			switch( output[ 0]) {
-				case 'value': return this.wsh.#decode( output[ 1]);
-				case 'error': throw new Error( output[ 1]);
-				default: throw new Error( `unknown status: ${ output[ 0]}`);
-			}
-		},
-
-		construct( target, argumentsList) {
-			const encodedTarget = this.wsh.#encode( target.proxy);
-			const encodedArgumentList = this.wsh.#encode( [ ...argumentsList]); // argumentsList may not be instanceof Array
-			const output = JSON.parse( this.wsh.#syncline.exchange( JSON.stringify( [ 'construct', encodedTarget, encodedArgumentList])));
-			switch( output[ 0]) {
-				case 'value': return this.wsh.#decode( output[ 1]);
-				case 'error': throw new Error( output[ 1]);
-				default: throw new Error( `unknown status: ${ output[ 0]}`);
-			}
-		},
-	};
+	#ref2proxy = new Map(); // Map< string, WeakRef< Proxy | <custom-mapped>>>
+	#proxy2ref = new WeakMap(); // Map< Proxy | <custom-mapped>, string>
 
-	constructor( syncline) {
+	constructor( syncline, options) {
 		super();
 		this.#syncline = syncline;
-		this.#syncline.on( 'stderr', line => console.log( 'wsh:', line));
-		this.#syncline.on( 'stdout', line => console.log( 'wsh:', line));
+		this.#syncline.on( 'stderr', line => console.log( 'wsh-stderr:', line));
+		this.#syncline.on( 'stdout', line => console.log( 'wsh-stdout:', line));
+		if( options.printSynclineIO) {
+			this.#syncline.on( 'input', line => console.log( 'syncline-input:', line));
+			this.#syncline.on( 'output', line => console.log( 'syncline-output', line));
+		}
 	}
 
 	get remoteObjects() {
@@ -90,12 +41,12 @@ export class WindowsScriptingHost extends EventEmitter {
 		};
 	}
 
-	global( name) {
+	global( name, mapper = undefined) {
 		const output = JSON.parse( this.#syncline.exchange( JSON.stringify( [ 'global', name])));
 		switch( output[ 0]) {
-			case 'value': return this.#decode( output[ 1]);
+			case 'value': return this.#decode( output[ 1], mapper);
 			case 'error': throw new Error( output[ 1]);
-			default: throw new Error( `unknown status: ${ output[ 0]}`);
+			default: throw new Error( `unknown status: ${ output[ 0]}`); // bug
 		}
 	}
 
@@ -104,67 +55,7 @@ export class WindowsScriptingHost extends EventEmitter {
 		await this.#syncline.close();
 	}
 
-	#getOrCreate( ref) {
-		const existingWeakRef = this.#ref2proxy.get( ref);
-		const existingProxy = existingWeakRef && existingWeakRef.deref();
-		if( existingProxy)
-			return existingProxy;
-
-		const target = new RemoteObject( ref);
-		const newProxy = new Proxy( target, this.#handler);
-		target.proxy = newProxy;
-		this.#ref2proxy.set( ref, new WeakRef( newProxy)); // may be overwriting a dead WeakRef
-		this.#proxy2ref.set( newProxy, ref);
-		this.#finalizer.register( newProxy, ref);
-		this.emit( 'ref', ref, newProxy);
-		return newProxy;
-	}
-
-	#finalized( ref) {
-		if( this.#ref2proxy.get( ref).deref() === undefined) // otherwise, it's overwritten by a refreshed proxy
-			this.#ref2proxy.delete( ref);
-		if( !this.#closed)
-			this.#syncline.exchange( JSON.stringify( [ 'unref', ref]));
-		this.emit( 'unref', ref);
-	}
-
-	#encode( decoded) {
-		switch( typeof decoded) {
-			case 'boolean':
-			case 'number':
-			case 'string':
-				return decoded;
-			case 'undefined':
-				return { type: 'undefined'};
-			case 'object':
-				if( decoded === null)
-					return decoded;
-				if( Array.isArray( decoded)) {
-					const encoded = [];
-					for( const item of decoded)
-						encoded.push( this.#encode( item));
-					return encoded;
-				}
-				const encoded = { type: 'object', value: {}};
-				for( const [ name, value] of Object.entries( decoded))
-					encoded.value[ name] = this.#encode( value);
-				return encoded;
-			case 'function':
-				if( decoded instanceof RemoteObject) {
-					const ref = this.#proxy2ref.get( decoded);
-					if( ref === undefined) // not because garbage-collected, because clearly `decoded` is still alive
-						throw new Error( `remote object reference not found: ${ decoded}`);
-					return { type: 'ref', value: ref};
-				}
-				throw new Error( `functions from node cannot be sent: ${ decoded}`);
-			case 'bigint':
-			case 'symbol':
-			default:
-				throw new Error( `unsupported value: ${ decoded}`);
-		}
-	}
-
-	#decode( encoded) {
+	#decode( encoded, mapper) {
 		switch( typeof encoded) {
 			case 'boolean':
 			case 'number':
@@ -176,7 +67,7 @@ export class WindowsScriptingHost extends EventEmitter {
 				if( Array.isArray( encoded)) {
 					const decoded = [];
 					for( const item of encoded)
-						decoded.push( this.#decode( item));
+						decoded.push( this.#decode( item, mapper));
 					return decoded;
 				}
 				switch( encoded.type) {
@@ -185,10 +76,10 @@ export class WindowsScriptingHost extends EventEmitter {
 					case 'object':
 						const decoded = {};
 						for( const [ name, value] of Object.entries( encoded.value))
-							decoded[ name] = this.#decode( value);
+							decoded[ name] = this.#decode( value, mapper);
 						return decoded;
 					case 'ref':
-						return this.#getOrCreate( encoded.value);
+						return this.#getOrCreate( encoded.value, mapper);
 					default:
 						throw new Error( `illegal value: ${ encoded}`);
 				}
@@ -200,27 +91,147 @@ export class WindowsScriptingHost extends EventEmitter {
 				throw new Error( `illegal value: ${ encoded}`);
 		}
 	}
+
+	#encode( decoded) {
+		switch( typeof decoded) {
+			case 'boolean':
+			case 'number':
+			case 'string':
+				return decoded;
+			case 'undefined':
+				return { type: 'undefined'};
+			case 'object': {
+				if( decoded === null)
+					return decoded;
+				const ref = this.#proxy2ref.get( decoded);
+				if( ref !== undefined)
+					return { type: 'ref', value: ref};
+				if( Array.isArray( decoded)) {
+					const encoded = [];
+					for( const item of decoded)
+						encoded.push( this.#encode( item));
+					return encoded;
+				}
+				const encoded = { type: 'object', value: {}};
+				for( const [ name, value] of Object.entries( decoded))
+					encoded.value[ name] = this.#encode( value);
+				return encoded;
+			}
+			case 'function': {
+				const ref = this.#proxy2ref.get( decoded);
+				if( ref !== undefined)
+					return { type: 'ref', value: ref};
+				throw new Error( `functions from node cannot be sent: ${ decoded}`);
+			}
+			case 'bigint':
+			case 'symbol':
+			default:
+				throw new Error( `unsupported value: ${ decoded}`);
+		}
+	}
+
+	#getOrCreate( ref, mapper) {
+		const existingWeakRef = this.#ref2proxy.get( ref);
+		const existingProxy = existingWeakRef && existingWeakRef.deref();
+		if( existingProxy)
+			return existingProxy;
+
+		const newProxy = new RemoteObject( this.#syncline, this.#encode.bind( this), this.#decode.bind( this), ref, mapper).proxy;
+		if( this.#proxy2ref.has( newProxy)) // sanity check, doesn't catch all misbehaving mappers
+			throw new Error( `mapper must return new objects: ${ newProxy}`);
+		this.#ref2proxy.set( ref, new WeakRef( newProxy)); // may be overwriting a dead WeakRef
+		this.#proxy2ref.set( newProxy, ref);
+		this.#finalizer.register( newProxy, ref);
+		this.emit( 'ref', ref, newProxy);
+		return newProxy;
+	}
+
+	#finalized( ref) {
+		if( this.#ref2proxy.get( ref).deref() === undefined) // otherwise, it's overwritten by a refreshed proxy
+			this.#ref2proxy.delete( ref);
+		if( !this.#closed)
+			this.#syncline.exchange( JSON.stringify( [ 'unref', ref]));
+		this.emit( 'unref', ref);
+	}
 }
 
 class RemoteObject extends Function {
 
+	static #handler = {
+		get: ( ticket, prop) => ticket.get( prop, undefined),
+		set: ( ticket, prop, value) => ticket.set( prop, value),
+		apply: ( ticket, thisArg, argumentsList) => ticket.apply( thisArg, argumentsList, undefined),
+		construct: ( ticket, argumentsList) => ticket.construct( argumentsList, undefined),
+	};
+
+	#syncline;
+	#encode;
+	#decode;
 	#ref;
 	#proxy;
 
-	constructor( ref) {
+	constructor( syncline, encode, decode, ref, mapper) {
 		super();
+		this.#syncline = syncline;
+		this.#encode = encode;
+		this.#decode = decode;
 		this.#ref = ref;
-	}
-
-	get ref() {
-		return this.#ref;
+		this.#proxy = mapper? mapper( this): this.newProxy();
 	}
 
 	get proxy() {
 		return this.#proxy;
 	}
 
-	set proxy( proxy) {
-		this.#proxy = proxy;
+	newProxy() {
+		return new Proxy( this, RemoteObject.#handler);
+	}
+
+	get( prop, mapper) {
+		if( prop === Symbol.toPrimitive)
+			return () => `ref#${ this.#ref}`; 
+		const encodedTarget = this.#encode( this.#proxy);
+		const encodedProp = this.#encode( prop);
+		const output = JSON.parse( this.#syncline.exchange( JSON.stringify( [ 'get', encodedTarget, encodedProp])));
+		switch( output[ 0]) {
+			case 'value': return this.#decode( output[ 1], mapper);
+			case 'error': throw new Error( output[ 1]);
+			default: throw new Error( `unknown status: ${ output[ 0]}`);
+		}
+	}
+
+	set( prop, value) {
+		const encodedTarget = this.#encode( this.#proxy);
+		const encodedProp = this.#encode( prop);
+		const encodedValue = this.#encode( value);
+		const output = JSON.parse( this.#syncline.exchange( JSON.stringify( [ 'set', encodedTarget, encodedProp, encodedValue])));
+		switch( output[ 0]) {
+			case 'set': return true;
+			case 'error': throw new Error( output[ 1]);
+			default: throw new Error( `unknown status: ${ output[ 0]}`);
+		}
+	}
+
+	apply( thisArg, argumentsList, mapper) {
+		const encodedTarget = this.#encode( this.#proxy);
+		const encodedThisArg = this.#encode( thisArg);
+		const encodedArgumentList = this.#encode( [ ...argumentsList]); // argumentsList may not be instanceof Array
+		const output = JSON.parse( this.#syncline.exchange( JSON.stringify( [ 'apply', encodedTarget, encodedThisArg, encodedArgumentList])));
+		switch( output[ 0]) {
+			case 'value': return this.#decode( output[ 1], mapper);
+			case 'error': throw new Error( output[ 1]);
+			default: throw new Error( `unknown status: ${ output[ 0]}`);
+		}
+	}
+
+	construct( argumentsList, mapper) {
+		const encodedTarget = this.#encode( this.#proxy);
+		const encodedArgumentList = this.#encode( [ ...argumentsList]); // argumentsList may not be instanceof Array
+		const output = JSON.parse( this.#syncline.exchange( JSON.stringify( [ 'construct', encodedTarget, encodedArgumentList])));
+		switch( output[ 0]) {
+			case 'value': return this.#decode( output[ 1], mapper);
+			case 'error': throw new Error( output[ 1]);
+			default: throw new Error( `unknown status: ${ output[ 0]}`);
+		}
 	}
 }

package/lib/node/utils.js

@@ -0,0 +1,24 @@
+export class Collection {
+
+	#ticket;
+	#type;
+
+	constructor( ticket, type) {
+		this.#ticket = ticket;
+		this.#type = type;
+	}
+
+	get length() {
+		return this.#ticket.get( 'Count');
+	}
+
+	get( indexBase0) {
+		return this.#ticket.get( 'Item', t2 => t2.apply.bind( t2))( this, [ indexBase0 + 1], t3 => new this.#type( t3));
+	}
+
+	*[ Symbol.iterator]() {
+		const length = this.length; // expect anomoly if the underlying collect is changing
+		for( let i = 0; i < length; i++)
+			yield this.get( i);
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@arcticnotes/node-wsh",
-	"version": "0.0.11",
+	"version": "0.0.12",
 	"description": "A Node.js package that runs Windows Scripting Host (WSH) as a child process and exposes the resources from the WSH world to the Node.js world",
 	"author": "Paul <paul@arcticnotes.com>",
 	"license": "MIT",
@@ -21,7 +21,7 @@
 		".": "./lib/index.js"
 	},
 	"dependencies": {
-		"@arcticnotes/syncline": "0.0.3"
+		"@arcticnotes/syncline": "0.0.4"
 	},
 	"files": [
 		"/lib/"