@polylith/builder 0.0.37 → 0.0.39

package/App.js

@@ -7,33 +7,18 @@ import * as resolve from '@rollup/plugin-node-resolve';
 import commonjs from '@rollup/plugin-commonjs';
 import html from 'rollup-plugin-html';
 import livereload from 'rollup-plugin-livereload';
+import styles from "rollup-plugin-styles";
 
 import loader from './plugin-loader.js';
 import mainHTML from './plugin-main-html.js';
 import features from './plugin-features.js';
-import styles from "rollup-plugin-styles";
 import resources from "./plugin-copy-resources.js";
 import jsconfig from "./plugin-jsconfig.js";
 
+import {forceToPosix, fileExists} from './utils.js'
 import ConfigFeature from './ConfigFeature.js';
 import Files from './Files.js';
 
-/**
- * call this function to check if the given file exists
- *
- * @param {String} path the name of the file
- * @returns {Promise<Boolean>} true if the file exists
- */
-
-async function fileExists(path) {
-    try {
-        await stat(path)
-        return true;
-    } catch (e) {
-        return false;
-    }
-}
-
 /**
  * The base class for applications. Applications inherit from this class
  */
@@ -42,16 +27,15 @@ export default class App {
 	 * Construct the app object.
 	 *
 	 * @param {String} name a name for the app
-	 * @param {String} root the root directory of the project. All other
-	 *  	paths will be relative to this path.
+	 * @param {String} root the full path to the root directory of the project.
+	 * 		All other paths will be relative to this path.
 	 * @param {String} index the relative path to the main source file from the
 	 * 		root. All source paths will be assumed to be relative to this path.
 	 * @param {String} dest the relative path to the destination folder from the
 	 * 		root for rolled up files
 	 */
-
 	constructor(name, root, index, dest) {
-		root = App.fixPath(root);
+		root = forceToPosix(root);
 		this.root = root;
 
 		var filename = path.posix.join(root, index);
@@ -69,30 +53,62 @@ export default class App {
 		this.manualChunkType = 'function';
 		this.manualChunks = [];
 		this.files = new Files(this.sourcePath, this.destPath);
+		this.cssSpecs = [];
 		this.cssFiles = [];
 		this.liveReload = true;
+		this.templateVariables = {};
+		this.ns = name.toUpperCase();
+		this.ns = this.ns.replace(/[- ]*?/g, '_');
+		this.codeVariables = {};
 	}
 
-	static fileToPath(filename) {
-		filename = App.fixPath(filename);
-		return path.posix.dirname(filename);
+	/**
+	 * Call this method to set the code variable name space. An object with this
+	 * name will be attached to the window object with the code variables as
+	 * members. The default value for the name space is the app name in upper
+	 * snake case.
+	 *
+	 * @param {String} ns the name space name for added code variables. This
+	 * 		must be a valid JavaScript identifier.
+	 */
+	setNamespace(ns) {
+		this.ns = ns;
 	}
 
 	/**
-	 * call this method to force the file path to use posix notation and remove
-	 * all drive information.
+	 * Call this method to add a code variable to the output html file. This
+	 * variable will be added the namsespace for the app.
 	 *
+	 * @param {String} name the name of tyhe variable. This must be a valid
+	 * 		JavaScript identifier.
+	 * @param {*} value the value of the variable to set. This can be any type
+	 * 		that can be serialized through JSON.
+	 */
+	 addCodeVariable(name, value) {
+		this.codeVariables[name] = value;
+	}
+
+	/**
+	 * Call this method to get the replacement value for ${codeVariables}. This
+	 * will be the code that adds all the codeVariables to the namespace.
 	 *
-	 * @param {String} src the filename wqe
-	 * @returns {String} the new path
+	 * @returns {String} the replacement value for the codeVariables template
+	* 		variable;
 	 */
-	static fixPath(src) {
-		src = src.replace('file:', '');
-		src = src.replace('///', '');
-		src = src.replace(/.:/, '');
-		src = src.replace(/\\/g, '/');
+	getCodeVariablesValue() {
+		var names = Object.keys(this.codeVariables);
+		if (names.length === 0) return '';
+
+		var members = names.map(function(name) {
+			return `			${name}: ${JSON.stringify(this.codeVariables[name])},`
+		}, this);
 
-		return src;
+		var codeBlock =
+`		${this.ns} = {
+${members.join('\n')}
+		}
+`;
+		return codeBlock;
 	}
 
 	/**
@@ -109,23 +125,67 @@ export default class App {
 		return './' + path;
 	}
 
+	/**
+	 * Call this method with true to reload the browser when any files in the
+	 * destination folder have changed.
+	 *
+	 * @param {Bollean} on set to true to turn on destination watching
+	 */
 	setLiveReload(on) {
 		this.liveReload = on;
 	}
+
+	/**
+	 * Call this method to set the template for the main application html. This
+	 * template file must have the required replacement strings for basic
+	 * functionality. Call setTemplateVariable to create application specific
+	 * repalcement values.
+	 *
+	 * @param {String} source the relative path from the application root to the
+	 * 		html template
+	 * @param {String} destination the relative path to the destination file
+	 */
 	setHtmlTemplate(source, destination) {
 		this.htmlTemplate = {source: source, destination: destination};
 	}
 
+	/**
+	 * Call this method to set the value of a template variable. Template
+	 * variables specify a location in the html template where the value will be
+	 * inserted. To specify where the value should be inserted in the template
+	 * file add the string "${variableName}" in the location.
+	 *
+	 * @param {*} name
+	 * @param {*} value
+	 */
+	setTemplateVariable(name, value) {
+		this.templateVariables[name] = value;
+	}
+
 	addConfig(config, root) {
 		this.configs[root] = config;
 	}
 
-	async addMainCss(specs) {
+	/**
+	 * Call this method to add specifications for application css files  These
+	 * css files will be included in the html template
+	 *
+	 * @param {ResourceSpecList} specs the specification for the css files. These
+	 * 		will also be added as resources to be copied.
+	 */
+	addMainCss(specs) {
+		this.cssSpecs = [...this.cssSpecs, ...specs];
+	}
+
+	/**
+	 * Call this method to find all the css files specified by the css specs
+	 */
+	async findMainCss() {
 		var files = new Files(this.sourcePath, this.destPath)
 
-	// get the file paths
+	// Find all the files frem the added css speces
 		specs.forEach(function(spec) {
-			files.addCopySpec('', spec);
+			files.addResourceSpec('', spec);
 		}, this)
 
 		var expanded = await files.findAllFiles();
@@ -141,30 +201,32 @@ export default class App {
 
 	/**
 	 * Call this method to add a list of resources that will be moved to the
-	 * destination path when the application is built. This will either be a
-	 * feature root, or the source path
+	 * destination path when the application is built.
 	 *
-	 * @param {Array<import('./Files.js').CopySpec} resourceSpecs the copy specs
+	 * @param {String} root the relative path from the source root to the path
+	 * 		to the origin of the caller. This will either be a feature root, or
+	 * 		empty for the main applicatio the source pathPaths specified in the
+	 * 		resource spec are assumed to be relative to this.-
+	 * @param {Array<ReourceSpec>} resourceSpecs the copy specs
 	 * 		for all the resources being added.
-	 * @param {String} root the path to the origin of the caller. Paths in
-	 * 		the spec are assumed to be relative to this.
 	 */
 	addResources(root, resourceSpecs) {
 		resourceSpecs.forEach(function(spec) {
-			this.files.addCopySpec(root, spec);
+			this.files.addResourceSpec(root, spec);
 		}, this)
 	}
 
 	/**
 	 * Call this method to add a feature to the application. This method is
 	 * given a path to the root of the feature. At build time the builder will
-	 * look directory for a file named build.js and if found import it and
-	 * call the default function passing it a pointner to this object.
+	 * look in the feature directory for a file named build.js and if found
+	 * import it and call the default function passing it a pointner to this
+	 * object.
 	 *
 	 * If there is no build.js file the builder will look for a build.json file.
 	 * If present that json will be loaded and used to build the feature.
 	 *
-	 * If that is not found it will look for an index.js file. and if found it
+	 * If that is not found it will look for an index.js file, and if found it
 	 * will add that to the list of feature index files which will be
 	 * automatically imported when the built code imports the @polylith/features
 	 * module
@@ -223,54 +285,53 @@ export default class App {
 	}
 
 	/**
-	 * If no manual chunk specifiers are added, then this will be used as the
-	 * default.
+	 * This is called by rollup if no manual chunk specifiers are added,
 	 *
-	 * @param {String} id this is the filename of the current file being
+	 * @param {String} filename this is the filename of the current file being
 	 * 		processed by rollup
 	 *
 	 * @returns {String} the chunk name if there is a match
 	 */
-	defaultManualChunks(id) {
-		if (id.includes('node_modules')) {
+	defaultManualChunks(filename) {
+		if (filename.includes('node_modules')) {
 			return 'vendor';
 		}
 	}
 
 	/**
-	 * This is called when manual chunk specifications have been added as an
-	 * array.
+	 * This is called by rollup when manual chunk specifications have been added
+	 * as an array.
 	 *
-	 * @param {String} id this is the filename of the current file being
+	 * @param {String} filename this is the filename of the current file being
 	 * 		processed by rollup
-	 * @returns {String} the name fo the chunk if there is a matching chunk
+	 * @returns {String} the name oo the chunk if there is a matching chunk
 	 * 		name specifier
 	 */
-	handleManualChunksArray(id) {
-		var fixId = App.fixPath(id);
+	handleManualChunksArray(filename) {
+		var posixFilename = forceToPosix(filename);
 		var result = this.manualChunks.find(function(spec) {
-			return fixId.includes(spec.includes);
+			return posixFilename.includes(spec.includes);
 		})
 
 		if (result) return result.name;
 	}
 
 	/**
-	 * This is called when the manual chunk specifiers are functions. Each
-	 * registered function is called in the reverse order to how they were
+	 * This is called by rollup when the manual chunk specifiers are functions.
+	 * Each registered function is called in the reverse order to how they were
 	 * added.
 	 *
-	 * @param {String} id this is the filename of the current file being
+	 * @param {String} filename this is the filename of the current file being
 	 * 		processed by rollup
 	 * @returns the chunk name if any of the callbacks return one
 	 */
-	handleManualChunksCallbacks(id) {
-		var fixId = App.fixPath(id);
+	handleManualChunksCallbacks(filename) {
+		var posixFilename = forceToPosix(filename);
 		if (this.manualChunks.length === 0) {
-			return this.defaultManualChunks(fixId);
+			return this.defaultManualChunks(posixFilename);
 		} else {
-			for (let idx = 0; idx < this.manualChunks.length; idx++) {
-				var result = this.manualChunks[idx](fixId);
+			for (chunk of this.manualChunks) {
+				var result = chunk(posixFilename);
 				if (result) return result;
 			}
 		}
@@ -343,40 +404,62 @@ export default class App {
 
 	/**
 	 *
+	 * @param {String} root the relative path from the source root to the
+	 * 		feature directory. Loadable paths are assumed to be relative to this
+	 * 		directory
 	 * @param {String} name unique name of the loadable that will be passed to
 	 * 		the load method
-	 * @param {String} main the relative path from the source folder to the entry
-	 * 		point of the loadable.
+	 * @param {String} index the relative path from the source folder to the
+	 * 		entry point of the loadable.
 	 * @param {String} [prefix] if given, the prefix on services created in
 	 * 		this loadable. When the loadable has been loaded, the start and
 	 * 		ready methods will be called on all services starting with this
 	 * 		prefix.
-	 * @param {Array<CopySpec>} [css] if supplied it will be a copy spec of the
-	 * 		css files that will included when the module is loaded
+	 * @param {ResourceSpecList} [css] if give, it will be a list of resource
+	 * 		specifications for the css files that will be included when the
+	 * 		module is loaded
 	 */
-	async addLoadable(root, name, main, prefix, css) {
-		// expand css specs
-		var cssUris = css ? [] : undefined;
-		if (css) {
+	async addLoadable(root, name, index, prefix, css) {
+		var indexPath = path.posix.join(this.sourcePath, index);
+		this.loadables.push({name, index: indexPath, prefix, root, css});
+	}
+
+	/**
+	 * Call this method to locate all the css files for a loadable. These css
+	 * files will be loaded into the browser when this loadable has been loaded
+	 *
+	 * @param {Loadable} loadable
+	 */
+	async findLoadableCss(loadable) {
+		if (loadable.css) {
 			var files = new Files(this.sourcePath, this.destPath)
-			css.forEach(function(spec) {
-				files.addCopySpec(root, spec);
+			loadable.css.forEach(function(spec) {
+				files.addResourceSpec(loadable.root, spec);
 			}, this)
+
 			var expanded = await files.findAllFiles();
 			var keys = Object.keys(expanded);
-			keys.forEach(function(key){
+
+			var cssUris = keys.map(function(key){
 				var file = expanded[key];
-				cssUris.push(file.uri)
+				return file.uri
 			}, this)
-		}
 
-		var dest = path.posix.join(this.sourcePath, main);
-		this.loadables.push({name, path: dest, prefix, css: cssUris});
+			loadable.css = cssUris;
+		}
 	}
 
-
-	buildMainCss() {
+	/**
+	 * Call this method to build the template variable for the main html css
+	 * files
+	 *
+	 * @returns {Promise<String>} the value of the mainCss template variable
+	 */
+	async buildMainCss() {
 		var cssTags = '';
+
+		await this.findMainCss();
+
 		this.cssFiles.forEach(function(uri) {
 			cssTags += `		<link rel="stylesheet" href="${uri}"></link>`
 		}, this);
@@ -385,25 +468,28 @@ export default class App {
 	}
 
 	/**
-	 * The build method calls this method to create the rollup configuration
-	 * object
+	 * The build method calls this to create the rollup configuration object
 	 *
 	 * @returns {Object} rollup configuration object
 	 */
 
-	buildConfiguration() {
+	async buildConfiguration() {
 		var input = [this.fullIndexPath];
-		this.loadables.forEach(function(spec) {
-			input.push(spec.path);
-		});
 
-		this.variables = {
-			pattern: 'main-js',
-			replacement: `<script type="module" src="${this.index}"></script>`
+		// using a for loop because we are making an async call
+		for (let loadable of loadables) {
+		// find all the css files for the loadables
+			await this.findLoadableCss(loadable);
+			input.push(loadable.index);
 		}
 
 		var manualChunks = this.getManualChunks();
-		var mainCss = this.buildMainCss();
+		var mainCss = await this.buildMainCss();
+		var codeVariables = this.getCodeVariablesValue();
+
+		this.templateVariables['mainCss'] = mainCss;
+		this.templateVariables['codeVariables'] = codeVariables;
+
 		var plugins = [
 			resolve.nodeResolve({
 				extensions: ['.js', '.jsx']
@@ -424,7 +510,7 @@ export default class App {
 				root: this.root,
 				source: this.htmlTemplate.source,
 				destination: this.htmlTemplate.destination,
-				replaceVars: {mainCss: mainCss},
+				templateVars: this.templateVariables,
 			}),
 			resources(this.name, this.files)
 		];
@@ -449,9 +535,9 @@ export default class App {
 						return '[name]-[hash][extname]';
 					},
 					entryFileNames: function(chunkInfo) {
-						var entry = App.fixPath(chunkInfo.facadeModuleId);
+						var entry = forceToPosix(chunkInfo.facadeModuleId);
 						var found = this.loadables.find(function(loadable) {
-							return loadable.path === entry;
+							return loadable.index === entry;
 						}, this);
 						var exists = Boolean(found);
 
@@ -478,7 +564,7 @@ export default class App {
 
 	async build() {
 		await this.buildFeatures();
-		this.config = this.buildConfiguration();
+		this.config = await this.buildConfiguration();
 
 		const bundle = await rollup.rollup(this.config.input);
 		await bundle.generate(this.config.output);

package/ConfigApp.js

@@ -1,12 +1,16 @@
 import App from './App.js';
 import path from 'node:path/posix';
+import {forceToPosix} from './utils.js'
 
+/**
+ * This class is used to build an application from a configuration file.
+ */
 export default class ConfigApp extends App {
 	constructor (config, root) {
-		root = App.fixPath(root);
+		root = forceToPosix(root);
 		var name = config.name || 'unnamed';
-		var index = config.index || path.join(root, 'src', 'index.js');
-		var dest = config.dest || path.join(root, 'dist');
+		var index = config.index || 'src/index.js';
+		var dest = config.dest || 'dist';
 
 		super(name, root, index, dest);
 		this.config = config;
@@ -14,20 +18,30 @@ export default class ConfigApp extends App {
 		if (!index.template || !index.template.source) throw new Error('html source not defined in config file');
 		var source = index.template.source;
 		var sourceFilename = path.basename(source);
-		var destination = index.template.destination || path.join(dest, sourceFilename)
+		var destination = index.template.destination || path.join(dest, sourceFilename);
 		this.setHtmlTemplate(source, destination);
 
-		if (config.manualChunks) this.addManualChunks(config.manualChunks);
+		if (config.manualChunks) {
+			config.manualChunks.forEach(function(chunk) {
+				this.addManualChunks(chunk);
+			}, this)
+		}
+
 		if (this.config.features) {
 			this.config.features.forEach(function(feature) {
 				this.addFeature(feature);
 			}.bind(this))
 		}
 
-		if (config.resources) ;
-	}
+		if (config.resources && Array.isArray(config.resources)) this.addResources('', config.resources);
+		if (config.css) this.addMainCss(css);
 
-	async getFeatures() {
-		return this.config.features || [];
+		if (config.variables) {
+			var names = Object.keys(config.variables);
+
+			names.forEach(function(name) {
+				this.addCodeVariable(name, config.variables[name]);
+			}, this)
+		}
 	}
 }

package/ConfigFeature.js

@@ -1,5 +1,6 @@
 import Feature from './Feature.js';
 import path from 'node:path/posix';
+import App from './App.js';
 
 export default class ConfigFeature extends Feature {
 	/**

package/Files.js

@@ -3,27 +3,8 @@ import path from 'node:path/posix'
 import {ensureDir} from 'fs-extra';
 import { copyFile } from 'node:fs/promises';
 import App from './App.js';
-
-/**
- * @typedef {Object} CopySpec
- * @property {String} dest the relative path of the copy destination from the
- *  application's destination path.
- * @property {String} cwd the relative path from the spec root to search for
- *  files
- * @property {String} glob the search expression for the files to copy, in glob
- *  format
- * @property {Boolean} [keepNest] if true then the nesting of the found file
- *  relative to the cwd property will be retained when the file is copied.
- *  Defaults to false
- */
-
-/**
- * @typedef {Object} FileSpec
- * @property {String} name the full path to the file being copied
- * @property {String} searchRoot the absolute path to where the search started
- * @property {CopySpec} spec the specifier for how to find and copy files
- */
-
+import {forceToPosix} from './utils.js'
+import './types.js'
 /**
  * create an instance of this class to specify and and copy files from source
  * to destination.
@@ -40,6 +21,7 @@ export default class Files {
 	constructor(src, dest) {
 		this.dest = dest;
 		this.src = src;
+		/** @type {CopyInfoList} */
 		this.files = {};
 		this.specs = [];
 	}
@@ -52,20 +34,23 @@ export default class Files {
 	 * @param {String} root the originating path of the specifier. This is a
 	 *  relative path from the project src path. This is probably the location
 	 *  of the feature, or empty for the src path itself.
-	 * @param {CopySpec} spec the specification for how to find and copy files
+	 * @param {ResourceSpec} spec the specification for how to find and copy files
 	 */
-	addCopySpec(root, spec) {
+	addResourceSpec(root, spec) {
 		spec.root = root;
 		this.specs.push(spec);
 	}
 
 	/**
-	 * call this methid to generate the destination filename from the spec and
+	 * call this method to generate the destination filename from the spec and
 	 * the source filename
 	 *
-	 * @param {CopySpec} spec the spec that generate the filename
-	 * @param {String} srcFilename the source filename
-	 * @returns
+	 * @param {String} searchRoot the full path to the directory where the
+	 * 		search started that found this file
+	 * @param {ResourceSpec} spec the spec that found the file
+	 * @param {String} srcFilename the full path to the source file
+	 *
+	 * @returns {String} the full path to the destination file
 	 */
 	makeDestination(searchRoot, spec, srcFilename) {
 		var fullPath = searchRoot;
@@ -87,35 +72,84 @@ export default class Files {
 	 * different specs then the spec with the longest search root will take
 	 * presidence, since it is the spec with the greatest specificity
 	 *
-	 * @param {Array<String>} files absolute filepaths of files that have been found
-	 * @param {String} searchRoot the absolute path of the spec root
-	 * @param {CopySpec} spec the spec that was used to find these files.
+	 * @param {String} searchRoot the full path to the directory where the
+	 * 		search started that found this file
+	 * @param {Array.<String>} files full paths to files that have been found
+	 * @param {ResourceSpec} spec the spec that was used to find these files.
+	 *
+	 * @returns {CopyInfoList} the list of files found for this spec
 	 */
 	addFiles(searchRoot, files, spec) {
+		/** @type {CopyInfoList} */
+		var foundFiles = {};
+
 		// the rule here is that files that are found by multiple specs will be
 		// controlled according to the spec with the deepest nested search path.
-		// Since file paths here are absolute tthis will always be based on the
+		// Since file paths here are absolute this will always be based on the
 		// string length.
 		files.forEach(function(file) {
-			file = App.fixPath(file);
+			file = forceToPosix(file);
+
 			// reconcile conflicts
 			if (this.files[file]) {
 				var copyInfo = this.files[file];
 				if (copyInfo.searchRoot.length > searchRoot.length) return;
 			}
+
 			var destination = this.makeDestination(searchRoot, spec, file);
 			var uri = destination.slice(this.dest.length + 1);
 
-			this.files[file] = {
+			foundFiles[file] = {
 				name: file,
+				searchRoot: searchRoot,
 				destFilename: destination,
 				uri: uri,
-				searchRoot: searchRoot,
 				spec: spec,
 			}
-		}, this)
+		}, this);
+
+		this.files = {...this.files, ...foundFiles}
+
+		return foundFiles;
 	}
 
+	/**
+	 * 	Call this method to get all the folders where files can copied from
+	 *
+	 * @returns {Array.<String>}
+	 */
+	getAllFolders() {
+		var folders = 	this.specs.map(function(spec){
+			return path.join(this.src, spec.root, spec.cwd);
+		}, this);
+
+		return folders;
+	}
+
+
+	/**
+	 * Call this method to copy a single file into its destination location
+	 *
+	 * @param {String} file the full path of the file to be copied
+	 */
+	async copyOneFile(file, updated) {
+		file = forceToPosix(file);
+
+		var destination = this.files[file] && this.files[file].destFilename;
+
+		if (destination && updated) {
+			console.log(`file ${file} updated, copied to ${destination}`);
+			await copyFile(file, destination);
+		}
+	}
+
+	/**
+	 * Call this method to find all the files specified by a spec.
+	 *
+	 * @param {ResourceSpec} spec the specification for the files to find
+	 *
+	 * @returns {Promise.<CopyInfoList>} all the files that have been found so far.
+	 */
 	async findFiles(spec) {
 		var searchRoot = path.join(this.src, spec.root, spec.cwd);
 		var options = {
@@ -136,17 +170,16 @@ export default class Files {
 
 	/**
 	 * Call this method to locate all the files to be found from all the copy
-	 * specs that have been added
+	 * specs that have been added.
 	 *
-	 * @returns {Promise<Array<FileSpec>>} the list of all files. This is also
-	 *  stored in the object variable this.files
+	 * @returns {Promise<CopyInfoList>} the list of all files that have
+	 * 		been found. This is also stored in the object variable this.files
 	 */
 	async findAllFiles() {
 		if (this.filesFound) return this.files;
 
 		// using a for loop here because we are making async calls
-		for (let idx = 0; idx < this.specs.length; idx++) {
-			let spec = this.specs[idx];
+		for (let spec of this.specs) {
 			await this.findFiles(spec);
 		}
 
@@ -156,22 +189,20 @@ export default class Files {
 	}
 
 	/**
-	 * Call this method to copy all the files that have been specified through
-	 * addCopySpec
+	 * Call this method to copy all the files that have been specified by
+	 * calling addResourceSpec to their destination directories
 	 */
 	async copyFiles() {
 		await this.findAllFiles();
 
 		var filenames = Object.keys(this.files);
+
 		// using a for loop because we are making async calls
-		for (let idx = 0 ; idx < filenames.length; idx++) {
-			let srcFilename = filenames[idx];
+		for (let srcFilename of filenames) {
 			let destFilename = this.files[srcFilename].destFilename;
-			var destFilePath = path.dirname(destFilename);
-			// we will override existing destination files. This could have
-			// unintended consequences
+			let destFilePath = path.dirname(destFilename);
+
 			try {
-//				console.log(`copying ${srcFilename} to ${destFilename}`);
 				await ensureDir(destFilePath);
 				await copyFile(srcFilename, destFilename);
 			} catch (e) {

package/index.js

@@ -2,5 +2,12 @@ import App from './App.js'
 import Feature from './Feature.js';
 import ConfigApp from './ConfigApp.js';
 import ConfigFeature from './ConfigFeature.js';
+import utils from './utils.js';
 
-export {App, Feature, ConfigApp, ConfigFeature};
+var utilsExport = {
+	forceToPosix: utils.forceToPosix,
+	fileExists: utils.fileExists,
+	fileToPath: utils.fileToPath,
+}
+
+export {App, Feature, ConfigApp, ConfigFeature, utilsExport as utils};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polylith/builder",
-  "version": "0.0.37",
+  "version": "0.0.39",
   "description": "The polylith builder",
   "main": "index.js",
   "type": "module",

package/plugin-copy-resources.js

@@ -10,13 +10,15 @@ export default function(name, files) {
 	return {
 		name: "copy-resources",
 
-		async buildStart(){
-			var foundFiles = files.findAllFiles();
-			var filenames = Object.keys(foundFiles);
-			filenames.forEach(function(name) {
-				var destFilename = foundFiles[name].destFilename;
-				this.addWatchFile(destFilename);
-			});
+		buildStart() {
+			var folders = files.getAllFolders();
+			folders.forEach(function(name) {
+				this.addWatchFile(name);
+			}, this);
+		},
+
+		watchChange(file, event) {
+			files.copyOneFile(file);
 		},
 
 		async generateBundle(outputOptions, bundleInfo) {

package/plugin-features.js

@@ -7,12 +7,9 @@ function makeSource(features) {
 
 	var source = `${importStatements}`
 
-	console.log('@polylith/features');
-	console.log(source);
 	return source;
 }
 
-
 export default function features(features) {
 	return {
 		name: 'features',

package/plugin-jsconfig.js

@@ -1,25 +1,6 @@
 import path from 'node:path/posix';
 import {readFile, writeFile, stat} from 'node:fs/promises';
-
-async function fileExists(path) {
-    try {
-        await stat(path)
-        return true;
-    } catch (e) {
-        return false;
-    }
-}
-
-function fixPath(src) {
-	src = src.replace('file:', '');
-	src = src.replace('///', '');
-	src = src.replace(/.:/, '');
-	src = src.replace(/\\/g, '/');
-
-	return src;
-}
-
-
+import {forceToPosix, fileExists} from './utils.js'
 
 /**
  * Matches pattern with a single star against search.
@@ -58,20 +39,19 @@ function matchStar(pattern, search) {
 
 async function findPathMatch(base, source, paths) {
 	var patterns = Object.keys(paths);
-	var source = fixPath(source);
+	var source = forceToPosix(source);
 
 	if (source.indexOf(base) === 0) return
-//		source = source.slice(base.length);
 
-	for(let patternIdx = 0; patternIdx < patterns.length; patternIdx++) {
-		let pattern = patterns[patternIdx];
+	for (let pattern of patterns) {
 		let searches = paths[pattern];
 		let capture = matchStar(pattern, source);
-		if (!capture) continue;
 
+		if (!capture) continue;
 		if (!Array.isArray(searches)) continue;
-		for (let searchIdx = 0; searchIdx < searches.length; searchIdx++) {
-			var tryName = path.join(base, searches[searchIdx].replace('*', capture));
+
+		for (let search of searches) {
+			var tryName = path.join(base, search.replace('*', capture));
 
 			if (await fileExists(tryName)) {
 				return tryName;
@@ -111,7 +91,7 @@ export default function jsconfig(root) {
 		name: 'jsconfig',
 
 		async resolveId (source, importer, options) {
-			source = fixPath(source);
+			source = forceToPosix(source);
 
 			if (previouslyMatched[source] !== undefined) return previouslyMatched[source];
 			previouslyMatched[source] === null;

package/plugin-loader.js

@@ -1,6 +1,6 @@
 import path from 'node:path/posix';
 import {readFile, writeFile, stat} from 'node:fs/promises';
-import {fixPath} from './utils.js';
+import {forceToPosix} from './utils.js';
 var templateSource;
 
 function makeSource(loadables) {
@@ -38,7 +38,7 @@ ${serviceStr}
 
 		var switchStr =
 `			case '${loadable.name}':
-				promise = import('${loadable.path}')${prefixStr}
+				promise = import('${loadable.index}')${prefixStr}
 				break;
 `
 		loadableSwitches += switchStr;
@@ -64,7 +64,7 @@ export default function loader(loadables) {
 		},
 
 		async load (id) {
-			var root = path.dirname(fixPath(import.meta.url));
+			var root = path.dirname(forceToPosix(import.meta.url));
 			if (!templateSource) {
 				templateSource = await readFile(path.join(root, 'loaderTemplate.txt'), 'utf-8');
 			}

package/plugin-main-html.js

@@ -6,12 +6,6 @@ import {readFile, writeFile} from 'node:fs/promises';
 const INVALID_ARGS_ERROR =
   "[plugin-main-html] You did not provide a template or target!";
 
-/**
- * Takes an HTML file as a template and replaces variables.
- * @param {Object} options The options object.
- * @return {Object} The rollup code object.
- */
-
 function createScriptTags(scripts) {
 	var tags = '';
 	scripts.forEach(function(script) {
@@ -22,54 +16,58 @@ function createScriptTags(scripts) {
 	return tags;
 }
 
-export default function(options = {}) {
-  var { root, source, destination, replaceVars } = options;
+/**
+ * Takes an HTML file as a template and replaces template variables with
+ * assigned values
+ *
+ * @param {Object} options The options object.
+ * @return {Object} The rollup plugin object.
+ */
+ export default function(options = {}) {
+
+	var { root, source, destination, templateVars } = options;
 
-  return {
-    name: "main-html-template",
+	return {
+		name: "main-html-template",
 
-    async generateBundle(outputOptions, bundleInfo) {
-		return new Promise(async function (resolve, reject) {
-			try {
-				var includes = [];
-				var names = Object.keys(bundleInfo);
-				var scripts;
+		async generateBundle(outputOptions, bundleInfo) {
+			var includes = [];
+			var names = Object.keys(bundleInfo);
+			var scripts;
 
-				if (!destination && !source) throw new Error(INVALID_ARGS_ERROR);
+			if (!destination && !source) throw new Error(INVALID_ARGS_ERROR);
 
-				names.forEach(function(name) {
-					var entry = bundleInfo[name];
-					if (!entry.isDynamicEntry) {
-						includes.push(name);
-					}
-				});
+			names.forEach(function(name) {
+				var entry = bundleInfo[name];
+				if (!entry.isDynamicEntry) {
+					includes.push(name);
+				}
+			});
 
-				scripts = createScriptTags(includes);
-				replaceVars["scripts"] = scripts;
+			scripts = createScriptTags(includes);
+			templateVars["scripts"] = scripts;
 
-				var sourceFilePath = path.join(root, source);
-				var destinationFilePath = path.join(root, destination);
+			var sourceFilePath = path.join(root, source);
+			var destinationFilePath = path.join(root, destination);
 
-				// Read the file
-				var content = await readFile(sourceFilePath, 'utf-8');
-				if (replaceVars) {
-					var varNames = Object.keys(replaceVars);
-					varNames.forEach(function(name) {
-						var replacement = replaceVars[name]
-						var escapedName = escapeStringRegexp('${' + name + '}');
-						var regex = new RegExp(escapedName, 'g');
-						content = content.replace(regex, replacement);
-					});
-				}
+			var content = await readFile(sourceFilePath, 'utf-8');
 
-				// write the injected template to a file
-				await ensureFile(destinationFilePath);
-				writeFile(destinationFilePath, content, 'utf-8');
-				resolve();
-			} catch (e) {
-				reject(e);
+			if (templateVars) {
+				var varNames = Object.keys(templateVars);
+				varNames.forEach(function(name) {
+					var replacement = templateVars[name]
+					var escapedName = escapeStringRegexp('${' + name + '}');
+					var regex = new RegExp(escapedName, 'g');
+					content = content.replace(regex, replacement);
+				});
 			}
-      });
-    },
-  };
+
+			// remove template vars that were not replaced
+			content = content.replace(/\$\{.*?\}/, '');
+
+			// write the injected template to a file
+			await ensureFile(destinationFilePath);
+			writeFile(destinationFilePath, content, 'utf-8');
+		},
+	};
 }

package/types.js

@@ -0,0 +1,60 @@
+/** @module types */
+
+/**
+ * This type defines how to locate a set of files that will be copied to the
+ * dest folder.
+ *
+ * @typedef {Object} ResourceSpec
+ * @property {String} dest the relative path of the copy destination from the
+ *  application's destination path.
+ * @property {String} cwd the relative path from the spec root to search for
+ *  files
+ * @property {String} glob the search expression for the files to copy, in glob
+ *  format
+ * @property {Boolean} [keepNest] if true then the nesting of the found file
+ *  relative to the cwd property will be retained when the file is copied.
+ *  Defaults to false
+ */
+
+/**
+ * This type defines a list of ResourceSpec
+ *
+ * @typedef {Array.<ResourceSpec} ResourceSpecList
+ */
+
+/**
+ * This defines the specification for a file that has been found from a
+ * ResourceSpec
+ *
+ * @typedef {Object} CopyInfo
+ * @property {String} name the full path to the file found
+ * @property {String} searchRoot the absolute path to where the search started.
+ * @property {String} destFilename the absolute path to where the file be copied
+ * @property {String} uri the path to the file relative to the destination
+ * 		directory. This can be used to reference the file from the output
+ * 		application.
+ * @property {ResourceSpec} spec the specifier used to locate this file
+ */
+
+/**
+ * This type defines a list of CopyInfos
+ *
+ * @typedef {Object.<String, CopyInfo>} CopyInfoList
+ */
+
+/**
+ * This specifies what is in a loadable object
+ *
+ * @typedef {Object} Loadable
+ * @property {String} name this is the name the loadable will be known as. This
+ * 		will be the string passed to the load function
+ * @property {String} root the relative path from the source directory to the
+ * 		root of the feature. All feature paths are assumed to be relative to
+ * 		this
+ * @property {String} index the absolute path to the loadables index file
+ * @property {String} prefix if given then all services that begin with this
+ * 		prefix will go through the start sequence when loaded
+ * @property {ResourceSpecList|Array<String>} css is either the specification for
+ * 		where to find the css files to load, or during build, an array of the
+ * 		uris for each css file.
+ */

package/utils.js

@@ -1,16 +1,37 @@
 import path from 'node:path/posix';
 import {readFile, writeFile, stat} from 'node:fs/promises';
 
-export function fixPath(src) {
+/**
+ * call this function to force the file path to use posix notation and remove
+ * all drive information.
+ *
+ *
+ * @param {String} src the filename wqe
+ * @returns {String} the new path
+ */
+export function forceToPosix(src) {
 	src = src.replace('file:', '');
 	src = src.replace('///', '');
-	src = src.replace(/.:/, '');
+	src = src.replace(/.*?:/, '');
 	src = src.replace(/\\/g, '/');
 
 	return src;
 }
 
-async function fileExists(path) {
+export function fileToPath(filename) {
+    filename = fixPath(filename);
+    return path.dirname(filename);
+}
+
+
+/**
+ * call this function to check if the given file exists
+ *
+ * @param {String} path the name of the file
+ * @returns {Promise<Boolean>} true if the file exists
+ */
+
+ export async function fileExists(path) {
     try {
         await stat(path)
         return true;