@normed/bundle 4.0.0 → 4.2.0

package/CHANGELOG.md

@@ -6,6 +6,16 @@ Given a version number MAJOR.MINOR.PATCH, increment the:
 2. MINOR version when you add functionality in a backwards compatible manner, and
 3. PATCH version when you make backwards compatible bug fixes.
 
+# 4.2.0
+
+* MINOR: supports a range of plugins, but these are undocumented.
+* MINOR: supports slightly better error returning, but this is not implemented across the board.
+
+# 4.1.0
+
+* MINOR: fixes building of entypoint pug files.
+* MINOR: updates error formatting to print less information, better.
+
 # 4.0.0
 
 * MAJOR: moves to a new package.json format

package/bundles/bin/cli.js

@@ -68580,6 +68580,34 @@ function groupBy(objs, extractSubgroupFuncs) {
   }
   return groups;
 }
+function keyBy(objs, extractKeyFuncs) {
+  const result = /* @__PURE__ */ new Map();
+  const knownKeys = [];
+  for (const obj of objs) {
+    const key = {};
+    for (const [keyName, extractKeyFunc] of Object.entries(extractKeyFuncs)) {
+      key[keyName] = extractKeyFunc(obj);
+    }
+    let knownKey = knownKeys.find(
+      (knownKey2) => Object.keys(knownKey2).length === Object.keys(key).length && Object.keys(knownKey2).every(
+        (k) => knownKey2[k] === key[k]
+      )
+    );
+    if (!knownKey) {
+      knownKey = key;
+      knownKeys.push(key);
+      result.set(knownKey, [obj]);
+    } else {
+      const group = result.get(knownKey);
+      if (group) {
+        group.push(obj);
+      } else {
+        throw new Error(`Keying failed in keyBy`);
+      }
+    }
+  }
+  return result;
+}
 function divide(list, divider) {
   const a = [];
   const b = [];
@@ -68876,6 +68904,68 @@ function mergeDeep(into, from) {
 }
 
 // pnp:/builds/normed/bundle/packages/bundle/src/errors.ts
+function combineErrorLogs(...logs) {
+  const combined = {
+    errors: [],
+    warnings: []
+  };
+  for (const log of logs) {
+    if (log.errors) {
+      combined.errors.push(...log.errors);
+    }
+    if (log.warnings) {
+      combined.warnings.push(...log.warnings);
+    }
+  }
+  return combined;
+}
+var WrappedErrors = class _WrappedErrors extends AggregateError {
+  constructor(errors, message, meta) {
+    var __super = (...args) => {
+      super(...args);
+      this.meta = meta;
+      return this;
+    };
+    if (Array.isArray(errors)) {
+      __super(errors, message);
+    } else {
+      __super(errors.errors ?? [], message);
+      this.warnings = errors.warnings ?? [];
+    }
+    this.name = "WrappedError";
+  }
+  warnings;
+  static fromErrorLog(errorLog, message, meta) {
+    return new _WrappedErrors(errorLog, message, meta);
+  }
+  static fromError(error, message, meta) {
+    return new _WrappedErrors([error], message, meta);
+  }
+  static fromErrors(errors, message, meta) {
+    return new _WrappedErrors(errors, message, meta);
+  }
+  static fromValue(value, message, meta) {
+    const error = asError(value);
+    return new _WrappedErrors([error], message, meta);
+  }
+  static fromValues(values, message, meta) {
+    const errors = values.map(asError);
+    return new _WrappedErrors(errors, message, meta);
+  }
+};
+function asError(value, meta) {
+  let error;
+  if (!(value instanceof Error)) {
+    error = new Error(String(value));
+  } else {
+    error = value;
+  }
+  if (meta) {
+    let existingMeta = error.meta ?? {};
+    error.meta = { ...existingMeta, ...meta };
+  }
+  return error;
+}
 var NoMatchingBuilder = class extends Error {
   file;
   ext;
@@ -68900,6 +68990,14 @@ var copyBuilder = {
         copy(infile.absolute, outfile.absolute);
       })
     );
+    return {
+      warnings: [],
+      errors: [],
+      watchFiles: entrypoints.map((e) => e.infile),
+      watchDirs: [],
+      producedFiles: entrypoints.map((e) => e.outfile),
+      completed: true
+    };
   }
 };
 
@@ -69028,6 +69126,30 @@ var load_less_default = plugin;
 var import_pug = __toESM(require_lib14());
 var import_fs4 = __toESM(require("fs"));
 var import_path5 = __toESM(require("path"));
