@normed/bundle 4.0.0 → 4.2.0

package/bundles/bundle.d.ts

@@ -1,3 +1,28 @@
 import "@normed/json-types";
-import { APIOptions_Bundle } from "./types";
-export default function bundle(options?: APIOptions_Bundle): Promise<undefined>;
+import { Entrypoint, APIOptions_Bundle } from "./types";
+import { WrappedErrors } from "./errors";
+import { BundlePlugins } from "./plugins";
+export default function bundle(options?: APIOptions_Bundle, plugins?: BundlePlugins): Promise<WrappedErrors | {
+    completed: boolean;
+    errors: Error[];
+    warnings: Error[];
+    watchFiles: import("./File").FileInfo[];
+    watchDirs: {
+        path: string;
+    }[];
+    producedFiles: import("./File").FileInfo[];
+    entrypoints: Entrypoint[];
+    duration_ms: number;
+    children: ({
+        completed: boolean;
+        watchFiles: import("./File").FileInfo[];
+        watchDirs: {
+            path: string;
+        }[];
+        producedFiles: import("./File").FileInfo[];
+    } & import("./errors").ErrorLog & {
+        entrypoints: Entrypoint[];
+        builder: import("./types").Builder;
+        duration_ms: number;
+    })[];
+}>;

package/bundles/entrypoints.d.ts

@@ -1,4 +1,4 @@
 import "@normed/json-types";
 import { Entrypoint, BuildConfig } from "./types";
 import { NoMatchingBuilder } from "./errors";
-export default function getEntrypoints(buildConfig: BuildConfig, manuallySpecified?: string[]): Promise<(Entrypoint | NoMatchingBuilder)[]>;
+export default function getEntrypoints(buildConfig: BuildConfig, manuallySpecified?: string[]): Promise<(NoMatchingBuilder | Entrypoint)[]>;

package/bundles/errors.d.ts

@@ -1,3 +1,24 @@
+export interface MetaField {
+    meta?: JSONishObject | undefined;
+}
+export type WithMeta<V> = V & MetaField;
+export interface ErrorLog {
+    errors?: Error[];
+    warnings?: Error[];
+}
+export declare function combineErrorLogs(...logs: ErrorLog[]): ErrorLog;
+export declare class WrappedErrors extends AggregateError implements MetaField, ErrorLog {
+    meta?: JSONishObject | undefined;
+    warnings?: Error[];
+    constructor(errors: Error[] | ErrorLog, message: string, meta?: JSONishObject | undefined);
+    static fromErrorLog(errorLog: ErrorLog, message: string, meta?: JSONishObject): WrappedErrors;
+    static fromError(error: Error, message: string, meta?: JSONishObject): WrappedErrors;
+    static fromErrors(errors: Error[], message: string, meta?: JSONishObject): WrappedErrors;
+    static fromValue(value: unknown, message: string, meta?: JSONishObject): WrappedErrors;
+    static fromValues(values: unknown[], message: string, meta?: JSONishObject): WrappedErrors;
+}
+export declare function asError(value: unknown): Error;
+export declare function asError(value: unknown, meta: JSONishObject): WithMeta<Error>;
 export declare class NoMatchingBuilder extends Error {
     readonly file: string;
     readonly ext: string;

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

@@ -68594,6 +68594,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 = [];
@@ -68890,6 +68918,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;
@@ -68914,6 +69004,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
+    };
   }
 };
 
@@ -69042,6 +69140,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"
@@ -69049,33 +69171,59 @@ 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,
+    plugins: [
+      pugTransformer(isScriptNodeWithSrcAttr, (nodes) => {
+        nodes;
+      })
+    ]
+  });
   return {
     contents,
     loader: "js"
   };
 }
-async function loadAsCopy(filepath) {
+async function loadAsEntrypoint(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",
+    plugins: [
+      pugTransformer(isScriptNodeWithSrcAttr, (nodes) => {
+        nodes;
+      })
+    ]
+  });
   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 +69262,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) {
@@ -69122,7 +69270,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 +69279,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 +69452,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 +69465,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 +69540,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) {
@@ -69409,6 +69580,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, options) {
@@ -70282,7 +70465,7 @@ async function getEntrypoints(buildConfig, manuallySpecified) {
 }
 
 // pnp:/builds/normed/bundle/packages/bundle/src/bundle.ts
-async function bundle(options = {}) {
+async function getBuildConfig(options) {
   const buildConfig = {
     dir: {
       in: getInDir(options),
@@ -70396,125 +70579,116 @@ async function bundle(options = {}) {
     "Build Config - post reading package.json",
     JSON.stringify(buildConfig.baseConfig, null, 2)
   );
-  const [raw_entrypoints, missingBuilders] = divide(
-    await getEntrypoints(buildConfig, options.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(options = {}, plugins = {}) {
+  const start = Date.now();
+  const buildConfig = await getBuildConfig(options);
+  const entrypoints = await discoverEntrypoints(
+    buildConfig,
+    options.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