@normed/bundle 4.5.7 → 4.6.0

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

@@ -23,6 +23,19 @@ export declare const discoveredPugReferences: Map<string, DiscoveredPugReference
  * This is populated during build and used by the builder to trigger sub-builds.
  */
 export declare const discoveredLessReferences: Map<string, DiscoveredLessReference[]>;
+/**
+ * Discovered package CSS reference from HTML.
+ * Package CSS files need to go through esbuild's CSS pipeline to handle url() references.
+ */
+export interface DiscoveredPackageCssReference {
+    originalHref: string;
+    absolutePath: string;
+}
+/**
+ * Map of source pug file path to discovered package CSS references.
+ * This is populated during build and used by the builder to trigger CSS processing.
+ */
+export declare const discoveredPackageCssReferences: Map<string, DiscoveredPackageCssReference[]>;
 /**
  * Clear discovered pug references. Should be called before a new build.
  */
@@ -31,5 +44,9 @@ export declare function clearDiscoveredPugReferences(): void;
  * Clear discovered less references. Should be called before a new build.
  */
 export declare function clearDiscoveredLessReferences(): void;
+/**
+ * Clear discovered package CSS references. Should be called before a new build.
+ */
+export declare function clearDiscoveredPackageCssReferences(): void;
 declare const plugin: esbuild.Plugin;
 export default plugin;

package/bundles/index.js

@@ -69150,6 +69150,7 @@ var import_pug = __toESM(require_lib14());
 var import_fs4 = __toESM(require("fs"));
 var import_path5 = __toESM(require("path"));
 var import_crypto = __toESM(require("crypto"));
