@absolutejs/absolute 0.19.0-beta.932 → 0.19.0-beta.934

package/dist/index.js

@@ -14997,6 +14997,15 @@ ${content.slice(firstUseIdx)}`;
     conventions: undefined,
     pageFiles: []
   };
+  const htmlConventionDirs = [
+    reactPagesPath,
+    sveltePagesPath,
+    vuePagesPath,
+    angularPagesPath,
+    emberPagesPath,
+    htmlPagesPath,
+    htmxPagesPath
+  ].filter((path) => Boolean(path));
   const [
     ,
     allReactEntries,
@@ -15006,7 +15015,7 @@ ${content.slice(firstUseIdx)}`;
     vueConventionResult,
     angularConventionResult,
     emberConventionResult,
-    htmlConventionResult,
+    htmlConventionResults,
     allGlobalCssEntries
   ] = await Promise.all([
     tailwindPromise,
@@ -15017,7 +15026,7 @@ ${content.slice(firstUseIdx)}`;
     vuePagesPath ? tracePhase("scan/vue-conventions", () => scanConventions(vuePagesPath, "*.vue")) : emptyConventionResult,
     angularPagesPath ? tracePhase("scan/angular-conventions", () => scanConventions(angularPagesPath, "*.ts")) : emptyConventionResult,
     emberPagesPath ? tracePhase("scan/ember-conventions", () => scanConventions(emberPagesPath, "*.{gjs,gts,ts}")) : emptyConventionResult,
-    htmlPagesPath ? tracePhase("scan/html-conventions", () => scanConventions(htmlPagesPath, "*.html")) : emptyConventionResult,
+    tracePhase("scan/html-conventions", async () => Promise.all(htmlConventionDirs.map((dir) => scanConventions(dir, "*.html")))),
     stylesDir ? tracePhase("scan/css", () => scanCssEntryPoints(stylesDir, stylesIgnore)) : []
   ]);
   const allSvelteEntries = svelteConventionResult.pageFiles;
@@ -15035,26 +15044,88 @@ ${content.slice(firstUseIdx)}`;
     conventionsMap.angular = angularConventionResult.conventions;
   if (emberConventionResult.conventions)
     conventionsMap.ember = emberConventionResult.conventions;
-  if (htmlConventionResult.conventions && htmlDir && htmlPagesPath) {
-    const outputHtmlPages = isSingle ? join26(buildPath, "pages") : join26(buildPath, basename9(htmlDir), "pages");
-    const remap = (sourcePath) => join26(outputHtmlPages, relative12(htmlPagesPath, sourcePath));
-    const htmlConventions = htmlConventionResult.conventions;
-    if (htmlConventions.defaults) {
-      if (htmlConventions.defaults.error)
-        htmlConventions.defaults.error = remap(htmlConventions.defaults.error);
-      if (htmlConventions.defaults.notFound)
-        htmlConventions.defaults.notFound = remap(htmlConventions.defaults.notFound);
-      if (htmlConventions.defaults.loading)
-        htmlConventions.defaults.loading = remap(htmlConventions.defaults.loading);
-    }
-    if (htmlConventions.pages) {
-      for (const page of Object.values(htmlConventions.pages)) {
-        if (page.error)
-          page.error = remap(page.error);
-        if (page.loading)
-          page.loading = remap(page.loading);
+  const htmlDefaults = {};
+  const htmlPages = {};
+  const htmlConventionSources = [];
+  for (let idx = 0;idx < htmlConventionResults.length; idx++) {
+    const result = htmlConventionResults[idx];
+    if (!result?.conventions)
+      continue;
+    const dirLabel = htmlConventionDirs[idx] ?? "<unknown>";
+    const { defaults: scannedDefaults, pages: scannedPages } = result.conventions;
+    if (scannedDefaults?.error) {
+      if (htmlDefaults.error) {
+        logWarn(`Multiple error.html files found; using ${htmlDefaults.error} and ignoring ${scannedDefaults.error} (${dirLabel}).`);
+      } else {
+        htmlDefaults.error = scannedDefaults.error;
+        htmlConventionSources.push(scannedDefaults.error);
       }
     }
+    if (scannedDefaults?.notFound) {
+      if (htmlDefaults.notFound) {
+        logWarn(`Multiple not-found.html files found; using ${htmlDefaults.notFound} and ignoring ${scannedDefaults.notFound} (${dirLabel}).`);
+      } else {
+        htmlDefaults.notFound = scannedDefaults.notFound;
+        htmlConventionSources.push(scannedDefaults.notFound);
+      }
+    }
+    if (scannedDefaults?.loading && !htmlDefaults.loading) {
+      htmlDefaults.loading = scannedDefaults.loading;
+      htmlConventionSources.push(scannedDefaults.loading);
+    }
+    if (scannedPages) {
+      for (const [pageName, page] of Object.entries(scannedPages)) {
+        if (!htmlPages[pageName])
+          htmlPages[pageName] = {};
+        if (page.error && !htmlPages[pageName].error) {
+          htmlPages[pageName].error = page.error;
+          htmlConventionSources.push(page.error);
+        }
+        if (page.loading && !htmlPages[pageName].loading) {
+          htmlPages[pageName].loading = page.loading;
+          htmlConventionSources.push(page.loading);
+        }
+      }
+    }
+  }
+  if (htmlDefaults.error || htmlDefaults.notFound || htmlDefaults.loading || Object.keys(htmlPages).length > 0) {
+    const htmlConventionsOutDir = join26(buildPath, "conventions", "html");
+    mkdirSync11(htmlConventionsOutDir, { recursive: true });
+    const htmlPathRemap = new Map;
+    for (const sourcePath of htmlConventionSources) {
+      const dest = join26(htmlConventionsOutDir, basename9(sourcePath));
+      cpSync(sourcePath, dest, { force: true });
+      htmlPathRemap.set(sourcePath, dest);
+    }
+    const remap = (path) => path ? htmlPathRemap.get(path) ?? path : undefined;
+    const htmlConventions = {};
+    const remappedDefaults = {};
+    const errorRemap = remap(htmlDefaults.error);
+    if (errorRemap)
+      remappedDefaults.error = errorRemap;
+    const notFoundRemap = remap(htmlDefaults.notFound);
+    if (notFoundRemap)
+      remappedDefaults.notFound = notFoundRemap;
+    const loadingRemap = remap(htmlDefaults.loading);
+    if (loadingRemap)
+      remappedDefaults.loading = loadingRemap;
+    if (remappedDefaults.error || remappedDefaults.notFound || remappedDefaults.loading) {
+      htmlConventions.defaults = remappedDefaults;
+    }
+    if (Object.keys(htmlPages).length > 0) {
+      const remappedPages = {};
+      for (const [pageName, page] of Object.entries(htmlPages)) {
+        const entry = {};
+        const errorPath = remap(page.error);
+        if (errorPath)
+          entry.error = errorPath;
+        const loadingPath = remap(page.loading);
+        if (loadingPath)
+          entry.loading = loadingPath;
+        remappedPages[pageName] = entry;
+      }
+      htmlConventions.pages = remappedPages;
+    }
     conventionsMap.html = htmlConventions;
   }
   const notFoundFrameworks = ["react", "svelte", "vue", "angular", "ember", "html"].filter((framework) => conventionsMap[framework]?.defaults?.notFound);
@@ -15399,6 +15470,7 @@ ${content.slice(firstUseIdx)}`;
     "svelte/*",
     "vue",
     "vue/*",
+    "@vue/*",
     "@angular/*",
     "typescript"
   ];
@@ -32062,5 +32134,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=1D5D4C42226608CC64756E2164756E21
+//# debugId=E833033599BF27F964756E2164756E21
 //# sourceMappingURL=index.js.map