@polylith/builder 0.0.32 → 0.0.34

package/App.js

@@ -12,6 +12,7 @@ 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 ConfigFeature from './ConfigFeature.js';
 import Files from './Files.js';
@@ -66,7 +67,8 @@ export default class App {
 		this.configs = {};
 		this.manualChunkType = 'function';
 		this.manualChunks = [];
-		this.files = new Files(this.sourcePath, this.destPath)
+		this.files = new Files(this.sourcePath, this.destPath);
+		this.cssFiles = [];
 	}
 
 	static fileToPath(filename) {
@@ -113,6 +115,25 @@ export default class App {
 		this.configs[root] = config;
 	}
 
+	async addMainCss(specs) {
+		var files = new Files(this.sourcePath, this.destPath)
+
+	// get the file paths
+		specs.forEach(function(spec) {
+			files.addCopySpec('', spec);
+		}, this)
+
+		var expanded = await files.findAllFiles();
+		var keys = Object.keys(expanded);
+		keys.forEach(function(key){
+			var file = expanded[key];
+			this.cssFiles.push(file.uri)
+		}, this);
+
+	// now add them to be copied
+		this.addResources('', specs);
+	}
+
 	/**
 	 * 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
@@ -123,7 +144,7 @@ export default class App {
 	 * @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) {
+	addResources(root, resourceSpecs) {
 		resourceSpecs.forEach(function(spec) {
 			this.files.addCopySpec(root, spec);
 		}, this)
@@ -159,7 +180,7 @@ export default class App {
 	 * 		the application source folder.
 	 */
 	addFeatureIndex(index) {
-		this.featureIndexes.push(index);
+		this.featureIndexes.push(path.join(this.sourcePath, index));
 	}
 
 	/**
@@ -325,10 +346,37 @@ export default class App {
 	 * 		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
 	 */
-	addLoadable(name, main, prefix) {
+	async addLoadable(root, name, main, prefix, css) {
+		// expand css specs
+		var cssUris = css ? [] : undefined;
+		if (css) {
+			var files = new Files(this.sourcePath, this.destPath)
+			css.forEach(function(spec) {
+				files.addCopySpec(root, spec);
+			}, this)
+			var expanded = await files.findAllFiles();
+			var keys = Object.keys(expanded);
+			keys.forEach(function(key){
+				var file = expanded[key];
+				cssUris.push(file.uri)
+			}, this)
+		}
+
 		var dest = path.posix.join(this.sourcePath, main);
-		this.loadables.push({name, path: dest, prefix});
+		this.loadables.push({name, path: dest, prefix, css: cssUris});
+	}
+
+
+	buildMainCss() {
+		var cssTags = '';
+		this.cssFiles.forEach(function(uri) {
+			cssTags += `		<link rel="stylesheet" href="${uri}"></link>`
+		}, this);
+
+		return cssTags;
 	}
 
 	/**
@@ -340,8 +388,8 @@ export default class App {
 
 	buildConfiguration() {
 		var input = [this.fullIndexPath];
-		this.loadables.forEach(function(path) {
-			input.push(path.path);
+		this.loadables.forEach(function(spec) {
+			input.push(spec.path);
 		});
 
 		this.variables = {
@@ -350,6 +398,7 @@ export default class App {
 		}
 
 		var manualChunks = this.getManualChunks();
+		var mainCss = this.buildMainCss();
 
 		var config = {
 			input : {
@@ -365,6 +414,7 @@ export default class App {
 					}),
 					loader(this.loadables),
 					features(this.featureIndexes),
+					jsconfig(this.root),
 					html({
 						include: path.join(this.sourcePath, "**/*.html"),
 					}),
@@ -373,7 +423,7 @@ export default class App {
 						root: this.root,
 						source: this.htmlTemplate.source,
 						destination: this.htmlTemplate.destination,
-						replaceVars: {},
+						replaceVars: {mainCss: mainCss},
 					}),
 					resources(this.name, this.files)
 				],
