@arcticnotes/node-wsh 0.0.10 → 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

@@ -3,8 +3,8 @@ import PATH from 'node:path';
 import { Syncline} from "@arcticnotes/syncline";
 
 const COMMAND = 'cscript.exe';
-const ARGS = [ '//E:jscript', '//NoLogo'];
-const SCRIPT_FILE = PATH.join( PATH.dirname( import.meta.dirname), 'wsh', 'host.js');
+const ARGS = [ '//NoLogo'];
+const SCRIPT_FILE = PATH.join( PATH.dirname( import.meta.dirname), 'wsh', 'host.wsf');
 
 export class WindowsScriptingHost extends EventEmitter {
 
@@ -12,84 +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();
+	#ref2proxy = new Map(); // Map< string, WeakRef< Proxy | <custom-mapped>>>
+	#proxy2ref = new WeakMap(); // Map< Proxy | <custom-mapped>, string>
 
-	#objectHandler = {
-
-		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]}`);
-			}
-		},
-	};
-
-	#functionHandler = {
-
-		wsh: this,
-
-		get( target, prop) {
-			if( prop === Symbol.toPrimitive)
-				return () => `ref#${ target.ref}`;
-			return undefined;
-		},
-
-		apply( target, thisArg, argumentList) {
-			const encodedTarget = this.wsh.#encode( target.proxy);
-			const encodedThisArg = this.wsh.#encode( thisArg);
-			const encodedArgumentList = this.wsh.#encode( argumentList);
-			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, argumentList) {
-			const encodedTarget = this.wsh.#encode( target.proxy);
-			const encodedArgumentList = this.wsh.#encode( argumentList);
-			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]}`);
-			}
-		},
-	};
-
-	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() {
@@ -101,90 +41,21 @@ 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
 		}
 	}
 
 	async disconnect() {
+		this.#closed = true;
 		await this.#syncline.close();
 	}
 
-	#getOrCreateObject( ref) {
-		return this.#getOrCreate( ref, this.#objectHandler);
-	}
-
-	#getOrCreateFunction( ref) {
-		return this.#getOrCreate( ref, this.#functionHandler);
-	}
-
-	#getOrCreate( ref, handler) {
-		const existingWeakRef = this.#ref2proxy.get( ref);
-		const existingProxy = existingWeakRef && existingWeakRef.deref();
-		if( existingProxy)
-			return existingProxy;
-
-		const target = handler === this.#objectHandler? new RemoteObject( ref): new RemoteFunction( ref);
-		const newProxy = new Proxy( target, 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);
-		const output = 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( decoded instanceof Array) {
-					const encoded = [];
-					for( const item of decoded)
-						encoded.push( this.#encode( item));
-					return encoded;
-				}
-				if( decoded instanceof RemoteObject) {
-					const objref = this.#proxy2ref.get( decoded);
-					if( objref === undefined) // not because garbage-collected, because clearly `decoded` is still alive
-						throw new Error( `remote object reference not found: ${ decoded}`);
-					return { type: 'objref', value: objref};
-				}
-				const encoded = { type: 'object', value: {}};
-				for( const [ name, value] of Object.entries( decoded))
-					encoded.value[ name] = this.#encode( value);
-				return encoded;
-			case 'function':
-				const funref = this.#proxy2ref.get( decoded);
-				if( funref === undefined) // not because garbage-collected, because clearly `decoded` is still alive
-					throw new Error( `functions from node are disallowed: ${ decoded}`);
-				return { type: 'funref', value: funref};
-			case 'bigint':
-			case 'symbol':
-			default:
-				throw new Error( `unsupported value: ${ decoded}`);
-		}
-	}
-
-	#decode( encoded) {
+	#decode( encoded, mapper) {
 		switch( typeof encoded) {
 			case 'boolean':
 			case 'number':
@@ -193,10 +64,10 @@ export class WindowsScriptingHost extends EventEmitter {
 			case 'object':
 				if( encoded === null)
 					return encoded;
-				if( encoded instanceof Array) {
+				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) {
@@ -205,12 +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 'objref':
-						return this.#getOrCreateObject( encoded.value);
-					case 'funref':
-						return this.#getOrCreateFunction( encoded.value);
+					case 'ref':
+						return this.#getOrCreate( encoded.value, mapper);
 					default:
 						throw new Error( `illegal value: ${ encoded}`);
 				}
@@ -222,49 +91,147 @@ export class WindowsScriptingHost extends EventEmitter {
 				throw new Error( `illegal value: ${ encoded}`);
 		}
 	}
-}
-
-class RemoteObject {
 
-	#ref;
-	#proxy;
-
-	constructor( ref) {
-		this.#ref = 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;
+				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}`);
+		}
 	}
 
-	get ref() {
-		return this.#ref;
-	}
+	#getOrCreate( ref, mapper) {
+		const existingWeakRef = this.#ref2proxy.get( ref);
+		const existingProxy = existingWeakRef && existingWeakRef.deref();
+		if( existingProxy)
+			return existingProxy;
 
-	get proxy() {
-		return this.#proxy;
+		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;
 	}
 
