wirejs-scripts 2.0.5 → 3.0.0

package/bin.js

@@ -1,51 +1,389 @@
 #!/usr/bin/env node
 
-const process = require('process');
-const rimraf = require('rimraf');
-const fs = require('fs');
-const path = require('path');
+import process from 'process';
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
 
-const webpack = require('webpack');
-const webpackConfigure = require('./configs/webpack.config');
-const WebpackDevServer = require('webpack-dev-server');
+import webpack from 'webpack';
+import webpackConfigure from './configs/webpack.config.js';
+import { rimraf } from 'rimraf';
+
+import { JSDOM } from 'jsdom';
+import { useJSDOM } from 'wirejs-dom/v2';
+import { requiresContext, Context, CookieJar } from '../wirejs-resources/lib/types.js';
 
 const CWD = process.cwd();
 const webpackConfig = webpackConfigure(process.env, process.argv);
 const [_nodeBinPath, _scriptPath, action] = process.argv;
 const processes = [];
 
+const logger = {
+	log(...items) {
+		console.log('wirejs', ...items);
+	},
+	error(...items) {
+		console.error('wirejs ERROR', ...items);
+	},
+	info(...items) {
+		console.info('wirejs', ...items);
+	},
+	warn(...items) {
+		console.warn('wirejs', ...items);
+	}
+};
+
+const oldFetch = globalThis.fetch;
+globalThis.fetch = (url, ...args) => {
+	if (typeof url === 'string') {
+		try {
+			return fetch(new URL(url), ...args);
+		} catch {
+			return fetch(`http://localhost:3000${url}`, ...args);
+		}
+	} else {
+		return oldFetch(url, ...args);
+	}
+}
+
+/**
+ * 
+ * @param {http.IncomingMessage} req 
+ * @returns 
+ */
+function createContext(req) {
+	const { url, headers } = req;
+	const origin = headers.origin || `http://${headers.host}`;
+	const location = new URL(`${origin}${url}`);
+	const cookies = new CookieJar(headers.cookie);
+	return new Context({ cookies, location });
+}
+
+/**
+ * 
+ * @param {object} api
+ * @param {{method: string, args: any[]}} call
+ * @param {Context} context
+ * @returns {Promise<any>}
+ */
+async function callApiMethod(api, call, context) {
+	try {
+		const [scope, ...rest] = call.method;
+		logger.info('api method parsed', { scope, rest });
+		if (rest.length === 0) {
+			logger.info('api method resolved. invoking...');
+			if (requiresContext(api[scope])) {
+				return {
+					data: await api[scope](context, ...call.args.slice(1))
+				};
+			} else {
+				return {
+					data: await api[scope](...call.args)
+				};
+			}
+		} else {
+			logger.info('nested scope found');
+			return callApiMethod(api[scope], {
+				...call,
+				method: rest,
+			}, context);
+		}
+	} catch (error) {
+		return { error: error.message };
+	}
+}
+
+/**
+ * 
+ * @param {http.IncomingMessage} req 
+ * @param {http.ServerResponse} res 
+ * @returns 
+ */
+async function handleApiResponse(req, res) {
+	const {
+		headers, url, method, params, query,
+		baseUrl, originalUrl, trailers
+	} = req;
+
+	const context = createContext(req);
+
+	if (url === '/api') {
+		const body = await postData(req);
+		const calls = JSON.parse(body);
+		logger.info('handling API request', body);
+
+		const apiPath = path.join(CWD, 'api', 'index.js');
+		const api = await import(`${apiPath}?cache-id=${new Date().getTime()}`);
+
+		const responses = [];
+		for (const call of calls) {
+			logger.info('handling API call', call);
+			responses.push(await callApiMethod(api, call, context));
+		}
+
+		logger.info('setting cookies', context.cookies.getSetCookies());
+		for (const cookie of context.cookies.getSetCookies()) {
+			const cookieOptions = [];
+			if (cookie.maxAge) cookieOptions.push(`Max-Age=${cookie.maxAge}`);
+			if (cookie.httpOnly) cookieOptions.push('HttpOnly');
+			if (cookie.secure) cookieOptions.push('Secure');
+			
+			logger.info('setting cookie', cookie.name, cookie.value, cookieOptions);
+			res.appendHeader(
+				'Set-Cookie',
+				`${cookie.name}=${cookie.value}; ${cookieOptions.join('; ')}`
+			);
+		}
+
+		res.setHeader('Content-Type', 'application/json; charset=utf-8')
+		res.end(JSON.stringify(
+			responses
+		));
+	} else {
+		logger.error('Bad endpoint given', { url });
+
+		res.statusCode = 404;
+		res.end("404 - Endpoint not found");
+	}
+}
+
+/**
+ * 
+ * @param {http.IncomingMessage} req 
+ * @returns 
+ */
+function fullPathFrom(req) {
+	const relativePath = req.url === '/' ? 'index.html' : req.url;
+	return path.join(CWD, 'dist', relativePath);
+}
+
+
+/**
+ * 
+ * @param {http.IncomingMessage} req 
+ * @param {http.ServerResponse} res 
+ * @returns 
+ */
+async function tryStaticPath(req, res) {
+	const fullPath = fullPathFrom(req);
+
+	logger.info('checking static', fullPath);
+	if (!fs.existsSync(fullPath)) return false;
+	logger.info('static found');
+
+	if (fullPath.endsWith(".html")) {
+		res.setHeader('Content-Type', 'text/html; charset=utf-8');
+	} else if (fullPath.endsWith(".js")) {
+		res.setHeader('Content-Type', 'text/javascript; charset=utf-8');
+	} else {
+		res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+	}
+
+	try {
+		res.end(fs.readFileSync(fullPath));
+	} catch {
+		res.statusCode = 404;
+		res.end("404 - File not found (b)");
+	}
+
+	return true;
+}
+
+/**
+ * Compare two strings by length for sorting in order of increasing length.
+ * 
+ * @param {string} a 
+ * @param {string} b 
+ * @returns 
+ */
+function byLength(a, b) {
+    return a.length - b.length;
+}
+
+/**
+ * @param {string} pattern - string pattern, where `*` matches anything
+ * @param {string} text 
+ * @returns 
+ */
+function globMatch(pattern, text) {
+    const parts = pattern.split('*');
+    const regex = new RegExp(parts.join('.+'));
+    return regex.test(text);
+}
+
+/**
+ * 
+ * @param {Context} context 
+ * @param {string} [forceExt]
+ */
+function routeSSR(context, forceExt) {
+	const SSR_ROOT = path.join(CWD, 'dist', 'ssr');
+	const asJSPath = forceExt ?
+		context.location.pathname.replace(/\.(\w+)$/, `.${forceExt}`)
+		: context.location.pathname
+	;
+	const allHandlers = fs.readdirSync(SSR_ROOT, { recursive: true })
+		.filter(p => p.endsWith('.js'))
+		.map(p => `/${p}`)
+	;
+	const matchingHandlers = allHandlers.filter(h => globMatch(h, asJSPath));
+	const match = matchingHandlers.sort(byLength).pop();
+
+	if (match) {
+		return path.join(SSR_ROOT, match);
+	}
+}
+
+/**
+ * @param {http.IncomingMessage} req 
+ * @param {http.ServerResponse} res 
+ * @returns 
+ */
+async function trySSRScriptPath(req, res) {
+	const context = createContext(req);
+	const srcPath = routeSSR(context);
+	if (!srcPath) return false;
+
+	logger.info('SSR handler associated script found', srcPath);
+
+	res.setHeader('Content-Type', 'text/javascript');
+
+	try {
+		res.end(fs.readFileSync(srcPath));
+	} catch {
+		res.statusCode = 404;
+		res.end("404 - File not found (c)");
+	}
+
+	return true;
+}
+
+/**
+ * 
+ * @param {http.IncomingMessage} req
+ * @param {http.ServerResponse} res
+ * @returns 
+ */
+async function trySSRPath(req, res) {
+	const context = createContext(req);
+
+	const asJSPath = context.location.pathname.replace(/\.(\w+)$/, '.js');
+	const srcPath = routeSSR(context, 'js');
+	if (!srcPath) return false;
+
+	logger.info('SSR handler found', srcPath);
+
+	try {
+		useJSDOM(JSDOM);
+		global.self = global.window;
+		await import(`${srcPath}?cache-id=${new Date().getTime()}`);
+		const module = self.exports;
+		console.log({module});
+		if (typeof module.generate === 'function') {
+			const doc = await module.generate(context);
+			const doctype = doc.parentNode.doctype?.name || '';
+
+			let hydrationsFound = 0;
+			while (globalThis.pendingDehydrations?.length > 0) {
+				globalThis.pendingDehydrations.shift()(doc);
+				hydrationsFound++;
+			}
+
+			if (hydrationsFound) {
+				const script = doc.parentNode.createElement('script');
+				script.src = asJSPath;
+				doc.parentNode.body.appendChild(script);
+			}
+
+			res.setHeader('Content-type', 'text/html; charset=utf-8')
+			res.end([
+				doctype ? `<!doctype ${doctype}>\n` : '',
+				doc.outerHTML
+			].join(''));
+
+			return true;
+		} else {
+			logger.info('SSR module missing generate function');
+			return false;
+		}
+	} catch (error) {
+		logger.error('ssr error', error);
+		res.statusCode = 404;
+		res.end("404 - File not found (a)");
+	}
+
+	return true;
+}
+
+/**
+ * 
+ * @param {http.IncomingMessage} req 
+ * @param {http.ServerResponse} res 
+ * @param {any} compiler 
+ * @returns 
+ */
+async function handleRequest(req, res, compiler) {
+	logger.info('received', JSON.stringify({ url: req.url }, null, 2));
+
+	if (req.url.startsWith('/api')) {
+		return handleApiResponse(req, res, compiler);
+	}
+
+	// const fs = compiler.outputFileSystem;
+
+	if (await tryStaticPath(req, res, fs)) return;
+	if (await trySSRScriptPath(req, res, fs)) return;
+	if (await trySSRPath(req, res, fs)) return;
+
+	// if we've made it this far, we don't have what you're looking for
+	res.statusCode = '404';
+	res.end('404 - Not found');
+}
+
+/**
+ * 
+ * @param {http.IncomingMessage} request 
+ * @returns 
+ */
+async function postData(request) {
+	return new Promise((resolve, reject) => {
+		const buffer = [];
+		const timeout = setTimeout(() => {
+			reject("Post data not received.");
+		}, 5000);
+		request.on('data', data => buffer.push(data));
+		request.on('end', () => {
+			if (!timeout) return;
+			clearTimeout(timeout);
+			resolve(buffer.join(''));
+		});
+	});
+};
+
 async function compile(watch = false) {
-	const stats = await new Promise((resolve, reject) => {
+	const stats = await new Promise(async (resolve, reject) => {
+		let compiler;
 		if (watch) {
-			compiler = webpack({
+			webpack({
 				...webpackConfig,
-				mode: 'development'
-			});
+				mode: 'development',
+				watch: true
+			}, () => {}).run(() => {});
 
-			const server = new WebpackDevServer({
-				static: {
-					directory: path.join(CWD, 'dist')
-				},
-				open: true,
-			}, compiler);
-
-			console.log('Starting server...');
-			server.start().then(() => {
-				resolve({});
-			});
-
-			resolve({});
+			logger.log('Starting server...');
+			const server = http.createServer(handleRequest);
+			server.listen(3000);
 		} else {
-			console.log('wirejs instantiating webpack compiler');
+			logger.log('instantiating webpack compiler');
 			compiler = webpack(webpackConfig);
 			compiler.run((err, res) => {
-				console.log('wirejs invoking webpack compiler');
+				logger.log('invoking webpack compiler');
 				if (err) {
-					console.error('wirejs webpack compiler failed');
-					console.error(err);
+					logger.error('webpack compiler failed');
+					logger.error(err);
 					reject(err);
 				} else {
-					console.error('wirejs webpack compiler succeeded');
+					logger.error('webpack compiler succeeded');
 					resolve(res);
 				}
 			});
@@ -53,7 +391,7 @@ async function compile(watch = false) {
 	});
 
 	if (stats?.compilation?.errors?.length > 0) {
-		console.log('wirejs compilation errors', stats.compilation.errors);
+		logger.log('compilation errors', stats.compilation.errors);
 		throw new Error('Build failed.');
 	}
 
@@ -62,31 +400,30 @@ async function compile(watch = false) {
 
 const engine = {
 	async build({ watch = false } = {}) {
-		console.log('wirejs build starting');
+		logger.log('build starting');
 
 		rimraf.sync('dist');
-		console.log('wirejs cleared old dist folder');
+		logger.log('cleared old dist folder');
 
 		fs.mkdirSync('dist');
-		console.log('wirejs recreated dist folder');
+		logger.log('recreated dist folder');
 
 		try {
-
 			await compile(watch);
-			console.log('wirejs finished compile');
+			logger.log('finished compile');
 		} catch (err) {
-			console.log(err);
+			logger.error(err);
 		}
-		console.log('wirejs build finished')
+		logger.log('build finished')
 	},
 
 	async start() {
-		console.log('wirejs starting')
+		logger.log('starting')
 		this.build({ watch: true });
 
 		await new Promise(resolve => {
 			function exitGracefully() {
-				console.log('Exiting gracefully ...');
+				logger.log('Exiting gracefully ...');
 				processes.forEach(p => p.kill());
 				resolve();
 			}
@@ -95,17 +432,17 @@ const engine = {
 		});
 
 		// explicit exit forces lingering child processes to die.
-		console.log('wirejs stopping')
+		logger.log('stopping')
 		process.exit();
 	}
 
 };
 
 if (typeof engine[action] === 'function') {
-	console.log(`Running ${action} ... `);
+	logger.log(`Running ${action} ... `);
 	engine[action]().then(() => {
-		console.log('All done!');
+		logger.log('All done!');
 	});
 } else {
-	console.error(`Invalid wirejs-scripts action: ${action}`);
-}
+	logger.error(`Invalid wirejs-scripts action: ${action}`);
+}

package/configs/webpack.config.js

@@ -1,10 +1,12 @@
-const fs = require('fs');
-const path = require('path');
-const glob = require('glob');
-const { exec } = require('child_process');
-const process = require('process');
-const CopyWebpackPlugin = require('copy-webpack-plugin');
-const marked = require('marked');
+import { useJSDOM } from 'wirejs-dom/v2';
+import fs from 'fs';
+import path from 'path';
+import glob from 'glob';
+import process from 'process';
+import CopyWebpackPlugin from 'copy-webpack-plugin';
+import marked from 'marked';
+import { JSDOM } from 'jsdom';
+
 
 const CWD = process.cwd();
 
@@ -25,20 +27,14 @@ const BUILD_ID = (new Date()).getTime();
 
 fs.writeFileSync('./src/build_id.json', JSON.stringify(BUILD_ID.toString()));
 
-
-// TODO: Refactor these transforms out of here.
-// TODO: Create a separate package to manage all of this for easy reuse on
-// other projects.
-// TODO: consider whether using the front-end framework for SSG would be safe,
-// and intuitive, rather than having two completely separate rendering modes.
-
-function distPath({ subpathOut = '', subpathIn = '' } = {}) {
+function distPath({ subpathOut = '', subpathIn = '', extensionOut } = {}) {
 	return function ({ context, absoluteFilename }) {
 		const prefixIn = path.resolve(context, subpathIn);
 		const prefixOut = path.resolve(context, 'dist', subpathOut);
 		const relativeName = path.join('./', absoluteFilename.slice(prefixIn.toString().length));
-		const fullOutPath = path.resolve(prefixOut, relativeName)
-			.replace(/\.md$/, ".html");
+		const fullOutPath = extensionOut ?
+			path.resolve(prefixOut, relativeName).replace(/\.\w+$/, ".html")
+			: path.resolve(prefixOut, relativeName);
 		console.log(`Mapping ${relativeName} to ${fullOutPath}`);
 		return fullOutPath;
 	};
@@ -57,58 +53,15 @@ const CollectLayouts = {
 const SSG = {
 	transformer: async (content, _path) => {
 		let _meta = {};
-		function meta(o) {
-			_meta = o;
-			return '';
-		}
-
-		const _require = require;
-		const WD = path.dirname(_path);
 
 		let body;
 		try {
-			require = (requirePath) => {
-				const absolutePath = _require.resolve(requirePath, {paths: [WD]});
-				return _require(absolutePath);
-			}
-
-			if (_path.endsWith('.md')) {
-				let isInCodeBlock = false;
-				const escapedMarkdown = content.toString().split(/\n/)
-					.reduce((lines, line) => {
-						if (isInCodeBlock) {
-							lines[lines.length - 1] += "\n" + line;
-						} else {
-							lines.push(line);
-						}
-						if (line.startsWith('```')) {
-							isInCodeBlock = !isInCodeBlock;
-						}
-						return lines;
-					}, [])
-					.map(l => l.trim()).join('\n')
-					.replace(/(``+)/g, m => Array(m.length).fill('\\`').join(''))
-				;
-				const bodyMarkdown = eval('`' + escapedMarkdown + '`');
-				body = marked(bodyMarkdown);
-			} else {
-				body = eval('`' + content + '`');
-			}
+            body = _path.endsWith('.md') ? marked(content.toString()) : content.toString();
 		} catch (err) {
 			console.error(`Could not parse page ${_path}`, err);
 			throw err;
-		} finally {
-			require = _require;
 		}
 
-		const metatags = Object.entries(_meta).map(([tag, content]) => {
-			tag = tag.replace(/"/g, '"');
-			content = content.replace(/"/g, '"');
-			return `<meta name="${tag}" content="${content}" />`;
-		}).join('\n');
-
-		let title = _meta.title;
-
 		// apply no layout if the document has already provided the
 		// overarching html structure.
 		if (!_meta.layout && body && (
@@ -127,7 +80,7 @@ const SSG = {
 		const layout = layouts[layoutPath];
 
 		try {
-			return eval('`' + layout + '`');
+			return layout;
 		} catch (err) {
 			console.error(`Could not parse layout ${layoutPath}`, err);
 			throw err;
@@ -135,7 +88,47 @@ const SSG = {
 	}
 };
 
-module.exports = (env, argv) => {
+const Generated = {
+	transformer: async (content, contentPath) => {
+		useJSDOM(JSDOM);
+
+		try {
+			if (contentPath.endsWith('.js')) {
+				const module = await import(contentPath);
+				if (typeof module.generate === 'function') {
+					const doc = await module.generate(contentPath);
+					const doctype = doc.parentNode.doctype?.name || '';
+
+					let hydrationsFound = 0;
+					while (globalThis.pendingDehydrations?.length > 0) {
+						globalThis.pendingDehydrations.shift()(doc);
+						hydrationsFound++;
+					}
+
+					if (hydrationsFound) {
+						const script = doc.parentNode.createElement('script');
+						script.src = contentPath.substring((CWD + '/src/ssg').length);
+						doc.parentNode.body.appendChild(script);
+					}
+
+					return [
+						doctype ? `<!doctype ${doctype}>\n` : '',
+						doc.outerHTML
+					].join('');
+				} else {
+					return;
+				}
+			} else {
+				return content.toString();
+			}
+		} catch (err) {
+			console.error(`Could not generate page ${contentPath}`, err);
+			throw err;
+		}
+	}
+};
+
+export default (env, argv) => {
 	var devtool = 'source-map';
 	if (argv.mode == 'development') {
 		devtool = 'eval-cheap-source-map';
@@ -144,10 +137,17 @@ module.exports = (env, argv) => {
 	const sources = ['./src/index.js']
 		.concat(glob.sync('./src/layouts/**/*.js'))
 		.concat(glob.sync('./src/routes/**/*.js'))
+		.concat(glob.sync('./src/ssg/**/*.js'))
+		.concat(glob.sync('./src/ssr/**/*.js'))
 	;
 
 	const entry = sources.reduce((files, path) => {
-		if (path.match(/src\/routes/)) {
+		if (path.match(/src\/ssg/)) {
+			files[path.toString().slice('./src/ssg'.length)] = path;
+		} else if (path.match(/src\/ssr/)) {
+			// keep SSR bundles in the ssr subfolder
+			files[path.toString().slice('./src'.length)] = path;
+		} else if (path.match(/src\/routes/)) {
 			files[path.toString().slice('./src/routes'.length)] = path;
 		} else if (path.match(/src\/layouts/)) {
 			files[path.toString().slice('./src/'.length)] = path;
@@ -156,17 +156,12 @@ module.exports = (env, argv) => {
 	}, {});
 
 	return {
-		/*
-		devServer: {
-			contentBase: path.join(CWD, 'dist'),
-			compress: true,
-			open: true,
-			port: 9999,
-			watchContentBase: true,
-			// liveReload: true,
-			// hot: true
+		// here's where we might need to select different "import" conditions,
+		// which match with `exports: { path: { condition: "" } }` in package.json
+		// for different build types for API's, SSR, etc.
+		resolve: {
+			conditionNames: ['wirejs:client'],
 		},
-		*/
 		watchOptions: {
 			ignored: [
 				"**/dist/*",
@@ -178,8 +173,13 @@ module.exports = (env, argv) => {
 		},
 		entry,
 		output: {
-			filename: "[name]"
+			filename: "[name]",
+			library: {
+				type: 'global',
+				name: 'exports'
+			}
 		},
+		target: 'web',
 		devtool,
 		plugins: [
 
@@ -210,72 +210,79 @@ module.exports = (env, argv) => {
 						priority: 10,
 					},
 					{
-						from: './src/routes/**/*.md',
-						to: distPath({ subpathIn: 'src/routes' }),
-						transform: SSG,
+						from: './src/ssg/**/*.js',
+						to: distPath({ subpathIn: 'src/ssg', extensionOut: 'html' }),
+						transform: Generated,
 						noErrorOnMissing: true,
-						priority: 3,
-					},
-					{
-						from: './src/routes/**/*.html',
-						to: distPath({ subpathIn: 'src/routes' }),
-						transform: SSG,
-						noErrorOnMissing: true,
-						priority: 3,
-					},
-					{
-						from: './src/routes/**/*.xml',
-						to: distPath({ subpathIn: 'src/routes' }),
-						transform: SSG,
-						noErrorOnMissing: true,
-						priority: 3,
-					},
-					{
-						from: './src/routes/**/*.rss',
-						to: distPath({ subpathIn: 'src/routes' }),
-						transform: SSG,
-						noErrorOnMissing: true,
-						priority: 3,
-					},
-					{
-						from: './src/routes/**/*.css',
-						to: distPath({ subpathIn: 'src/routes' }),
-						noErrorOnMissing: true,
-						// trasform: ???
-						priority: 3,
-					},
-					{
-						from: './src/routes/**/*.png',
-						to: distPath({ subpathIn: 'src/routes' }),
-						noErrorOnMissing: true,
-						priority: 3,
-					},
-					{
-						from: './src/routes/**/*.jpg',
-						to: distPath({ subpathIn: 'src/routes' }),
-						noErrorOnMissing: true,
-						priority: 3,
-					},
-					{
-						from: './src/routes/**/*.json',
-						to: distPath({ subpathIn: 'src/routes' }),
-						noErrorOnMissing: true,
-						priority: 3,
-					},
-					{
-						from: './src/routes/**/*.svg',
-						to: distPath({ subpathIn: 'src/routes' }),
-						noErrorOnMissing: true,
-						priority: 3,
-					},
-					{
-						from: './src/routes/**/*.mp3',
-						to: distPath({ subpathIn: 'src/routes' }),
-						noErrorOnMissing: true,
-						priority: 3,
+						priority: 5
 					},
+					// {
+					// 	from: './src/routes/**/*.md',
+					// 	to: distPath({ subpathIn: 'src/routes' }),
+					// 	transform: SSG,
+					// 	noErrorOnMissing: true,
+					// 	priority: 3,
+					// },
+					// {
+					// 	from: './src/routes/**/*.html',
+					// 	to: distPath({ subpathIn: 'src/routes' }),
+					// 	transform: SSG,
+					// 	noErrorOnMissing: true,
+					// 	priority: 3,
+					// },
+					// {
+					// 	from: './src/routes/**/*.xml',
+					// 	to: distPath({ subpathIn: 'src/routes' }),
+					// 	transform: SSG,
+					// 	noErrorOnMissing: true,
+					// 	priority: 3,
+					// },
+					// {
+					// 	from: './src/routes/**/*.rss',
+					// 	to: distPath({ subpathIn: 'src/routes' }),
+					// 	transform: SSG,
+					// 	noErrorOnMissing: true,
+					// 	priority: 3,
+					// },
+					// {
+					// 	from: './src/routes/**/*.css',
+					// 	to: distPath({ subpathIn: 'src/routes' }),
+					// 	noErrorOnMissing: true,
+					// 	// trasform: ???
+					// 	priority: 3,
+					// },
+					// {
+					// 	from: './src/routes/**/*.png',
+					// 	to: distPath({ subpathIn: 'src/routes' }),
+					// 	noErrorOnMissing: true,
+					// 	priority: 3,
+					// },
+					// {
+					// 	from: './src/routes/**/*.jpg',
+					// 	to: distPath({ subpathIn: 'src/routes' }),
+					// 	noErrorOnMissing: true,
+					// 	priority: 3,
+					// },
+					// {
+					// 	from: './src/routes/**/*.json',
+					// 	to: distPath({ subpathIn: 'src/routes' }),
+					// 	noErrorOnMissing: true,
+					// 	priority: 3,
+					// },
+					// {
+					// 	from: './src/routes/**/*.svg',
+					// 	to: distPath({ subpathIn: 'src/routes' }),
+					// 	noErrorOnMissing: true,
+					// 	priority: 3,
+					// },
+					// {
+					// 	from: './src/routes/**/*.mp3',
+					// 	to: distPath({ subpathIn: 'src/routes' }),
+					// 	noErrorOnMissing: true,
+					// 	priority: 3,
+					// },
 				],
-			})
+			}),
 		],
 		module: {
 			rules: [
@@ -316,4 +323,4 @@ module.exports = (env, argv) => {
 			]
 		}
 	};
-};
+};

package/package.json

@@ -1,33 +1,39 @@
-{
-  "name": "wirejs-scripts",
-  "version": "2.0.5",
-  "description": "Basic build and start commands for wirejs apps",
-  "bin": {
-    "wirejs-scripts": "./bin.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/svidgen/wirejs-scripts.git"
-  },
-  "author": "Jon Wire",
-  "license": "AGPL-3.0-only",
-  "bugs": {
-    "url": "https://github.com/svidgen/wirejs-scripts/issues"
-  },
-  "homepage": "https://github.com/svidgen/wirejs-scripts#readme",
-  "dependencies": {
-    "copy-webpack-plugin": "^10.2.4",
-    "css-loader": "^5.2.0",
-    "file-loader": "^6.2.0",
-    "glob": "^7.2.0",
-    "marked": "^2.0.1",
-    "raw-loader": "^4.0.2",
-    "rimraf": "^3.0.2",
-    "style-loader": "^2.0.0",
-    "webpack": "^5.28.0",
-    "webpack-cli": "^4.6.0",
-    "webpack-dev-server": "^4.8.1",
-    "highlight.js": "^11.1.0",
-    "wirejs-dom": "^1.0.4"
-  }
-}
+{
+	"name": "wirejs-scripts",
+	"version": "3.0.0",
+	"description": "Basic build and start commands for wirejs apps",
+	"type": "module",
+	"bin": {
+		"wirejs-scripts": "./bin.js"
+	},
+	"scripts": {
+		"build": "echo \"Nothing to build\"",
+		"clean": "echo \"Nothing to clean\""
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/svidgen/create-wirejs-app.git"
+	},
+	"author": "Jon Wire",
+	"license": "AGPL-3.0-only",
+	"bugs": {
+		"url": "https://github.com/svidgen/create-wirejs-app/issues"
+	},
+	"homepage": "https://github.com/svidgen/create-wirejs-app#readme",
+	"dependencies": {
+		"copy-webpack-plugin": "^10.2.4",
+		"css-loader": "^5.2.0",
+		"file-loader": "^6.2.0",
+		"glob": "^7.2.0",
+		"highlight.js": "^11.1.0",
+		"jsdom": "^25.0.1",
+		"marked": "^2.0.1",
+		"raw-loader": "^4.0.2",
+		"rimraf": "^6.0.1",
+		"style-loader": "^2.0.0",
+		"webpack": "^5.97.1",
+		"webpack-cli": "^6.0.1",
+		"webpack-dev-server": "^5.2.0",
+		"wirejs-dom": "^1.0.34"
+	}
+}

package/.gitattributes

@@ -1 +0,0 @@
-* text=auto