@normed/bundle 4.1.0 → 4.2.1

package/CHANGELOG.md

@@ -6,6 +6,15 @@ 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.1
+
+* PATCH: Fixes missing path in load_less.
+
+# 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.

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
+    };
   }
 };
 
@@ -68982,14 +69080,20 @@ var plugin = {
     build2.onResolve(
       { filter: filter2 },
       async (args) => {
-        return {
-          sideEffects: false,
-          pluginData: Object.assign({}, args.pluginData, {
-            [name]: {
-              entrypoint: args.kind === "entry-point"
-            }
-          })
-        };
+        const resolvedPath = import_path4.default.resolve(args.resolveDir, args.path);
+        if (import_fs3.default.existsSync(resolvedPath)) {
+          return {
+            sideEffects: false,
+            path: import_path4.default.resolve(args.resolveDir, args.path),
+            pluginData: Object.assign({}, args.pluginData, {
+              [name]: {
+                entrypoint: args.kind === "entry-point"
+              }
+            })
+          };
+        } else {
+          return {};
+        }
       }
     );
     build2.onLoad(
@@ -69028,6 +69132,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"
@@ -69052,19 +69180,29 @@ async function loadAsHtml(filepath, options2) {
   const contents = import_pug.default.render(fileData, {
     name: "render",
     filename: filepath,
-    basedir: options2.outbase
+    basedir: options2.outbase,
+    plugins: [
+      pugTransformer(isScriptNodeWithSrcAttr, (nodes) => {
+        nodes;
+      })
+    ]
   });
   return {
     contents,
     loader: "js"
   };
 }
-async function loadAsCopy(filepath, options2) {
+async function loadAsEntrypoint(filepath, options2) {
   const fileData = await import_fs4.default.promises.readFile(filepath, "utf8");
   const contents = import_pug.default.render(fileData, {
     filename: filepath,
     basedir: options2.outbase,
-    name: "render"
+    name: "render",
+    plugins: [
+      pugTransformer(isScriptNodeWithSrcAttr, (nodes) => {
+        nodes;
+      })
+    ]
   });
   return {
     contents,
@@ -69116,7 +69254,7 @@ var plugin2 = {
       }) => {
         const isEntryPoint = pluginData?.[name2]?.entrypoint;
         if (isEntryPoint) {
-          return loadAsCopy(filepath, build2.initialOptions);
+          return loadAsEntrypoint(filepath, build2.initialOptions);
         }
         const type = withArg?.["type"] ?? "js";
         switch (type) {
@@ -69434,6 +69572,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) {
@@ -70283,7 +70433,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),
@@ -70397,125 +70547,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;
+  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
       }
-      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();
-          })
-        );
-      }
-    })
+    );
+  }
+  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(Boolean).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
@@ -70649,7 +70790,47 @@ 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(() => {
+    })
+  );
 }
 function errorPrinter(error, index) {
   if (Array.isArray(error)) {