@normed/bundle 4.0.0 → 4.1.0

package/CHANGELOG.md

@@ -6,6 +6,11 @@ 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.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

@@ -69035,33 +69035,49 @@ 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
+  });
   return {
     contents,
     loader: "js"
   };
 }
-async function loadAsCopy(filepath) {
+async function loadAsCopy(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"
+  });
   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 +69116,7 @@ var plugin2 = {
       }) => {
         const isEntryPoint = pluginData?.[name2]?.entrypoint;
         if (isEntryPoint) {
-          return loadAsCopy(filepath);
+          return loadAsCopy(filepath, build2.initialOptions);
         }
         const type = withArg?.["type"] ?? "js";
         switch (type) {
@@ -69108,7 +69124,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 +69133,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 +69306,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 +69319,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 +69394,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) {
@@ -70474,7 +70513,7 @@ async function bundle(options2 = {}) {
       })().catch((e) => e)
     )
   );
-  const errors = results.filter((e) => e instanceof Error).concat(missingBuilders);
+  const errors = results.filter(Boolean).concat(missingBuilders);
   if (errors.length) return Promise.reject(errors);
   return;
 }
@@ -70612,15 +70651,41 @@ if (optBuild) {
   log_default.info(`Building`);
   tasks.push(bundle2(options));
 }
-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();