@@ -427,7 +477,7 @@ export default class App {
 	watch() {
 		var watchConfig  = {
 			...this.config.input,
-			...this.config.output,
+			output: [this.config.output.output],
 			...this.config.watch,
 		}
 

package/ConfigApp.js

@@ -3,7 +3,7 @@ import path from 'node:path/posix';
 
 export default class ConfigApp extends App {
 	constructor (config, root) {
-		App.fixPath(root);
+		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');

package/ConfigFeature.js

@@ -1,4 +1,5 @@
 import Feature from './Feature.js';
+import path from 'node:path/posix';
 
 export default class ConfigFeature extends Feature {
 	/**
@@ -14,21 +15,22 @@ export default class ConfigFeature extends Feature {
 
 	/**
 	 * The application calls the method to build the feature.
-	 * @param {App} app the application for th
+	 *
+	 * @param {App} app the application for the feature
 	 */
 	async build(app) {
 		var config = this.config;
 
 		if (config.loadables && Array.isArray(config.loadables)) {
-			config.loadables.forEach(function(loadable) {
+			for (let loadable of config.loadables){
 				if (loadable.name && loadable.index) {
-					app.addLoadable(loadable.name, loadable.index, loadable.prefix);
+					await app.addLoadable(this.root, loadable.name, path.join(this.root, loadable.index), loadable.prefix, loadable.css);
 				}
-			}, this);
+			}
 		}
 
-		if (config.index) app.addFeatureIndex(config.index);
+		if (config.index) app.addFeatureIndex(path.join(this.root, config.index));
 		if (config.config) app.addConfig(config.config, this.root);
-		if (config.resources && Array.isArray(config.resources)) app.addResources(config.resources, this.root);
+		if (config.resources && Array.isArray(config.resources)) app.addResources(this.root, config.resources);
 	}
 }

package/Files.js

@@ -59,6 +59,28 @@ export default class Files {
 		this.specs.push(spec);
 	}
 
+	/**
+	 * call this methid 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
+	 */
+	makeDestination(searchRoot, spec, srcFilename) {
+		var fullPath = searchRoot;
+		var relativePath = srcFilename.slice(fullPath.length + 1);
+		var destFilename = '';
+
+		if (spec.keepNest) {
+			destFilename = path.join(this.dest, spec.dest, relativePath);
+		} else {
+			destFilename = path.join(this.dest, spec.dest, path.basename(srcFilename));
+		}
+
+		return destFilename;
+	}
+
 	/**
 	 * 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
@@ -81,15 +103,37 @@ export default class Files {
 				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] = {
 				name: file,
+				destFilename: destination,
+				uri: uri,
 				searchRoot: searchRoot,
 				spec: spec,
 			}
 		}, this)
 	}
 
+	async findFiles(spec) {
+		var searchRoot = path.join(this.src, spec.root, spec.cwd);
+		var options = {
+			cwd: searchRoot,
+			ignore: ['**/node_modules'],
+			absolute: true,
+			onlyFiles: true,
+			unique: true,
+			dot: true,
+		}
+		var fullGlob = path.join(searchRoot, spec.glob);
+		var files = await fg(fullGlob, options);
+
+		this.addFiles(searchRoot, files, spec);
+
+		return this.files;
+	}
+
 	/**
 	 * Call this method to locate all the files to be found from all the copy
 	 * specs that have been added
@@ -101,22 +145,10 @@ export default class 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];
-			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(searchRoot, spec.glob);
-			let files = await fg(fullGlob, options);
-
-			this.addFiles(searchRoot, files, spec);
+			await this.findFiles(spec);
 		}
 
-		return this.files
+		return this.files;
 	}
 
 	/**
@@ -126,30 +158,18 @@ export default class Files {
 	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 searchRoot = this.files[srcFilename].searchRoot;
-			let fullPath = searchRoot;
-			let relativePath = srcFilename.slice(fullPath.length + 1);
-			let destFilename = '';
-
-			if (spec.keepNest) {
-				destFilename = path.join(this.dest, spec.dest, relativePath);
-			} else {
-				destFilename = path.join(this.dest, spec.dest, path.basename(srcFilename));
-			}
-
+			let destFilename = this.files[srcFilename].destFilename;
 			var destFilePath = path.dirname(destFilename);
 			// we will override existing destination files. This could have
 			// unintended consequences
 			try {
-				console.log(`copying ${srcFilename} to ${destFilename}`);
-					await ensureDir(destFilePath);
-					await copyFile(srcFilename, destFilename);
+//				console.log(`copying ${srcFilename} to ${destFilename}`);
+				await ensureDir(destFilePath);
+				await copyFile(srcFilename, destFilename);
 			} catch (e) {
 				console.error(`Error copying file ${srcFilename} to ${destFilename}`);
 				throw e;

package/loaderTemplate.txt

@@ -0,0 +1,15 @@
+import {App, registry} from '@polylith/core';
+
+var loaded = {}
+
+export async function load(name) {
+	if (loaded[name]) return loaded[name]
+	var promise;
+
+	switch (name) {
+{{SWITCHES}}
+	}
+
+	loaded[name] = promise;
+	return promise;
+}

package/package.json

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

package/plugin-features.js

@@ -2,11 +2,13 @@ function makeSource(features) {
 
 	var importStatements = '';
 	features.forEach(function(feature) {
-		importStatements += `import '${feature}'\n`;
+		importStatements += `import ${JSON.stringify(feature)}\n`;
 	})
 
 	var source = `${importStatements}`
 
+	console.log('@polylith/features');
+	console.log(source);
 	return source;
 }
 

package/plugin-jsconfig.js

@@ -0,0 +1,147 @@
+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;
+}
+
+
+
+/**
+ * Matches pattern with a single star against search.
+ * Star must match at least one character to be considered a match.
+ *
+ * @param patttern for example "foo*"
+ * @param search for example "fooawesomebar"
+ * @returns the part of search that * matches, or undefined if no match.
+ */
+function matchStar(pattern, search) {
+	if (search.length < pattern.length) {
+		return;
+	}
+	if (pattern === "*") {
+		return search;
+	}
+	const star = pattern.indexOf("*");
+
+	if (star === -1) {
+		return;
+	}
+
+	const part1 = pattern.substring(0, star);
+	const part2 = pattern.substring(star + 1);
+
+	if (search.substr(0, star) !== part1) {
+		return;
+	}
+
+	if (search.substr(search.length - part2.length) !== part2) {
+		return;
+	}
+
+	return search.substr(star, search.length - part2.length);
+}
+
+async function findPathMatch(base, source, paths) {
+	var patterns = Object.keys(paths);
+	var source = fixPath(source);
+
+	if (source.indexOf(base) === 0) return
+//		source = source.slice(base.length);
+
+	console.log('>>>', source)
+	for(let patternIdx = 0; patternIdx < patterns.length; patternIdx++) {
+		let pattern = patterns[patternIdx];
+		let searches = paths[pattern];
+		let capture = matchStar(pattern, source);
+		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));
+			console.log('\t..', searches[searchIdx], tryName);
+
+			if (await fileExists(tryName)) {
+				return tryName;
+			}
+		}
+	}
+}
+
+
+export default function features(root) {
+	var jsConfig;
+	var basePath;
+	var paths;
+	var previouslyMatched = {};
+
+	console.log('====root', root);
+	async function readJsConfig() {
+		var jsConfigPath = path.join(root, 'jsconfig.json');
+		var exists = await fileExists(jsConfigPath);
+		if (!exists) {
+			jsConfig === false;
+			return;
+		}
+
+		try {
+			let content = JSON.parse(await readFile(jsConfigPath));
+			basePath = content.compilerOptions.baseUrl;
+			paths = content.compilerOptions.paths;
+			jsConfig = content;
+		} catch (e) {
+			console.err(e)
+			jsConfig = false;
+		}
+	}
+
+
+	return {
+		name: 'features',
+
+		async resolveId (source, importer, options) {
+			source = fixPath(source);
+
+//			console.log('---', source);
+			if (previouslyMatched[source] !== undefined) return previouslyMatched[source];
+			previouslyMatched[source] === null;
+
+			if (jsConfig === undefined) await readJsConfig();
+			if (!jsConfig) return null;
+
+			if (basePath) {
+				var tryName = path.join(root, basePath, source);
+				if (await fileExists(tryName)) {
+					previouslyMatched[source] = tryName;
+					return tryName;
+				}
+			}
+			if (paths) {
+				if (source.indexOf(root) === 0) return null;
+
+				var matchedPath = await findPathMatch(path.join(root, basePath), source, paths);
+
+				if (matchedPath) {
+					previouslyMatched[source] = matchedPath;
+					return matchedPath;
+				}
+			}
+
+			return null;
+		}
+	}
+}

