refactor: style and test discovery

packages/web/src/server/augment-build.js

@@ -7,7 +7,7 @@ const augmentBuild = (target, config, env, argv, flecks) => {
   switch (target) {
     case 'fleck': {
       finalLoader = {loader: MiniCssExtractPlugin.loader};
-      config.plugins.push(new MiniCssExtractPlugin({filename: '[name].css'}));
+      config.plugins.push(new MiniCssExtractPlugin({filename: 'assets/[name].css'}));
       break;
     }
     case 'server': {

packages/web/src/server/build/runtime.js

@@ -1,12 +1,13 @@
-const {readFile, realpath, stat} = require('fs/promises');
+const {access, readFile, realpath} = require('fs/promises');
 const {
+  basename,
   dirname,
+  extname,
   join,
 } = require('path');
 
 const {D} = require('@flecks/core');
-const {Flecks, require: R} = require('@flecks/core/server');
+const {Flecks, glob, require: R} = require('@flecks/core/server');
-const glob = require('glob');
 
 const debug = D('@flecks/web/runtime');
 
@@ -19,36 +20,23 @@ module.exports = async (config, env, argv, flecks) => {
   const rootMap = {};
   Object.keys(webFlecks.resolver)
     .forEach((fleck) => {
-      rootMap[webFlecks.root(fleck)] = fleck;
+      rootMap[fleck] = webFlecks.root(fleck);
     });
-  const roots = Object.entries(rootMap)
-    .map(([root, fleck]) => (
-      [fleck, dirname(R.resolve(join(root, 'package.json')))]
-    ));
   const styles = (
     await Promise.all(
-      roots
+      Object.entries(rootMap)
-        .map(([fleck, path]) => {
+        .map(async ([fleck, root]) => {
-          try {
+          // Compiled? It will be included with the compilation.
-            if (webFlecks.fleckIsCompiled(fleck)) {
+          if (webFlecks.fleckIsCompiled(fleck)) {
-              return [];
+            return undefined;
-            }
-            const {files} = R(join(path, 'package.json'));
-            return (
-              files
-                .filter((name) => name.match(/\.css$/))
-                .map((name) => join(path, name))
-            );
           }
-          catch (error) {
+          const fleckResolved = R.resolve(fleck);
-            return [];
+          const rootResolved = dirname(R.resolve(join(root, 'package.json')));
-          }
+          const sub = fleckResolved.slice(rootResolved.length + 1);
-        })
+          const style = join(rootResolved, 'assets', `${basename(sub, extname(sub))}.css`);
-        .flat()
-        .map(async (filename) => {
           try {
-            await stat(filename);
+            await access(style);
-            return filename;
+            return style;
           }
           catch (error) {
             return undefined;
@@ -112,25 +100,26 @@ module.exports = async (config, env, argv, flecks) => {
       });
   }
   // Styles.
-  // @todo Not necessary for compiled flecks.
   config.entry.index.push(...styles);
   // Tests.
   if (!isProduction) {
-    const testPaths = [];
+    // const testPaths = [];
-    roots.forEach(([fleck, root]) => {
+    const roots = Array.from(new Set(Object.entries(rootMap).map(([root]) => root)));
-      testPaths.push(...(
+    const testEntries = await Promise.all(
-        glob.sync(join(root, 'test/*.js'))
+      roots.map(async (root) => {
-          .map((path) => [fleck, path])
+        const paths = [];
-      ));
+        const resolved = dirname(__non_webpack_require__.resolve(root));
-      for (let i = 0; i < webFlecks.platforms.length; ++i) {
+        const rootTests = await glob(join(resolved, 'test', '*.js'));
-        testPaths.push(
+        paths.push(...rootTests);
-          ...(
+        const platformTests = await Promise.all(
-            glob.sync(join(root, `test/platforms/${webFlecks.platforms[i]}/*.js`))
+          webFlecks.platforms.map((platform) => (
-              .map((path) => [fleck, path])
+            glob(join(resolved, 'test', 'platforms', platform, '*.js'))
-          ),
+          )),
         );
-      }
+        paths.push(...platformTests.flat());
-    });
+        return [root, paths];
+      }),
+    );
     const tests = await realpath(R.resolve(
       join(webFlecks.resolve('@flecks/web'), 'server', 'build', 'tests'),
     ));
@@ -142,30 +131,16 @@ module.exports = async (config, env, argv, flecks) => {
           loader: runtime,
           options: {
             source: testsSource.replace(
-              "await import('@flecks/web/tests');",
+              "  await import('@flecks/web/tests');",
-              [
+              testEntries
-                'const tests = {};',
+                .filter(([, paths]) => paths.length > 0)
-                Object.entries(
+                .map(([root, paths]) => (
-                  testPaths
+                  [
-                    .reduce(
+                    `  describe('${root}', () => {`,
-                      (r, [fleck, path]) => ({
+                    `    ${paths.map((path) => `require('${path}');`).join('\n    ')}`,
-                        ...r,
+                    '  });',
-                        [fleck]: [...(r[fleck] || []), `require('${path}');`],
+                  ].join('\n')
-                      }),
+                )).join('\n\n'),
-                      {},
-                    ),
-                )
-                  .map(
-                    ([original, paths]) => (
-                      [
-                        `describe('${original}', () => {`,
-                        `  ${paths.join('\n  ')}`,
-                        '});',
-                      ].join('\n')
-                    ),
-                  ).join('\n'),
-                'await Promise.all(Object.values(tests));',
-              ].join('\n'),
             ),
           },
         },

packages/web/src/server/build/web.webpack.config.js

@@ -211,6 +211,10 @@ module.exports = async (env, argv, flecks) => {
     },
     plugins,
     resolve: {
+      // Resolve the generated `url(assets/*)` style paths.
+      alias: {
+        assets: '.',
+      },
       fallback: {
         buffer: R.resolve('buffer'),
         child_process: false,

packages/web/src/server/index.js

@@ -225,6 +225,11 @@ export const hooks = {
     'web',
     ...(flecks.get('@flecks/web/server.dll').length > 0 ? ['web-vendor'] : []),
   ],
+  '@flecks/fleck/server.packageJson': (json, compilation) => {
+    if (Object.keys(compilation.assets).some((filename) => filename.match(/^assets\//))) {
+      json.files.push('assets');
+    }
+  },
   '@flecks/web.config': async (req, flecks) => ({
     '@flecks/web/client': {
       appMountId: flecks.get('@flecks/web/server.appMountId'),