+function pugTransformer(test, onFound) {
+  return {
+    preCodeGen(ast) {
+      const pending = [...ast?.nodes || []];
+      const found = [];
+      while (pending.length > 0) {
+        const node = pending.shift();
+        if (!node) continue;
+        if (node.block?.nodes) {
+          pending.push(...node.block.nodes);
+        }
+        if (!test(node)) continue;
+        found.push(node);
+      }
+      if (found.length) {
+        onFound(found);
+      }
+      return ast;
+    }
+  };
+}
+function isScriptNodeWithSrcAttr(node) {
+  return node.name === "script" && node.attrs.some((attr) => attr.name === "src");
+}
 async function loadAsText2(_filepath) {
   return {
     loader: "text"
@@ -69035,33 +69157,59 @@ async function loadAsText2(_filepath) {
     // as well - its probably faster than us doing it in JS.
   };
 }
-async function loadAsJS2(filepath) {
+async function loadAsJS2(filepath, options2) {
   const fileData = await import_fs4.default.promises.readFile(filepath, "utf8");
-  const contents = "export default " + import_pug.default.compileClient(fileData, { name: "render" });
+  const contents = "export default " + import_pug.default.compileClient(fileData, {
+    name: "render",
+    filename: filepath,
+    basedir: options2.outbase
+  });
   return {
     contents,
     loader: "js"
   };
 }
-async function loadAsHtml(filepath) {
+async function loadAsHtml(filepath, options2) {
   const fileData = await import_fs4.default.promises.readFile(filepath, "utf8");
-  const contents = import_pug.default.render(fileData, { name: "render" });
+  const contents = import_pug.default.render(fileData, {
+    name: "render",
+    filename: filepath,
+    basedir: options2.outbase,
+    plugins: [
+      pugTransformer(isScriptNodeWithSrcAttr, (nodes) => {
+        nodes;
+      })
+    ]
+  });
   return {
     contents,
     loader: "js"
   };
 }
-async function loadAsCopy(filepath) {
+async function loadAsEntrypoint(filepath, options2) {
   const fileData = await import_fs4.default.promises.readFile(filepath, "utf8");
-  const contents = import_pug.default.render(fileData, { name: "render" });
+  const contents = import_pug.default.render(fileData, {
+    filename: filepath,
+    basedir: options2.outbase,
+    name: "render",
+    plugins: [
+      pugTransformer(isScriptNodeWithSrcAttr, (nodes) => {
+        nodes;
+      })
+    ]
+  });
   return {
     contents,
     loader: "copy"
   };
 }
-async function loadAsFile(filepath) {
+async function loadAsFile(filepath, options2) {
   const fileData = await import_fs4.default.promises.readFile(filepath, "utf8");
-  const contents = import_pug.default.render(fileData, { name: "render" });
+  const contents = import_pug.default.render(fileData, {
+    name: "render",
+    filename: filepath,
+    basedir: options2.outbase
+  });
   return {
     contents,
     loader: "file"
@@ -69100,7 +69248,7 @@ var plugin2 = {
       }) => {
         const isEntryPoint = pluginData?.[name2]?.entrypoint;
         if (isEntryPoint) {
-          return loadAsCopy(filepath);
+          return loadAsEntrypoint(filepath, build2.initialOptions);
         }
         const type = withArg?.["type"] ?? "js";
         switch (type) {
@@ -69108,7 +69256,7 @@ var plugin2 = {
           // This gives a string of the pug already rendered to html
           // TODO: could support passing options to pug.render via the with clause
           case "html":
-            return loadAsHtml(filepath);
+            return loadAsHtml(filepath, build2.initialOptions);
           // Load pug as a text file by doing "import template from './file.pug' with { type: 'text' }"
           // This gives a string of the raw pug file, which can be used as pug - e.g. as a template string
           case "pug":
@@ -69117,12 +69265,12 @@ var plugin2 = {
           // Load pug as a render function by doing "import render from './file.pug' with { type: 'js' }"
           // This is the default behaviour if no with clause is used, or no type is specified.
           case "js":
-            return loadAsJS2(filepath);
+            return loadAsJS2(filepath, build2.initialOptions);
           // Load pug as a file by doing "import template from './file.pug' with { type: 'file' }"
           // This will render the pug file to a file, and return the path to that file.
           // The path is going to contain a hash, so it is not going to be the same as the original file.
           case "file":
-            return loadAsFile(filepath);
+            return loadAsFile(filepath, build2.initialOptions);
           // In the case that the type is not recognised, throw an error
           default:
             throw new Error(`Unsupported type: ${type}`);
@@ -69290,7 +69438,9 @@ var esbuilder = {
         entryPoints: build2.map(({ infile }) => infile.absolute),
         outdir,
         outbase: indir,
-        write: false
+        write: false,
+        logLevel: "silent"
+        // TODO: add a specific variable for this
       };
       log_default.debug(
         `Final config:`,
@@ -69301,6 +69451,13 @@ var esbuilder = {
         )
       );
       const codeBuild = esbuild.build(finalConfig).then(async (result) => {
+        if (result.errors.length || result.warnings.length) {
+          log_default.info(`Build completed with errors or warnings:`, {
+            errors: result.errors.length,
+            warnings: result.warnings.length
+          });
+          throw result;
+        }
         log_default.debug(
           `Got output files:`,
           result.outputFiles.map((f) => import_path7.default.relative(outdir, f.path))
@@ -69369,6 +69526,20 @@ var esbuilder = {
           }
         }
         await Promise.all(writers);
+      }).catch((err) => {
+        const errors = err.errors || [];
+        const warnings = err.warnings || [];
+        if (!errors.length && !warnings.length) {
+          log_default.error(
+            `Build failed with no errors or warnings, but an unknown error occurred.`
+          );
+          throw err;
+        } else {
+          log_default.error(
+            `Build failed with ${errors.length} errors and ${warnings.length} warnings.`
+          );
+          throw [...errors, ...warnings];
+        }
       });
       promises.push(codeBuild);
       if (exampleFile.entryconfig.declarations) {
@@ -69395,6 +69566,18 @@ var esbuilder = {
       }
       await Promise.all(promises);
     }
+    return {
+      // TODO: rewrite to return warnings
+      warnings: [],
+      // TODO: rewrite to return errors
+      errors: [],
+      watchFiles: entrypoints.map((e) => e.infile),
+      watchDirs: [],
+      // TODO: these are not the correct files
+      producedFiles: entrypoints.map((e) => e.outfile),
+      // TODO: rewrite to only return true if all builds were successful
+      completed: true
+    };
   }
 };
 async function compileToTypeDeclarations(fileNames, options2) {
@@ -70244,7 +70427,7 @@ async function getEntrypoints(buildConfig, manuallySpecified) {
 }
 
 // pnp:/builds/normed/bundle/packages/bundle/src/bundle.ts
-async function bundle(options2 = {}) {
+async function getBuildConfig(options2) {
   const buildConfig = {
     dir: {
       in: getInDir(options2),
@@ -70358,125 +70541,116 @@ async function bundle(options2 = {}) {
     "Build Config - post reading package.json",
     JSON.stringify(buildConfig.baseConfig, null, 2)
   );
-  const [raw_entrypoints, missingBuilders] = divide(
-    await getEntrypoints(buildConfig, options2.entrypoints),
-    (v) => {
-      return !(v instanceof NoMatchingBuilder);
-    }
-  );
-  const [allContextEntrypoints, entrypoints] = divide(
-    raw_entrypoints,
-    (e) => e.origin === "discovered" && e.infile.modifiers.includes("context")
+  return buildConfig;
+}
+async function discoverEntrypoints(buildConfig, entrypoints, plugins = {}) {
+  let initialEntrypoints = await getEntrypoints(buildConfig, entrypoints);
+  initialEntrypoints = await plugins.initialEntrypoints?.(initialEntrypoints) ?? initialEntrypoints;
+  const [missing, found] = divide(
+    initialEntrypoints,
+    (e) => e instanceof NoMatchingBuilder
   );
-  let skippedContextFile = false;
-  await Promise.all(
-    allContextEntrypoints.map(async (contextEntrypoint) => {
-      if (4 > 1) {
-        if (!skippedContextFile) {
-          log_default.warn(`Context files are not yet supported`);
-          skippedContextFile = true;
-        }
-        log_default.warn(`	- skipping ${contextEntrypoint.infile.relative}`);
-        return;
-      }
-      skippedContextFile = false;
-      const matchingEntrypoints = entrypoints.filter(
-        (e) => e.infile.bare === contextEntrypoint.infile.bare
-      );
-      if (!matchingEntrypoints.length) {
-        log_default.warn(
-          `Context file ${contextEntrypoint.infile.bare} is not used by any entrypoint`
-        );
-        return;
-      }
-      log_default.verbose(
-        `Context file ${contextEntrypoint.infile.bare} is used by ${matchingEntrypoints.length} entrypoints`
-      );
-      async function compile(_v) {
-        throw new Error("Function not implemented.");
-      }
-      const compiled = await compile(contextEntrypoint);
-      const { context } = await compiled.run();
-      if (!context) {
-        log_default.warn(
-          `Context file ${contextEntrypoint.infile.bare} did not export a context function`
-        );
-        return;
-      }
-      const contextResult = await context();
-      if (!contextResult) {
-        log_default.warn(
-          `Context file ${contextEntrypoint.infile.bare} did not return a context object`
-        );
-        return;
-      }
-      const builderNames = matchingEntrypoints.map((e) => e.builder.name).filter((v, i, a) => a.indexOf(v) === i);
-      const builderNamesWithContexts = builderNames.filter(
-        (name3) => contextResult[name3]
-      );
-      if (!builderNamesWithContexts.length) {
-        log_default.warn(
-          `Context file ${contextEntrypoint.infile.bare} did not return any context for any of the builders: ${builderNames.join(", ")}`
-        );
-        return;
-      }
-      for (const builderName of builderNamesWithContexts) {
-        await Promise.all(
-          matchingEntrypoints.filter((e) => e.builder.name === builderName).map(async (entrypoint) => {
-            const func = contextResult[builderName];
-            if (!func) {
-              log_default.warn(
-                `Context file ${contextEntrypoint.infile.bare} did not return a context for builder ${builderName}`
-              );
-              return;
-            }
-            entrypoint.context = await func();
-          })
-        );
+  if (missing.length) {
+    const missingBuilders = missing.filter((v, i, a) => a.indexOf(v) === i);
+    return WrappedErrors.fromErrors(
+      missing,
+      "Missing builders for entrypoints",
+      {
+        missingBuilders: missingBuilders.map((b) => b.name),
+        missingBuilders_count: missingBuilders.length
       }
-    })
+    );
+  }
+  return plugins.discoveredEntrypoints?.(found) ?? found;
+}
+async function bundle(options2 = {}, plugins = {}) {
+  const start = Date.now();
+  const buildConfig = await getBuildConfig(options2);
+  const entrypoints = await discoverEntrypoints(
+    buildConfig,
+    options2.entrypoints,
+    plugins
   );
-  log_default.warn(missingBuilders.map((missing) => missing.message).join("\n"));
-  log_default.info(entrypoints.length + " entrypoints");
-  const grouped = entrypoints.reduce((acc, entryPoint) => {
-    const index = buildConfig.builders.indexOf(entryPoint.builder);
-    if (!acc[index]) {
-      acc[index] = [];
-    }
-    acc[index]?.push(entryPoint);
-    return acc;
-  }, []);
-  for (const index in grouped) {
-    const group = grouped[index];
-    const builder = buildConfig.builders[index];
-    if (!builder) {
-      continue;
-    }
-    log_default.info(
-      builder.color(
-        `${builder.name}:
-	${group?.map((i) => `${i.infile.relative} => ${i.outfile.relative}`).join("\n	")}`
-      )
+  if (entrypoints instanceof WrappedErrors) {
+    return WrappedErrors.fromError(
+      entrypoints,
+      "Failed to discover entrypoints"
     );
   }
-  const results = await Promise.all(
-    grouped.map(
-      (entrypoints2, index) => (async () => {
-        const start = Date.now();
-        await buildConfig.builders[index]?.build(entrypoints2);
-        const duration = Math.floor((Date.now() - start) / 10) / 100;
-        const builder = buildConfig.builders[index];
-        if (!builder) {
-          log_default.info(`Unknown builder: ${duration} seconds`);
-        } else {
-          log_default.info(builder.color(`${builder.name}: ${duration} seconds`));
+  let grouped = keyBy(entrypoints, {
+    builder: (entrypoint) => entrypoint.builder
+  });
+  grouped = await plugins.preBuild?.(grouped) ?? grouped;
+  const results = await Promise.allSettled(
+    Array.from(grouped.entries()).map(
+      async ([
+        { builder },
+        entrypoints2
+      ]) => {
+        const start2 = Date.now();
+        const annotations = {
+          entrypoints: entrypoints2,
+          builder,
+          duration_ms: -1
+        };
+        let result;
+        try {
+          result = await builder.build(entrypoints2);
+        } catch (e) {
+          result = {
+            warnings: [],
+            errors: [WrappedErrors.fromValue(e, "Builder failed to build")],
+            watchFiles: entrypoints2.map((e2) => e2.infile),
+            watchDirs: [],
+            producedFiles: [],
+            completed: false
+          };
+        } finally {
+          annotations.duration_ms = Date.now() - start2;
         }
-      })().catch((e) => e)
+        result = await plugins.postBuild?.(result, annotations) ?? result;
+        return {
+          ...result,
+          ...annotations
+        };
+      }
     )
   );
-  const errors = results.filter((e) => e instanceof Error).concat(missingBuilders);
-  if (errors.length) return Promise.reject(errors);
-  return;
+  const [rejected, fulfilled] = divide(
+    results,
+    (r) => r.status === "rejected"
+  );
+  const [uncompleted, completed] = divide(fulfilled, (r) => r.value.completed);
+  const errorLogs = combineErrorLogs(
+    ...uncompleted.map((r) => r.value),
+    ...completed.map((r) => r.value)
+  );
+  const errors = [
+    rejected.length ? WrappedErrors.fromValues(
+      rejected.map((r) => r.reason),
+      "Some builders encountered errors when running",
+      {
+        rejected_count: rejected.length,
+        entrypoints: entrypoints.map((e) => e.infile.relative),
+        builders: Array.from(grouped.keys()).map(
+          ({ builder }) => builder.name
+        )
+      }
+    ) : void 0,
+    ...errorLogs.errors ?? []
+  ];
+  const warnings = errorLogs.warnings ?? [];
+  return {
+    completed: rejected.length === 0 && uncompleted.length === 0,
+    errors: errors.filter(isNot.undefined),
+    warnings,
+    watchFiles: fulfilled.flatMap((r) => r.value.watchFiles),
+    watchDirs: fulfilled.flatMap((r) => r.value.watchDirs),
+    producedFiles: fulfilled.flatMap((r) => r.value.producedFiles),
+    entrypoints,
+    duration_ms: Date.now() - start,
+    children: fulfilled.map((r) => r.value)
+  };
 }
 
 // pnp:/builds/normed/bundle/packages/bundle/src/index.ts
@@ -70610,17 +70784,83 @@ if (optClean) {
 }
 if (optBuild) {
   log_default.info(`Building`);
-  tasks.push(bundle2(options));
+  tasks.push(
+    bundle2(options, {
+      preBuild(builderMap) {
+        const builders2 = [...builderMap.entries()].sort(
+          ([
+            {
+              builder: { name: a }
+            }
+          ], [
+            {
+              builder: { name: b }
+            }
+          ]) => {
+            return a.localeCompare(b);
+          }
+        );
+        for (const [{ builder }, entrypoints] of builders2) {
+          log_default.info(
+            builder.color(
+              `${builder.name}:
+	${entrypoints.map((i) => i.infile.relative).join("\n	")}`
+            )
+          );
+        }
+        return builderMap;
+      },
+      postBuild(success, { builder, duration_ms }) {
+        const duration = Math.floor(duration_ms / 10) / 100;
+        if (success) {
+          log_default.info(builder.color(`${builder.name}: ${duration} seconds`));
+        } else {
+          log_default.error(
+            builder.color(`${builder.name}: Failed after ${duration} seconds`)
+          );
+          exitCode = 1;
+        }
+        return success;
+      }
+    }).then(() => {
+    })
+  );
 }
-Promise.all(tasks).catch((_errors) => {
-  let errors = Array.isArray(_errors) ? _errors : [_errors];
-  for (const error of errors) {
-    if (error instanceof Error) {
-      log_default.error(error);
+function errorPrinter(error, index) {
+  if (Array.isArray(error)) {
+    for (const err of error) {
+      index = errorPrinter(err, index);
+    }
+    return index;
+  }
+  if (error instanceof Error) {
+    log_default.error(`(${index}) Error:`, error.message);
+    log_default.debug(error.stack);
+    index++;
+  } else {
+    if (error && typeof error === "object") {
+      if (error.text && error.notes && error.detail) {
+        log_default.error(`(${index}) Error: ${error.text}`);
+        for (const note of error.notes) {
+          log_default.verbose(`Note: ${note.text}`);
+          if (note.location) {
+            log_default.verbose(
+              `Location: ${note.location.file}:${note.location.line}:${note.location.column}`
+            );
+          }
+        }
+      } else {
+        log_default.error(`(${index}) Error:`, error);
+      }
     } else {
-      log_default.error("Error:", error);
+      log_default.error(`(${index}) Error:`, String(error));
     }
   }
+  return index;
+}
+Promise.all(tasks).catch((_errors) => {
+  let errors = Array.isArray(_errors) ? _errors : [_errors];
+  errorPrinter(errors, 1);
   exitCode = 1;
 }).finally(() => {
   const endTime = Date.now();