package/plugin-loader.js

@@ -1,43 +1,59 @@
-function makeSource(loadables) {
+import path from 'node:path/posix';
+import {readFile, writeFile, stat} from 'node:fs/promises';
+import {fixPath} from './utils.js';
+var templateSource;
 
+function makeSource(loadables) {
 	var loadableSwitches = '';
 
+	function makeCss(loadable) {
+		if (!loadable.css) return '';
+		var jsonCss = JSON.stringify(loadable.css);
+		return (
+`						App.loadCss(${jsonCss});`
+		)
+
+	}
+
+	function makeServices(loadable) {
+		if (!loadable.prefix) return '';
+		return (
+`						await registry.start('${loadable.prefix}');`
+		)
+	}
+
 	loadables.forEach(function(loadable) {
 		var prefixStr = ';';
+		var cssStr = makeCss(loadable);
+		var serviceStr = makeServices(loadable);
 
-		if (loadable.prefix) {
+		if (loadable.prefix || loadable.css) {
 			prefixStr = `
 					.then(async function(result) {
-						await registry.start('${loadable.prefix}');
-						return result;
+${cssStr}
+${serviceStr}
 					});
 `
 		}
 
-		var switchStr = `
-			case '${loadable.name}':
+		var switchStr =
+`			case '${loadable.name}':
 				promise = import('${loadable.path}')${prefixStr}
 				break;
 `
 		loadableSwitches += switchStr;
 	})
 
-	var source =
-`
-	import {registry} from '@polylith/core';
+	var source = templateSource;
+	var source = source.replace('{{SWITCHES}}', loadableSwitches);
+	var source = source.replace(/\t/g, '    ');
 
-	export async function load(name) {
-		var promise;
+	console.log(source);
 
-		switch (name) {
-${loadableSwitches}
-		}
-		return promise;
-	}
-`
 	return source;
 }
 
+
 export default function loader(loadables) {
 	return {
 		name: 'loader',
@@ -49,7 +65,13 @@ export default function loader(loadables) {
 			return null;
 		},
 
-		load (id) {
+		async load (id) {
+			var root = path.dirname(fixPath(import.meta.url));
+			if (!templateSource) {
+				templateSource = await readFile(path.join(root, 'loaderTemplate.txt'), 'utf-8');
+				console.log(templateSource);
+			}
+
 			if (id === '@polylith/loader') {
 				return makeSource(loadables);
 			}

package/utils.js

@@ -0,0 +1,20 @@
+import path from 'node:path/posix';
+import {readFile, writeFile, stat} from 'node:fs/promises';
+
+export function fixPath(src) {
+	src = src.replace('file:', '');
+	src = src.replace('///', '');
+	src = src.replace(/.:/, '');
+	src = src.replace(/\\/g, '/');
+
+	return src;
+}
+
+async function fileExists(path) {
+    try {
+        await stat(path)
+        return true;
+    } catch (e) {
+        return false;
+    }
+}