+var import_module = require("module");
 function computeContentHash(content) {
   const hash = import_crypto.default.createHash("sha256").update(content).digest();
   const num = hash.readUInt32BE(0);
@@ -69185,14 +69186,36 @@ function isPugReference(assetPath) {
 function isLessReference(assetPath) {
   return assetPath.endsWith(".less") && isRelativeAssetPath(assetPath);
 }
+var PKG_PREFIX = "pkg:";
+function isPackageReference(assetPath) {
+  return assetPath.startsWith(PKG_PREFIX);
+}
+function getPackageSpecifier(assetPath) {
+  return assetPath.slice(PKG_PREFIX.length);
+}
+function isPackageCssReference(assetPath) {
+  return isPackageReference(assetPath) && assetPath.endsWith(".css");
+}
+function resolvePackagePath(packageSpecifier, fromFile) {
+  try {
+    const require2 = (0, import_module.createRequire)(fromFile);
+    return require2.resolve(packageSpecifier);
+  } catch {
+    return null;
+  }
+}
 var discoveredPugReferences = /* @__PURE__ */ new Map();
 var discoveredLessReferences = /* @__PURE__ */ new Map();
+var discoveredPackageCssReferences = /* @__PURE__ */ new Map();
 function clearDiscoveredPugReferences() {
   discoveredPugReferences.clear();
 }
 function clearDiscoveredLessReferences() {
   discoveredLessReferences.clear();
 }
+function clearDiscoveredPackageCssReferences() {
+  discoveredPackageCssReferences.clear();
+}
 function applyAssetNamesTemplate(template, originalPath, hash, baseDir) {
   const ext = import_path5.default.extname(originalPath).slice(1);
   const name3 = import_path5.default.basename(originalPath, import_path5.default.extname(originalPath));
@@ -69204,6 +69227,7 @@ async function processHtmlAssets(html, pugFilePath, options) {
   const assets = [];
   const pugReferences = [];
   const lessReferences = [];
+  const packageCssReferences = [];
   const assetNames = options.assetNames || "[name]-[hash]";
   const outdir = options.outdir || ".";
   const outbase = options.outbase || import_path5.default.dirname(pugFilePath);
@@ -69230,6 +69254,7 @@ async function processHtmlAssets(html, pugFilePath, options) {
   }
   const discoveredPugPaths = /* @__PURE__ */ new Set();
   const discoveredLessPaths = /* @__PURE__ */ new Set();
+  const discoveredPackageCssPaths = /* @__PURE__ */ new Set();
   for (const { fullMatch, attr, value } of matches) {
     let newValue = value;
     if (attr === "srcset") {
@@ -69281,6 +69306,32 @@ async function processHtmlAssets(html, pugFilePath, options) {
         discoveredLessPaths.add(absolutePath);
         lessReferences.push({ originalHref: value, absolutePath });
       }
+    } else if (isPackageCssReference(value)) {
+      const packageSpecifier = getPackageSpecifier(value);
+      const absolutePath = resolvePackagePath(packageSpecifier, pugFilePath);
+      if (absolutePath && !discoveredPackageCssPaths.has(absolutePath)) {
+        discoveredPackageCssPaths.add(absolutePath);
+        packageCssReferences.push({ originalHref: value, absolutePath });
+      }
+    } else if (isPackageReference(value)) {
+      const packageSpecifier = getPackageSpecifier(value);
+      const absolutePath = resolvePackagePath(packageSpecifier, pugFilePath);
+      if (absolutePath) {
+        const hashedPath = await processPackageAsset(
+          absolutePath,
+          packageSpecifier,
+          pugFilePath,
+          outdir,
+          outbase,
+          assetNames,
+          publicPath,
+          assets,
+          processedAssets
+        );
+        if (hashedPath) {
+          newValue = hashedPath;
+        }
+      }
     } else if (isRelativeAssetPath(value)) {
       const hashedPath = await processAsset(
         value,
@@ -69302,7 +69353,13 @@ async function processHtmlAssets(html, pugFilePath, options) {
       modifiedHtml = modifiedHtml.replace(fullMatch, newFullMatch);
     }
   }
-  return { html: modifiedHtml, assets, pugReferences, lessReferences };
+  return {
+    html: modifiedHtml,
+    assets,
+    pugReferences,
+    lessReferences,
+    packageCssReferences
+  };
 }
 async function processAsset(assetPath, pugDir, pugFilePath, outdir, outbase, assetNames, publicPath, assets, processedAssets) {
   const absoluteSource = import_path5.default.resolve(pugDir, assetPath);
@@ -69343,6 +69400,46 @@ async function processAsset(assetPath, pugDir, pugFilePath, outdir, outbase, ass
     return null;
   }
 }
+async function processPackageAsset(absoluteSource, packageSpecifier, pugFilePath, outdir, outbase, assetNames, publicPath, assets, processedAssets) {
+  if (processedAssets.has(absoluteSource)) {
+    return processedAssets.get(absoluteSource);
+  }
+  if (!import_fs4.default.existsSync(absoluteSource)) {
+    return null;
+  }
+  try {
+    const content = await import_fs4.default.promises.readFile(absoluteSource);
+    const hash = computeContentHash(content);
+    const filename = import_path5.default.basename(packageSpecifier);
+    const hashedFilename = applyAssetNamesTemplate(
+      assetNames,
+      filename,
+      hash,
+      ""
+      // No base dir for package assets
+    );
+    const absoluteOutput = import_path5.default.join(outdir, hashedFilename);
+    const pugRelativeToOutbase = import_path5.default.relative(outbase, pugFilePath);
+    const htmlOutputPath = import_path5.default.join(outdir, pugRelativeToOutbase);
+    const htmlOutputDir = import_path5.default.dirname(htmlOutputPath);
+    let htmlPath;
+    if (publicPath) {
+      htmlPath = publicPath.replace(/\/$/, "") + "/" + hashedFilename;
+    } else {
+      htmlPath = import_path5.default.relative(htmlOutputDir, absoluteOutput);
+    }
+    assets.push({
+      originalPath: packageSpecifier,
+      hashedPath: htmlPath,
+      absoluteSource,
+      absoluteOutput
+    });
+    processedAssets.set(absoluteSource, htmlPath);
+    return htmlPath;
+  } catch {
+    return null;
+  }
+}
 async function copyAssets(assets) {
   const written = /* @__PURE__ */ new Set();
   for (const asset of assets) {
@@ -69437,7 +69534,8 @@ async function loadAsEntrypoint(filepath, options) {
     html: processedHtml,
     assets,
     pugReferences,
-    lessReferences
+    lessReferences,
+    packageCssReferences
   } = await processHtmlAssets(contents, filepath, options);
   contents = processedHtml;
   if (pugReferences.length > 0) {
@@ -69446,6 +69544,9 @@ async function loadAsEntrypoint(filepath, options) {
   if (lessReferences.length > 0) {
     discoveredLessReferences.set(filepath, lessReferences);
   }
+  if (packageCssReferences.length > 0) {
+    discoveredPackageCssReferences.set(filepath, packageCssReferences);
+  }
   if (assets.length > 0) {
     await copyAssets(assets);
   }
@@ -69707,6 +69808,18 @@ function rewriteLessReferencesInHtml(html, lessReferences, lessToOutputPath, htm
   }
   return result;
 }
+function rewritePackageCssReferencesInHtml(html, packageCssReferences, packageCssToOutputPath, htmlOutputDir, outdir) {
+  let result = html;
+  for (const ref of packageCssReferences) {
+    const outputPath = packageCssToOutputPath.get(ref.absolutePath);
+    if (outputPath) {
+      const absoluteOutputPath = import_path8.default.join(outdir, outputPath);
+      const relativePath = import_path8.default.relative(htmlOutputDir, absoluteOutputPath);
+      result = result.split(ref.originalHref).join(relativePath);
+    }
+  }
+  return result;
+}
 function outExt(inExt) {
   if (inExt.match(/^((c|m)?sx?|tsx?)$/)) {
     return "js";
@@ -69813,13 +69926,17 @@ var esbuilder = {
       );
       clearDiscoveredPugReferences();
       clearDiscoveredLessReferences();
+      clearDiscoveredPackageCssReferences();
       const pugHtmlOutputs = /* @__PURE__ */ new Map();
       const pugToOutputPath = /* @__PURE__ */ new Map();
       const lessToOutputPath = /* @__PURE__ */ new Map();
+      const packageCssToOutputPath = /* @__PURE__ */ new Map();
       const processedPugFiles = /* @__PURE__ */ new Set();
       const processedLessFiles = /* @__PURE__ */ new Set();
+      const processedPackageCssFiles = /* @__PURE__ */ new Set();
       const pendingPugFiles = [];
       const pendingLessFiles = [];
+      const pendingPackageCssFiles = [];
       const processOutputFiles = async (result, currentOutputFilesMap, isDiscoveredBuild) => {
         if (result.errors.length || result.warnings.length) {
           log_default.info(`Build completed with errors or warnings:`, {
@@ -69880,6 +69997,7 @@ var esbuilder = {
           if (isHtmlOutput && sourcePath) {
             const pugRefs = discoveredPugReferences.get(sourcePath) || [];
             const lessRefs = discoveredLessReferences.get(sourcePath) || [];
+            const packageCssRefs = discoveredPackageCssReferences.get(sourcePath) || [];
             pugToOutputPath.set(sourcePath, relativeTarget);
             for (const ref of pugRefs) {
               if (!processedPugFiles.has(ref.absolutePath) && !pendingPugFiles.includes(ref.absolutePath)) {
@@ -69909,12 +70027,27 @@ var esbuilder = {
                 }
               }
             }
+            for (const ref of packageCssRefs) {
+              if (!processedPackageCssFiles.has(ref.absolutePath) && !pendingPackageCssFiles.includes(ref.absolutePath)) {
+                if (import_fs7.default.existsSync(ref.absolutePath)) {
+                  pendingPackageCssFiles.push(ref.absolutePath);
+                  log_default.debug(
+                    `Discovered package CSS reference: ${ref.originalHref} -> ${ref.absolutePath}`
+                  );
+                } else {
+                  log_default.warn(
+                    `Referenced package CSS file not found: ${ref.originalHref} (resolved to ${ref.absolutePath})`
+                  );
+                }
+              }
+            }
             pugHtmlOutputs.set(sourcePath, {
               content: file.text,
               sourcePath,
               outputPath: import_path8.default.join(outdir, relativeTarget),
               pugReferences: pugRefs,
-              lessReferences: lessRefs
+              lessReferences: lessRefs,
+              packageCssReferences: packageCssRefs
             });
           } else {
             if (relativeTarget.endsWith(".css") && oFM_result?.entrypoint?.infile.extension === "less") {
@@ -70037,6 +70170,39 @@ var esbuilder = {
               }
             }
           }
+          while (pendingPackageCssFiles.length > 0) {
+            const batch = pendingPackageCssFiles.splice(0);
+            const newEntryPoints = batch.filter(
+              (f) => !processedPackageCssFiles.has(f)
+            );
+            if (newEntryPoints.length === 0) break;
+            log_default.debug(
+              `Building ${newEntryPoints.length} discovered package CSS file(s):`,
+              newEntryPoints
+            );
+            for (const cssSourcePath of newEntryPoints) {
+              processedPackageCssFiles.add(cssSourcePath);
+              const entryNames = "[name]-[hash]";
+              const cssConfig = {
+                ...finalConfig,
+                entryPoints: [cssSourcePath],
+                entryNames
+              };
+              const cssResult = await esbuild.build(cssConfig);
+              for (const file of cssResult.outputFiles) {
+                const relativeFilePath = import_path8.default.relative(outdir, file.path);
+                if (relativeFilePath.endsWith(".css")) {
+                  packageCssToOutputPath.set(cssSourcePath, relativeFilePath);
+                  log_default.debug(
+                    `Built package CSS file: ${cssSourcePath} -> ${relativeFilePath}`
+                  );
+                }
+                await fileWriter.writeFile(file.path, file.contents, {
+                  encoding: "utf-8"
+                });
+              }
+            }
+          }
           log_default.debug(
             `Rewriting pug/less references in ${pugHtmlOutputs.size} HTML file(s)`
           );
@@ -70062,6 +70228,15 @@ var esbuilder = {
                 outdir
               );
             }
+            if (output.packageCssReferences.length > 0) {
+              html = rewritePackageCssReferencesInHtml(
+                html,
+                output.packageCssReferences,
+                packageCssToOutputPath,
+                htmlOutputDir,
+                outdir
+              );
+            }
             const promise = fileWriter.writeFile(output.outputPath, html, {
               encoding: "utf-8"
             });