@polylith/builder 0.0.27 → 0.0.29

package/App.js

@@ -13,6 +13,7 @@ import features from './plugin-features.js';
 import styles from "rollup-plugin-styles";
 
 import ConfigFeature from './ConfigFeature.js';
+import Files from './Files.js';
 
 /**
  * call this function to check if the given file exists
@@ -39,11 +40,11 @@ export default class App {
 	 *
 	 * @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.
+	 *  	paths will be relative to this path.
 	 * @param {String} index the path to the main source file for the app. all
-	 * 	source paths will be assumed to be relative to this path.
+	 * 		source paths will be assumed to be relative to this path.
 	 * @param {String} dest the path to the destination folder for the
-	 * 	rolled up files
+	 * 		rolled up files
 	 */
 
 	constructor(name, root, index , dest) {
@@ -52,17 +53,19 @@ export default class App {
 
 		var filename = path.posix.join(root, index);
 		this.sourcePath = path.posix.dirname(filename);
-		this.destination = path.posix.join(root, dest);
+		this.destPath = path.posix.join(root, dest);
 
 		this.name = name;
 		this.index = index;
 		this.fullIndexPath = path.posix.join(root, index);
 
 		this.loadables = [];
+		this.features = [];
 		this.featureIndexes = [];
 		this.configs = {};
 		this.manualChunkType = 'function';
 		this.manualChunks = [];
+		this.files = new Files(sourcePath, destination)
 	}
 
 	static fileToPath(filename) {
@@ -109,13 +112,53 @@ export default class App {
 		this.configs[root] = config;
 	}
 
-	// default implementation, applications will implement this to specify the loadable features to be used
-	async getFeatures() {
-		return [];
+	/**
+	 * 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
+	 *
+	 * @param {Array<import('./Files.js').CopySpec} 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(resourceSpecs, root) {
+		resourceSpecs.forEach(function(spec) {
+			this.files.addCopySpec(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.
+	 *
+	 * 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
+	 * will add that to the list on feature index files which will be
+	 * automatically imported when the built code imports the @polylith/features
+	 * module
+	 *
+	 * @param {String} feature the relative path from the application source
+	 * 		directory to the feature root.
+	 */
+	addFeature(feature) {
+		this.features.push(feature);
 	}
 
-	addFeatureMain(main) {
-		this.featureIndexes.push(main);
+	/**
+	 * Call this method to add a feature index file to the application. These
+	 * features will be imported when the application imports
+	 * "@polylith/features"
+	 *
+	 * @param {String} index the relative path to the feature index file from
+	 * 		the application source folder.
+	 */
+	addFeatureIndex(index) {
+		this.featureIndexes.push(index);
 	}
 
 	/**
@@ -156,18 +199,28 @@ export default class App {
 	 * If no manual chunk specifiers are added, then this will be used as the
 	 * default.
 	 *
-	 * @param {String} id the filename being processed.
+	 * @param {String} id this is the filename of the current file being
+	 * 		processed by rollup
 	 *
 	 * @returns {String} the chunk name if there is a match
 	 */
-	defaultManualChunkCallback(id) {
+	defaultManualChunks(id) {
 		if (id.includes('node_modules')) {
 			return 'vendor';
 		}
 	}
 
-	manualChunksArray(id) {
-		var fixId = this.fixPath(id);
+	/**
+	 * This is called when manual chunk specifications have been added as an
+	 * array.
+	 *
+	 * @param {String} id 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
+	 * 		name specifier
+	 */
+	handleManualChunksArray(id) {
+		var fixId = App.fixPath(id);
 		var result = this.manualChunks.find(function(spec) {
 			return fixId.includes(spec.includes);
 		})
@@ -175,22 +228,38 @@ export default class App {
 		if (result) return result.name;
 	}
 
-	manualChunksCallback(id) {
-		var fixId = this.fixPath(fixId);
+	/**
+	 * This is called 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
+	 * 		processed by rollup
+	 * @returns the chunk name if any of the callbacks return one
+	 */
+	handleManualChunksCallbacks(id) {
+		var fixId = App.fixPath(id);
 		if (this.manualChunks.length === 0) {
 			return this.defaultManualChunks(fixId);
 		} else {
 			for (let idx = 0; idx < this.manualChunks.length; idx++) {
-				var result = this.manualChunks[id](fixId);
+				var result = this.manualChunks[idx](fixId);
 				if (result) return result;
 			}
 		}
 	}
 
+	/**
+	 * This is called by the builder to get the method to handle manual chunks
+	 * based on how they have been setup. The value returned from this funtion
+	 * will be the value set in the rollup options object.
+	 *
+	 * @returns {Object|Function} the value to assign to the manualChunk field.
+	 */
 	getManualChunks() {
-		if (this.manualChunksType === 'object') return this.manualChunks;
-		if (this.manualChunksType === 'array') return this.manualChunksArray.bind(this);
-		if (this.manualChunksType === 'function') return this.manualChunksCallback.bind(this);
+		if (this.manualChunkType === 'object') return this.manualChunks;
+		if (this.manualChunkType === 'array') return this.handleManualChunksArray.bind(this);
+		if (this.manualChunkType === 'function') return this.handleManualChunksCallbacks.bind(this);
 	}
 
 	/**
@@ -198,7 +267,7 @@ export default class App {
 	 * pieces of code that are not a direct dependency of the main application.
 	 *
 	 * @param {String} root path relative to the source directory for the
-	 * feature to load.
+	 * 		feature to load.
 	 */
 	async loadFeature(root) {
 		var featurePath = path.posix.join(this.sourcePath, root);
@@ -226,7 +295,7 @@ export default class App {
 			try {
 				let content = JSON.parse(await readFile(jsonPath));
 
-				let builder = new ConfigFeature(content, featurePath);
+				let builder = new ConfigFeature(content, root);
 				await builder.build(this)
 			} catch (e) {
 				console.error(e);
@@ -238,30 +307,32 @@ export default class App {
 	}
 
 	async buildFeatures() {
-		var features = await this.getFeatures();
+		var features = this.features;
 
 		for (let feature of features) {
 			await(this.loadFeature(feature));
 		}
 	}
 
-	/* features will call this method if they want to add loadables
-
-	  name - name of the loadable that we be passed to the load method
-	  main - the relative path from the source folder to the entry point of the
-	    loadable.
-	  prefix - if given, the prefix on services created in this loadable.
-	    The start and ready methods will be called on these services
-	*/
+	/**
+	 *
+	 * @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} [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.
+	 */
 	addLoadable(name, main, prefix) {
 		var dest = path.posix.join(this.sourcePath, main);
-
-		console.log('addLoadable', {name, path: dest, prefix})
 		this.loadables.push({name, path: dest, prefix});
 	}
 
 	/**
-	 * build calls this method to create the rollup configuration object
+	 * The build method calls this method to create the rollup configuration
+	 * object
 	 *
 	 * @returns {Object} rollup configuration object
 	 */
@@ -289,6 +360,7 @@ export default class App {
 					commonjs(),
 					babel({
 						presets: ['@babel/preset-react'],
+						babelHelpers: 'bundled',
 					}),
 					loader(this.loadables),
 					features(this.featureIndexes),
@@ -307,7 +379,7 @@ export default class App {
 			output : {
 				output : {
 					sourcemap: true,
-					dir : this.destination,
+					dir : this.destPath,
 					format: 'es',
 					assetFileNames: function(chunkInfo) {
 						return '[name]-[hash][extname]';
@@ -326,10 +398,14 @@ export default class App {
 						return '[name].js';
 					}.bind(this),
 					manualChunks: manualChunks,
-					treeshake: {
-						moduleSideEffects: true
-					}
 				},
+			},
+			watch : {
+				watch: {
+					buildDelay: 250,
+					exclude: 'node_modules/**',
+					clearScreen: true,
+				}
 			}
 		};
 
@@ -338,11 +414,41 @@ export default class App {
 
 	async build() {
 		await this.buildFeatures();
-		var config = this.buildConfiguration();
+		this.config = this.buildConfiguration();
 
-		const bundle = await rollup.rollup(config.input);
-		await bundle.generate(config.output);
-		await bundle.write(config.output);
+		const bundle = await rollup.rollup(this.config.input);
+		await bundle.generate(this.config.output);
+		await bundle.write(this.config.output);
 		await bundle.close();
 	}
+
+	watch() {
+		var watchConfig  = {
+			...this.config.input,
+			...this.config.output,
+			...this.config.watch,
+		}
+
+		const watcher = rollup.watch(watchConfig);
+		watcher.on('event', function(event) {
+			console.log(event.code);
+			if (event.result) {
+				event.result.close();
+			}
+
+			if (event.code === 'ERROR') {
+				console.error(event.error)
+			}
+
+			if (event.code === 'BUNDLE_START') {
+				process.stdout.write("\u001b[2J\u001b[0;0H");
+				console.log(event);
+			}
+
+			if (event.code === 'BUNDLE_END') {
+				process.stdout.write("\u001b[2J\u001b[0;0H");
+				console.log(event);
+			}
+		}.bind(this));
+	}
 }

package/ConfigApp.js

@@ -2,25 +2,32 @@ import App from './App';
 import path from 'node:path/posix';
 
 export default class ConfigApp extends App {
-    constructor (config, root) {
-        App.fixPath(root);
-        var name = config.name || 'unnamed';
-        var index = config.main || path.join(root, 'src', 'index.js');
-        var dest = config.dest || path.join(root, 'dist');
+	constructor (config, root) {
+		App.fixPath(root);
+		var name = config.name || 'unnamed';
+		var index = config.index || path.join(root, 'src', 'index.js');
+		var dest = config.dest || path.join(root, 'dist');
 
-        super(name, root, index, dest);
-        this.config = config;
+		super(name, root, index, dest);
+		this.config = config;
 
-        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)
-        this.setHtmlTemplate(source, destination);
+		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)
+		this.setHtmlTemplate(source, destination);
 
-        if (config.manualChunks) this.addManualChunks(config.manualChunks);
-    }
+		if (config.manualChunks) this.addManualChunks(config.manualChunks);
+		if (this.config.features) {
+			this.config.features.forEach(function(feature) {
+				this.addFeature(feature);
+			}.bind(this))
+		}
 
-    async getFeatures() {
-        return this.config.features || [];
-    }
+		if (config.resources) ;
+	}
+
+	async getFeatures() {
+		return this.config.features || [];
+	}
 }

package/ConfigFeature.js

@@ -1,23 +1,34 @@
 import Feature from './Feature.js';
 
 export default class ConfigFeature extends Feature {
-    constructor (config, root) {
-        super();
-        this.config = config;
-        this.root = root;
-    }
+	/**
+	 * Constrctor for the ConfigFeature class
+	 *
+	 * @param {Object} config the contents of the config file
+	 * @param {String} root the relative path of the feature from the app source directory
+	 */
+	constructor (config, root) {
+		super(root);
+		this.config = config;
+	}
 
-    async build(app) {
-        var config = this.config;
+	/**
+	 * The application calls the method to build the feature.
+	 * @param {App} app the application for th
+	 */
+	async build(app) {
+		var config = this.config;
 
-        if (config.loadables && Array.isArray(config.loadables)) {
-            config.loadables.forEach(function(loadable) {
-                if (loadable.name && loadable.main) {
-                    app.addLoadable(loadable.name, loadable.main, loadable.prefix);
-                }
-            }, this);
-        }
-        if (config.main) app.addFeatureMain(config.main);
-        if (config.config) app.addConfig(config.config, this.root);
-    }
+		if (config.loadables && Array.isArray(config.loadables)) {
+			config.loadables.forEach(function(loadable) {
+				if (loadable.name && loadable.index) {
+					app.addLoadable(loadable.name, loadable.index, loadable.prefix);
+				}
+			}, this);
+		}
+
+		if (config.index) app.addFeatureIndex(config.index);
+		if (config.config) app.addConfig(config.config, this.root);
+		if (config.resources && Array.isArray(config.resources)) app.addResources(config.resources, this.root);
+	}
 }

package/Feature.js

@@ -1,8 +1,9 @@
 export default class Feature {
-  constructor () {
-  }
+	constructor (root) {
+		this.root = root;
+	}
 
-  async build(app) {
-    this.app = app;
-  }
+	async build(app) {
+		this.app = app;
+	}
 }

package/Files.js

@@ -0,0 +1,156 @@
+import fg from 'fast-glob';
+import path from 'node:path/posix'
+import {ensureDir} from 'fs-extra';
+
+/**
+ * @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
+ */
+
+/**
+ * create an instance of this class to specify and and copy files from source
+ * to destination.
+ */
+export default class Files {
+	/**
+	 * Constructor for the Files class
+	 *
+	 * @param {String} dest the absolute filepath to the application's
+	 *  destination directory
+	 * @param {String} src  the abolute path to the applications source
+	 *  directory
+	 */
+	constructor(dest, src) {
+		this.dest = dest;
+		this.src = src;
+		this.files = {};
+		this.specs = [];
+	}
+
+	/**
+	 * Call this method to add a copy specifier for resources to be copied. This
+	 * will be called from either the application or from a feature build
+	 * configuration or js file
+	 *
+	 * @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
+	 */
+	addCopySpec(root, spec) {
+		spec.root = root;
+		this.specs.push(spec);
+	}
+
+	/**
+	 * Call this method once per spec to add a list of files to the complete
+	 * list of all the files to be copied. If multiple files are found through
+	 * 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.
+	 */
+	addFiles(searchRoot, files, spec) {
+		// 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
+		// string length.
+		files.forEach(function(file) {
+			// reconcile conflicts
+			if (this.files[file]) {
+				copyInfo = this.files[file];
+				if (copyInfo.searchRoot.length > searchRoot.length) return;
+			}
+
+			this.files[file] = {
+				name: file,
+				searchRoot: searchRoot,
+				spec: spec,
+			}
+		}, this)
+	}
+
+	/**
+	 * Call this method to locate all the files to be found from all the copy
+	 * specs that have been added
+	 *
+	 * @returns {Promise<Array<FileSpec>>} the list of all files. This is also
+	 *  stored in the object variable this.files
+	 */
+	async findAllFiles() {
+		// 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];
+			let searchRoot = path.join(this.src, spec.root, spec.cwd);
+			let options = {
+				cwd: searchRoot,
+				ignore: ['**/node_modules'],
+				absolute: true,
+				onlyFiles: true,
+				unique: true,
+				dot: true,
+			}
+			let fullGlob = path.join(searchPath, spec.glob);
+			let files = await fg(fullGlob, options);
+
+			this.addFiles(searchRoot, files, spec);
+		}
+
+		return this.files
+	}
+
+	/**
+	 * Call this method to copy all the files that have been specified through
+	 * addCopySpec
+	 */
+	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];
+			let spec = this.files[srcFilename].spec;
+			let relativePath = this.srcFilename.slice(this.files[srcFilename].searchRoot.length);
+			let destFilename = '';
+
+			if (spec.keepNest) {
+				destFilename = path.join(this.dest, spec.dest, relativePath);
+			} else {
+				destFilename = path.join(this.dest, spec.dest, path.basename(srcFilename));
+			}
+
+			// we will override existing destination files. This could have
+			// unintended consequences
+			try {
+				console.log(`copying ${srcFilename} to ${destFilename}`);
+				/*
+					await ensureDir(path.dirname(destinationFilePath));
+					await fs.copyFiles(srcFilename, destFilename);
+				*/
+			} catch (e) {
+				console.error(`Error copying file ${srcFilename} to ${destFilename}`);
+				throw e;
+			}
+		}
+	}
+
+}

package/index.js

@@ -1,4 +1,6 @@
 import App from './App.js'
 import Feature from './Feature.js';
+import ConfigApp from './ConfigApp.js';
+import ConfigFeature from './ConfigFeature.js';
 
-export {App as App, Feature as Feature};
+export {App, Feature, ConfigApp, ConfigFeature};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polylith/builder",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "description": "The polylith builder",
   "main": "index.js",
   "type": "module",
@@ -17,6 +17,7 @@
     "@rollup/plugin-node-resolve": "^13.0.5",
     "babel": "^6.23.0",
     "escape-string-regexp": "^5.0.0",
+    "fast-glob": "^3.2.12",
     "fs-extra": "^10.0.0",
     "less": "^4.1.2",
     "rollup": "^2.58.0",

package/plugin-copy-resources.js

@@ -0,0 +1,22 @@
+/**
+ *
+ * @param {Files} files the files object that specifies the resource files to
+ *  copy
+ * @returns {Object} the plugin
+ */
+export default function(files) {
+	return {
+		name: "main-html-template",
+
+		async generateBundle(outputOptions, bundleInfo) {
+			return new Promise(async function (resolve, reject) {
+				try {
+					await files.copyFiles();
+					resolve(true)
+				} catch (e) {
+					reject(e)
+				}
+			})
+		}
+	}
+}

package/plugin-features.js

@@ -1,9 +1,9 @@
 function makeSource(features) {
 
-    var importStatements = '';
+	var importStatements = '';
 	features.forEach(function(feature) {
-        importStatements += `import '${feature}'\n`;
-    })
+		importStatements += `import '${feature}'\n`;
+	})
 
 	var source = `${importStatements}`
 
@@ -13,7 +13,7 @@ function makeSource(features) {
 
 export default function features(features) {
 	return {
-		name: 'features', 
+		name: 'features',
 
 		resolveId (source, _, third) {
 			if (source === '@polylith/features') {
@@ -30,4 +30,3 @@ export default function features(features) {
 		}
 	};
 }
-

package/plugin-main-html.js

@@ -15,7 +15,7 @@ const INVALID_ARGS_ERROR =
 function createScriptTags(scripts) {
 	var tags = '';
 	scripts.forEach(function(script) {
-		var oneTag = `<script type="module" src="${script}"></script>`;
+		var oneTag = `<script type="module" src="${script}"></script>\n`;
 		tags += oneTag;
 	});
 
@@ -24,7 +24,7 @@ function createScriptTags(scripts) {
 
 export default function(options = {}) {
   var { root, source, destination, replaceVars } = options;
-  
+
   return {
     name: "main-html-template",
 
@@ -34,7 +34,7 @@ export default function(options = {}) {
 				var includes = [];
 				var names = Object.keys(bundleInfo);
 				var scripts;
-		
+
 				if (!destination && !source) throw new Error(INVALID_ARGS_ERROR);
 
 				names.forEach(function(name) {
@@ -73,5 +73,3 @@ export default function(options = {}) {
     },
   };
 }
-
-