-	set proxy( proxy) {
-		this.#proxy = proxy;
+	#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 RemoteFunction extends Function {
+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/lib/wsh/host.js

@@ -1,5 +1,13 @@
 // This file is in JScript, not in JavaScript. It is executed in Windows Scripting Host (WSH).
 
+function CreateVBArray( jsArray) {
+	var dict = new ActiveXObject( 'Scripting.Dictionary');
+	for( var i = 0; i < jsArray.length; i++)
+		dict.Add( i, jsArray[ i]);
+	dict.Add( 'length', jsArray.length);
+	return Dict2VBArray( dict);
+}
+
 var FSO = new ActiveXObject( 'Scripting.FileSystemObject');
 var OBJECT_TOSTRING = Object.toString();
 var GLOBAL = this;
@@ -34,21 +42,12 @@ function decode( encoded) {
 					for( i in encoded.value)
 						decoded[ i] = decode( encoded.value[ i]);
 					return decoded;
-				case 'objref':
-					item = REFERENCES[ encoded.value];
-					if( item === undefined)
-						throw new Error( 'reference not found: ' + encoded.value);
-					if( item.type !== 'obj')
-						throw new Error( 'reference type mismatch: ' + encoded.value);
-					return item.value;
-				case 'funref':
+				case 'ref':
 					item = REFERENCES[ encoded.value];
 					if( item === undefined)
 						throw new Error( 'reference not found: ' + encoded.value);
 					if( item.type === 'potential-method')
 						throw new Error( 'potentially a method, cannot be evaluated standalone: ' + encoded.value);
-					if( item.type !== 'fun')
-						throw new Error( 'reference type mismatch: ' + encoded.value);
 					return item.value;
 				default:
 					throw new Error( 'unknown object type: ' + encoded.type);
@@ -87,19 +86,15 @@ function encode( decoded) {
 					encoded.value[ i] = encode( decoded[ i]);
 				return encoded;
 			}
-			for( i in REFERENCES)
-				if( REFERENCES[ i].value === decoded)
-					return { type: 'objref', value: i};
-			i = '' + nextRefId++;
-			REFERENCES[ i] = { type: 'obj', value: decoded};
-			return { type: 'objref', value: i};
+		// warning: intentional fall-through here!
+		case 'unknown':
 		case 'function':
 			for( i in REFERENCES)
 				if( REFERENCES[ i].value === decoded)
-					return { type: 'funref', value: i};
+					return { type: 'ref', value: i};
 			i = '' + nextRefId++;
-			REFERENCES[ i] = { type: 'fun', value: decoded};
-			return { type: 'funref', value: i};
+			REFERENCES[ i] = { value: decoded};
+			return { type: 'ref', value: i};
 		case 'symbol':
 		case 'bigint':
 		default:
@@ -112,22 +107,22 @@ function encodePotentialMethod( target, prop) {
 	var item;
 	for( i in REFERENCES) {
 		item = REFERENCES[ i];
-		if( item.type === 'potential-method' && item.target === target, item.prop === prop)
-			return { type: 'funref', value: i};
+		if( item.type === 'potential-method' && item.target === target && item.prop === prop)
+			return { type: 'ref', value: i};
 	}
 	i = '' + nextRefId++;
 	REFERENCES[ i] = { type: 'potential-method', target: target, prop: prop};
-	return { type: 'funref', value: i};
+	return { type: 'ref', value: i};
 }
 
 function decodePotentialMethod( encoded) {
 	var item;
-	if( typeof encoded === 'object' && encoded.type === 'funref') {
+	if( typeof encoded === 'object' && encoded.type === 'ref') {
 		item = REFERENCES[ encoded.value];
 		if( item.type === 'potential-method')
-			return { 'potential-method': true, target: item.target, prop: item.prop};
+			return item;
 	}
-	return { 'potential-method': false, value: decode( encoded)}
+	return { type: 'regular', value: decode( encoded)};
 }
 
 ( function() {
@@ -174,11 +169,11 @@ function decodePotentialMethod( encoded) {
 					target = decodePotentialMethod( input[ 1]);
 					thisArg = decode( input[ 2]);
 					args = decode( input[ 3]);
-					if( target[ 'potential-method']) {
+					if( target.type === 'potential-method') {
 						if( thisArg === undefined)
-							throw new Error( 'potentially a method, can only be used as such');
+							throw new Error( 'potentially a method, use with a "this"');
 						if( thisArg !== target.target)
-							throw new Error( 'potentially a method, can only be used as such');
+							throw new Error( 'potentially a method, "this" has changed');
 						switch( args.length) {
 							case 0: output = [ 'value', encode( target.target[ target.prop]())]; break;
 							case 1: output = [ 'value', encode( target.target[ target.prop]( args[ 0]))]; break;

package/lib/wsh/host.vbs

@@ -0,0 +1,9 @@
+Function Dict2VBArray( dict)
+	Dim vbArray()
+	ReDim vbArray( dict.Item( "length") - 1)
+	Dim I
+	For I = 0 To dict.Item( "length") - 1
+		vbArray( I) = dict.Item( I)
+	Next
+	Dict2VBArray = vbArray
+End Function

package/lib/wsh/host.wsf

@@ -0,0 +1,4 @@
+<job>
+	<script language="VBScript" src="host.vbs" />
+	<script language="JScript" src="host.js" />
+</job>

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@arcticnotes/node-wsh",
-	"version": "0.0.10",
+	"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/"