@polylith/builder 0.0.31 → 0.0.33

package/App.js

@@ -11,6 +11,8 @@ 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 ConfigFeature from './ConfigFeature.js';
 import Files from './Files.js';
@@ -52,7 +54,7 @@ export default class App {
 		this.root = root;
 
 		var filename = path.posix.join(root, index);
-		this.sourcePath = path.posix.join(root, path.posix.dirname(filename));
+		this.sourcePath = path.posix.dirname(filename);
 		this.destPath = path.posix.join(root, dest);
 
 		this.name = name;
@@ -65,7 +67,7 @@ export default class App {
 		this.configs = {};
 		this.manualChunkType = 'function';
 		this.manualChunks = [];
-		this.files = new Files(sourcePath, destPath)
+		this.files = new Files(this.sourcePath, this.destPath)
 	}
 
 	static fileToPath(filename) {
@@ -158,7 +160,7 @@ export default class App {
 	 * 		the application source folder.
 	 */
 	addFeatureIndex(index) {
-		this.featureIndexes.push(index);
+		this.featureIndexes.push(path.join(this.sourcePath, index));
 	}
 
 	/**
@@ -325,7 +327,20 @@ export default class App {
 	 * 		ready methods will be called on all services starting with this
 	 * 		prefix.
 	 */
-	addLoadable(name, main, prefix) {
+	async addLoadable(name, main, prefix, css) {
+		// expand css specs
+		var files = new Files(this.sourcePath, this.destPath)
+		resourceSpecs.forEach(function(spec) {
+			files.addCopySpec(root, spec);
+		}, this)
+		var cssUris = [];
+		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});
 	}
@@ -364,6 +379,7 @@ export default class App {
 					}),
 					loader(this.loadables),
 					features(this.featureIndexes),
+					jsconfig(this.root),
 					html({
 						include: path.join(this.sourcePath, "**/*.html"),
 					}),
@@ -373,7 +389,8 @@ export default class App {
 						source: this.htmlTemplate.source,
 						destination: this.htmlTemplate.destination,
 						replaceVars: {},
-					})
+					}),
+					resources(this.name, this.files)
 				],
 			},
 			output : {
@@ -425,7 +442,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

@@ -1,9 +1,9 @@
-import App from './App';
+import App from './App.js';
 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 {
 	/**
@@ -22,12 +23,12 @@ export default class ConfigFeature extends Feature {
 		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);
+					app.addLoadable(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);
 	}

package/Files.js

@@ -1,6 +1,8 @@
 import fg from 'fast-glob';
 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
@@ -35,7 +37,7 @@ export default class Files {
 	 * @param {String} src the abolute path to the applications source
 	 *  directory
 	 */
-	constructor(dest, src) {
+	constructor(src, dest) {
 		this.dest = dest;
 		this.src = src;
 		this.files = {};
@@ -57,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
@@ -73,20 +97,43 @@ export default class Files {
 		// Since file paths here are absolute tthis will always be based on the
 		// string length.
 		files.forEach(function(file) {
+			file = App.fixPath(file);
 			// reconcile conflicts
 			if (this.files[file]) {
-				copyInfo = 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] = {
 				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
@@ -98,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(searchPath, spec.glob);
-			let files = await fg(fullGlob, options);
-
-			this.addFiles(searchRoot, files, spec);
+			await this.findFiles(spec);
 		}
 
-		return this.files
+		return this.files;
 	}
 
 	/**
@@ -124,28 +159,17 @@ export default class Files {
 		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));
-			}
-
+			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(path.dirname(destinationFilePath));
-					await fs.copyFiles(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.js

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

package/package.json

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

package/plugin-copy-resources.js

@@ -1,18 +1,23 @@
+var copied= {}
+
 /**
  *
  * @param {Files} files the files object that specifies the resource files to
  *  copy
  * @returns {Object} the plugin
  */
-export default function(files) {
+export default function(name, files) {
 	return {
-		name: "main-html-template",
+		name: "main-html-resources",
 
 		async generateBundle(outputOptions, bundleInfo) {
+			// assets are not watched, never copy more than once
+			if (copied[name]) return;
 			return new Promise(async function (resolve, reject) {
 				try {
 					await files.copyFiles();
 					resolve(true)
+					copied[name] = true;
 				} catch (e) {
 					reject(e)
 				}

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,15 +1,45 @@
-function makeSource(loadables) {
+import path from 'node:path/posix';
+import {readFile, writeFile, stat} from 'node:fs/promises';
+var templateSource;
+
+async function fileExists(path) {
+    try {
+        await stat(path)
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
 
+function makeSource(loadables) {
 	var loadableSwitches = '';
 
+	function makeCss() {
+		if (!loadable.css) return '';
+		var jsonCss = JSON.stringify(loadable.css);
+		return (
+`						App.loadCss(${jsonCss});`
+		)
+
+	}
+
+	function makeServices() {
+		if (!loadable.prefix) return '';
+		return (
+`						await registry.start('${loadable.prefix}');`
+		)
+	}
+
 	loadables.forEach(function(loadable) {
 		var prefixStr = ';';
+		var cssStr = makeCss();
+		var serviceStr = makeServices();
 
-		if (loadable.prefix) {
+		if (loadable.prefix || loadable.css) {
 			prefixStr = `
 					.then(async function(result) {
-						await registry.start('${loadable.prefix}');
-						return result;
+${cssStr}
+${serviceStr}
 					});
 `
 		}
@@ -22,19 +52,9 @@ function makeSource(loadables) {
 		loadableSwitches += switchStr;
 	})
 
-	var source =
-`
-	import {registry} from '@polylith/core';
-
-	export async function load(name) {
-		var promise;
+	var source = templateSource;
+	var source = source.replace('{{SWITCHES}}', loadableSwitches);
 
-		switch (name) {
-${loadableSwitches}
-		}
-		return promise;
-	}
-`
 	return source;
 }
 
@@ -49,7 +69,10 @@ export default function loader(loadables) {
 			return null;
 		},
 
-		load (id) {
+		async load (id) {
+			if (templateSource) {
+				templateSource = await readFile('./loaderTemplate.js');
+			}
 			if (id === '@polylith/loader') {
 				return makeSource(loadables);
 			}