@normed/bundle 4.0.0 → 4.1.0

package/bundles/esbuild-plugins/log_esbuild.d.ts

@@ -0,0 +1,3 @@
+import type * as esbuild from "esbuild";
+declare const plugin: esbuild.Plugin;
+export default plugin;

package/bundles/index.js

@@ -69049,33 +69049,49 @@ async function loadAsText2(_filepath) {
     // as well - its probably faster than us doing it in JS.
   };
 }
-async function loadAsJS2(filepath) {
+async function loadAsJS2(filepath, options) {
   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: options.outbase
+  });
   return {
     contents,
     loader: "js"
   };
 }
-async function loadAsHtml(filepath) {
+async function loadAsHtml(filepath, options) {
   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: options.outbase
+  });
   return {
     contents,
     loader: "js"
   };
 }
-async function loadAsCopy(filepath) {
+async function loadAsCopy(filepath, options) {
   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: options.outbase,
+    name: "render"
+  });
   return {
     contents,
     loader: "copy"
   };
 }
-async function loadAsFile(filepath) {
+async function loadAsFile(filepath, options) {
   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: options.outbase
+  });
   return {
     contents,
     loader: "file"
@@ -69114,7 +69130,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) {
@@ -69122,7 +69138,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":
@@ -69131,12 +69147,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}`);
@@ -69304,7 +69320,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:`,
@@ -69315,6 +69333,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))
@@ -69383,6 +69408,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) {
@@ -70512,7 +70551,7 @@ async function bundle(options = {}) {
       })().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;
 }