zuzu-js 0.4.0 → 0.6.0

package/lib/browser-bundle-entry.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { createBrowserRuntime } = require( './browser-runtime' );
+const { addBrowserModule } = require( './host/browser-host' );
 const {
 	createBrowserGuiBridge,
 	createBrowserGuiRenderer,
@@ -147,6 +148,7 @@ if (
 }
 
 module.exports = {
+	addModule: addBrowserModule,
 	createBrowserRuntime: createConfiguredBrowserRuntime,
 	createBrowserGuiBridge,
 	createBrowserGuiRenderer,

package/lib/cli.js

@@ -254,7 +254,7 @@ function stripShebang( source ) {
 }
 
 function printVersion( runtime, verbose ) {
-	process.stdout.write( 'zuzu-js version 0.4.0\n' );
+	process.stdout.write( 'zuzu-js version 0.6.0\n' );
 	if ( verbose ) {
 		process.stdout.write( '\nlib search paths:\n' );
 		for ( const p of runtime.getModuleSearchRoots() ) {

package/lib/collections.js

@@ -24,6 +24,10 @@ function makeSet( values ) {
 	return runtimeHelpers().makeSet( values );
 }
 
+function operatorString( value ) {
+	return runtimeHelpers().operatorString( value );
+}
+
 function stringSortComparator( a, b ) {
 	return runtimeHelpers().stringSortComparator( a, b );
 }
@@ -68,7 +72,15 @@ class ZuzuBag {
 		return this;
 	}
 	push( ...values ) { return this.add( ...values ); }
-	remove( value ) { return this.remove_first( value ); }
+	remove( value ) {
+		for ( let idx = this.items.length - 1; idx >= 0; idx-- ) {
+			if ( this.items[idx] === value ) {
+				releaseCollectionValue( this, this.items[idx] );
+				this.items.splice( idx, 1 );
+			}
+		}
+		return this;
+	}
 	remove_first( value ) {
 		const idx = this.items.indexOf( value );
 		if ( idx >= 0 ) {
@@ -87,7 +99,6 @@ class ZuzuBag {
 		} );
 		return this;
 	}
-	get( idx, fallback = null ) { return idx >= 0 && idx < this.items.length ? this.items[idx] : fallback; }
 	map( fn ) { return new ZuzuBag( this.items.map( fn ) ); }
 	grep( fn ) { return new ZuzuBag( this.items.filter( fn ) ); }
 	any( fn ) { return this.items.some( fn ) ? 1 : 0; }
@@ -193,6 +204,7 @@ class PairList {
 	length() { return this.list.length; }
 	count() { return this.list.length; }
 	empty() { return this.list.length === 0 ? 1 : 0; }
+	is_empty() { return this.empty(); }
 	keys() { return this.list.map( (pair) => pair[0] ); }
 	values() { return this.list.map( (pair) => pair[1] ); }
 	enumerate() { return this.to_Array(); }
@@ -279,6 +291,7 @@ Object.defineProperty( PairList.prototype, '__zuzu_builtin_type', {
 });
 
 function withArrayMethods() {
+	const nativeJoin = Array.prototype.join;
 	const define = ( name, fn ) => {
 		if ( !Object.prototype.hasOwnProperty.call( Array.prototype, name ) ) {
 			const desc = Object.create( null );
@@ -287,6 +300,40 @@ function withArrayMethods() {
 			Object.defineProperty( Array.prototype, name, desc );
 		}
 	};
+	if ( Array.prototype.join.__zuzu_array_join !== true ) {
+		const desc = Object.create( null );
+		desc.value = function _join( separator, fallback ) {
+			const hasFallback = arguments.length > 1;
+			let fallbackString;
+			const sep = operatorString( separator );
+			const out = [];
+			for ( const value of this ) {
+				try {
+					out.push( operatorString( value ) );
+				}
+				catch ( err ) {
+					if ( !hasFallback ) {
+						throw err;
+					}
+					if ( typeof fallback === 'function' ) {
+						out.push( operatorString( fallback( value ) ) );
+					}
+					else {
+						if ( fallbackString === undefined ) {
+							fallbackString = operatorString( fallback );
+						}
+						out.push( fallbackString );
+					}
+				}
+			}
+			return nativeJoin.call( out, sep );
+		};
+		desc.value.__zuzu_array_join = true;
+		desc.enumerable = false;
+		desc.configurable = true;
+		desc.writable = true;
+		Object.defineProperty( Array.prototype, 'join', desc );
+	}
 	define( 'count', function _count() { return this.length; } );
 	define( 'empty', function _empty() { return this.length === 0 ? 1 : 0; } );
 	define( 'is_empty', function _is_empty() { return this.empty(); } );

package/lib/host/browser-host.js

@@ -48,6 +48,43 @@ function _sourceUrlComment( runOptions = {} ) {
 	return `\n//# sourceURL=${filename.replace( /[\r\n]/gu, '_' )}`;
 }
 
+const browserModuleUrls = new Map();
+
+function _normalizeModuleName( value ) {
+	const name = String( value ?? '' ).trim().replace( /\\/gu, '/' );
+	if (
+		name === ''
+		|| name.startsWith( '/' )
+		|| name.endsWith( '/' )
+		|| /(^|\/)\.\.?(\/|$)/u.test( name )
+	) {
+		throw new Error( `Invalid browser module name: ${value}` );
+	}
+	return name.replace( /\.zzm$/u, '' );
+}
+
+function _moduleNameFromPath( filename ) {
+	const path = _resolvePath( filename );
+	if ( !path.startsWith( '/modules/' ) || !path.endsWith( '.zzm' ) ) {
+		return null;
+	}
+	return path.slice( '/modules/'.length, -'.zzm'.length );
+}
+
+function addBrowserModule( moduleName, url ) {
+	const logicalName = _normalizeModuleName( moduleName );
+	const moduleUrl = String( url ?? '' ).trim();
+	if ( moduleUrl === '' ) {
+		throw new Error( `Invalid URL for browser module '${logicalName}'` );
+	}
+	browserModuleUrls.set( logicalName, moduleUrl );
+	return logicalName;
+}
+
+function hasBrowserModules() {
+	return browserModuleUrls.size > 0;
+}
+
 function _browserEval( source, context, runOptions = {} ) {
 	context.globalThis = context;
 	const sourceUrl = _sourceUrlComment( runOptions );
@@ -153,6 +190,18 @@ function createBrowserHost( options = {} ) {
 	const jsModules = new Map( Object.entries( options.jsModules || {} )
 		.map( ( [ filename, loaded ] ) => [ _resolvePath( filename ), loaded ] ) );
 	const fetchedFiles = new Map();
+	const fetchingFiles = new Map();
+	const optionModuleUrls = new Map(
+		Object.entries( options.remoteModules || {} )
+			.map( ( [ name, url ] ) => [ _normalizeModuleName( name ), String( url ) ] )
+	);
+	const fetchText = typeof options.fetch === 'function'
+		? options.fetch
+		: (
+			typeof fetch === 'function'
+				? fetch
+				: null
+		);
 	const fetchModule = typeof options.fetchModule === 'function'
 		? options.fetchModule
 		: null;
@@ -193,6 +242,58 @@ function createBrowserHost( options = {} ) {
 		capabilities.add( 'worker' );
 	}
 	const gui = _defaultGuiBridge( options );
+	function browserModuleUrlForPath( filename ) {
+		const logicalName = _moduleNameFromPath( filename );
+		if ( !logicalName ) {
+			return null;
+		}
+		if ( optionModuleUrls.has( logicalName ) ) {
+			return optionModuleUrls.get( logicalName );
+		}
+		return browserModuleUrls.get( logicalName ) || null;
+	}
+	function hasAsyncModules() {
+		return optionModuleUrls.size > 0 || browserModuleUrls.size > 0;
+	}
+	async function fetchBrowserModule( key, url ) {
+		if ( fetchedFiles.has( key ) ) {
+			return fetchedFiles.get( key );
+		}
+		if ( fetchingFiles.has( key ) ) {
+			return fetchingFiles.get( key );
+		}
+		if ( !fetchText ) {
+			throw new Error( `Exception: Browser host cannot fetch module '${key}'` );
+		}
+		const pending = Promise.resolve( fetchText( url ) )
+			.then( async (response) => {
+				if ( typeof response === 'string' ) {
+					return response;
+				}
+				if ( response && response.ok === false ) {
+					throw new Error(
+						`Exception: Fetch failed for browser module '${key}' (${response.status})`
+					);
+				}
+				if ( !response || typeof response.text !== 'function' ) {
+					throw new Error(
+						`Exception: Fetch did not return text for browser module '${key}'`
+					);
+				}
+				return response.text();
+			} )
+			.then( (source) => {
+				const text = String( source );
+				fetchedFiles.set( key, text );
+				fetchingFiles.delete( key );
+				return text;
+			}, (err) => {
+				fetchingFiles.delete( key );
+				throw err;
+			} );
+		fetchingFiles.set( key, pending );
+		return pending;
+	}
 	return {
 		name: 'browser',
 		repoRoot,
@@ -229,13 +330,33 @@ function createBrowserHost( options = {} ) {
 					return fetched;
 				}
 			}
+			if ( browserModuleUrlForPath( key ) ) {
+				throw new Error( `Exception: Browser module '${filename}' requires asynchronous loading` );
+			}
 			throw new Error( `Exception: Browser host cannot read file '${filename}'` );
 		},
+		async readFileTextAsync( filename ) {
+			const key = _resolvePath( filename );
+			if ( virtualFiles.has( key ) ) {
+				return virtualFiles.get( key );
+			}
+			if ( fetchedFiles.has( key ) ) {
+				return fetchedFiles.get( key );
+			}
+			const browserModuleUrl = browserModuleUrlForPath( key );
+			if ( browserModuleUrl ) {
+				return fetchBrowserModule( key, browserModuleUrl );
+			}
+			return this.readFileText( key );
+		},
 		fileExists( filename ) {
 			const key = _resolvePath( filename );
 			if ( virtualFiles.has( key ) || jsModules.has( key ) || fetchedFiles.has( key ) ) {
 				return true;
 			}
+			if ( browserModuleUrlForPath( key ) ) {
+				return true;
+			}
 			if ( fetchModule ) {
 				const fetched = fetchModule( key );
 				if ( typeof fetched === 'string' ) {
@@ -270,9 +391,12 @@ function createBrowserHost( options = {} ) {
 			}
 			return jsModules.get( key );
 		},
+		hasAsyncModules,
 	};
 }
 
 module.exports = {
+	addBrowserModule,
 	createBrowserHost,
+	hasBrowserModules,
 };

package/lib/runtime-helpers.js

@@ -143,6 +143,15 @@ function retainValue( value ) {
 	return resolved;
 }
 
+function strongReferenceCount( value ) {
+	const resolved = resolveWeakValue( value );
+	if ( !isWeakableValue( resolved ) ) {
+		return 0;
+	}
+	const state = weakStates.get( resolved );
+	return state ? state.strong : 0;
+}
+
 function retainedValuesForCollection( collection, create = false ) {
 	const resolved = resolveWeakValue( collection );
 	if ( !isWeakableValue( resolved ) ) {
@@ -198,7 +207,7 @@ function releaseCollectionValues( collection ) {
 	return null;
 }
 
-function releaseValue( value ) {
+function releaseValue( value, options = {} ) {
 	if ( isWeakCell( value ) ) {
 		return null;
 	}
@@ -209,7 +218,15 @@ function releaseValue( value ) {
 			const wasStrong = state.strong;
 			state.strong = Math.max( 0, state.strong - 1 );
 			if ( wasStrong > 0 && state.strong === 0 ) {
-				releaseCollectionValues( resolved );
+				if ( !options.preserveCollectionValues ) {
+					releaseCollectionValues( resolved );
+				}
+				if (
+					!options.suppressDemolish
+					&& typeof resolved.__demolish__ === 'function'
+				) {
+					resolved.__demolish__();
+				}
 			}
 		}
 	}
@@ -571,6 +588,9 @@ function buildComparator( name ) {
 	if ( name === 'eq' ) {
 		return ( left, right ) => String( left ) === String( right );
 	}
+	if ( name === 'eqi' ) {
+		return ( left, right ) => String( left ).toLowerCase() === String( right ).toLowerCase();
+	}
 	if ( name === '~' ) {
 		return ( left, right ) => {
 			if ( right && typeof right.test === 'function' ) {
@@ -582,11 +602,21 @@ function buildComparator( name ) {
 	return ( left, right ) => left == right;
 }
 
+function switchTruthy( value ) {
+	return !!value;
+}
+
 function runSwitch( value, cmpName, cases, defaultBody ) {
 	const cmp = buildComparator( cmpName );
 	let runNext = false;
 	for ( const section of cases ) {
-		const matched = section.values.some( (item) => cmp( value, item ) );
+		let matched = false;
+		if ( Array.isArray( section.tests ) ) {
+			matched = section.tests.some( (test) => switchTruthy( test( value ) ) );
+		}
+		else {
+			matched = section.values.some( (item) => cmp( value, item ) );
+		}
 		if ( matched || runNext ) {
 			const result = section.body();
 			runNext = result === true;
@@ -961,6 +991,7 @@ module.exports = {
 	resolveWeakValue,
 	retainValue,
 	releaseValue,
+	strongReferenceCount,
 	retainCollectionValue,
 	releaseCollectionValue,
 	releaseCollectionValues,