@absolutejs/absolute 0.19.0-beta.832 → 0.19.0-beta.834

package/dist/build.js

@@ -658,10 +658,6 @@ var init_islandEntries = __esm(() => {
 });
 
 // src/build/generateReactIndexes.ts
-var exports_generateReactIndexes = {};
-__export(exports_generateReactIndexes, {
-  generateReactIndexFiles: () => generateReactIndexFiles
-});
 import { existsSync, mkdirSync as mkdirSync2 } from "fs";
 import { readdir, rm, writeFile } from "fs/promises";
 import { basename, join as join2, relative as relative2, resolve as resolve2, sep } from "path";
@@ -9323,11 +9319,6 @@ var init_nativeRewrite = __esm(() => {
 });
 
 // src/build/rewriteReactImports.ts
-var exports_rewriteReactImports = {};
-__export(exports_rewriteReactImports, {
-  rewriteReactImports: () => rewriteReactImports,
-  patchRefreshGlobals: () => patchRefreshGlobals
-});
 var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), rewriterCache, cacheKey = (vendorPaths) => {
   const entries = Object.entries(vendorPaths).sort(([left], [right]) => left.localeCompare(right));
   let key = "";
@@ -11267,21 +11258,34 @@ ${registrations}
   if (fileName.startsWith(outDir))
     return fileName.substring(outDir.length + 1);
   return fileName;
-}, hasJsLikeExtension = (path) => /\.(js|ts|mjs|cjs)$/.test(path), rewriteRelativeJsSpecifier = (importerOutputPath, specifier, outputFiles) => {
-  if (specifier.endsWith(".ts"))
-    return specifier.replace(/\.ts$/, ".js");
-  if (hasJsLikeExtension(specifier))
-    return specifier;
+}, hasJsLikeExtension = (path) => /\.(js|ts|mjs|cjs)$/.test(path), splitSpecifierAndQuery = (specifier) => {
+  const separator = specifier.indexOf("?");
+  if (separator === -1) {
+    return {
+      path: specifier,
+      query: ""
+    };
+  }
+  return {
+    path: specifier.substring(0, separator),
+    query: specifier.substring(separator)
+  };
+}, rewriteRelativeJsSpecifier = (importerOutputPath, specifier, outputFiles) => {
+  const { path, query } = splitSpecifierAndQuery(specifier);
+  if (path.endsWith(".ts"))
+    return `${path.replace(/\.ts$/, ".js")}${query}`;
+  if (hasJsLikeExtension(path))
+    return `${path}${query}`;
   const importerDir = dirname11(importerOutputPath);
-  const fileCandidate = resolve16(importerDir, `${specifier}.js`);
+  const fileCandidate = resolve16(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync16(fileCandidate)) {
-    return `${specifier}.js`;
+    return `${path}.js${query}`;
   }
-  const indexCandidate = resolve16(importerDir, specifier, "index.js");
+  const indexCandidate = resolve16(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync16(indexCandidate)) {
-    return `${specifier}/index.js`;
+    return `${path}/index.js${query}`;
   }
-  return `${specifier}.js`;
+  return `${path}.js${query}`;
 }, isRelativeModuleSpecifier = (specifier) => specifier.startsWith("./") || specifier.startsWith("../"), extractLocalImportSpecifiers = (source, fileName) => {
   const sourceFile = ts2.createSourceFile(fileName, source, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
   const specifiers = [];
@@ -11797,7 +11801,7 @@ ${fields}
     deferSlots: inlinedTemplate.deferSlots,
     source: result
   };
-}, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors) => {
+}, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
   const entryPath = resolve16(inputPath);
   const allOutputs = [];
   const visited = new Set;
@@ -11851,13 +11855,18 @@ ${fields}
     const fileBase = basename6(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
     return join16(outDir, relativeDir, fileBase);
   };
+  const withCacheBuster = (specifier) => {
+    if (!cacheBuster)
+      return specifier;
+    return specifier.includes("?") ? `${specifier}&t=${cacheBuster}` : `${specifier}?t=${cacheBuster}`;
+  };
   const transpileAndRewrite = (sourceCode, relativeDir, actualPath, importRewrites) => {
     let processedContent = angularTranspiler.transformSync(sourceCode);
     const outputPath = toOutputPath(actualPath);
     const rewriteBareImport = (prefix, specifier, suffix) => {
       const rewritten = importRewrites.get(specifier);
       if (rewritten) {
-        return `${prefix}${rewritten}${suffix}`;
+        return `${prefix}${withCacheBuster(rewritten)}${suffix}`;
       }
       if (specifier.startsWith(".") || specifier.startsWith("/")) {
         return `${prefix}${specifier}${suffix}`;
@@ -11925,20 +11934,20 @@ ${fields}
       if (!resolved2)
         return null;
       const relativeImport = relative9(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
-      importRewrites.set(specifier, relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`);
+      const relativeRewrite = relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
+      importRewrites.set(specifier, relativeRewrite);
       return resolved2;
     }).filter((path) => Boolean(path));
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey2 = actualPath;
-    if (jitContentCache.get(cacheKey2) === contentHash && existsSync16(targetPath)) {
-      allOutputs.push(targetPath);
-    } else {
+    const shouldWriteFile = cacheBuster ? true : jitContentCache.get(cacheKey2) !== contentHash || !existsSync16(targetPath);
+    if (shouldWriteFile) {
       const processedContent = transpileAndRewrite(sourceCode, relativeDir, actualPath, importRewrites);
       await fs.mkdir(targetDir, { recursive: true });
       await fs.writeFile(targetPath, processedContent, "utf-8");
-      allOutputs.push(targetPath);
       jitContentCache.set(cacheKey2, contentHash);
     }
+    allOutputs.push(targetPath);
     await Promise.all(localImportPaths.map((importPath) => transpileFile(importPath)));
   };
   await transpileFile(inputPath);
@@ -15412,7 +15421,25 @@ ${stubs}
   return `${imports.join(`
 `)}
 ${code}`;
-}, reactTranspilerOptions, reactTranspiler, transformReactFile = (filePath, projectRoot, rewriter) => {
+}, reactTranspilerOptions, reactTranspiler, probeReactFastRefresh = () => {
+  try {
+    const probeOptions = {
+      loader: "tsx",
+      reactFastRefresh: true
+    };
+    const probe = new Bun.Transpiler(probeOptions);
+    const out = probe.transformSync("export function __AbsoluteRefreshProbe(){return null;}");
+    return out.includes("$RefreshReg$");
+  } catch {
+    return false;
+  }
+}, reactFastRefreshSupported, reactFastRefreshWarningEmitted = false, warnIfReactFastRefreshUnsupported = () => {
+  if (reactFastRefreshSupported || reactFastRefreshWarningEmitted)
+    return;
+  reactFastRefreshWarningEmitted = true;
+  logWarn("React HMR is blocked: this Bun build ignores " + "`reactFastRefresh` on Bun.Transpiler, so component state " + "cannot be preserved across edits. Tracking " + "https://github.com/oven-sh/bun/pull/28312 \u2014 if it still has " + "not merged, leave a \uD83D\uDC4D on the PR so the Bun team knows it " + "is blocking you. Until then, React edits trigger a full " + "reload instead of a fast refresh.");
+}, transformReactFile = (filePath, projectRoot, rewriter) => {
+  warnIfReactFastRefreshUnsupported();
   const raw = readFileSync15(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
@@ -15935,6 +15962,7 @@ var init_moduleServer = __esm(() => {
   init_stylePreprocessor();
   init_lowerAwaitSlotSyntax();
   init_lowerIslandSyntax();
+  init_logger();
   init_transformCache();
   jsTranspiler2 = new Bun.Transpiler({
     loader: "js",
@@ -15980,6 +16008,7 @@ var init_moduleServer = __esm(() => {
     trimUnusedImports: true
   };
   reactTranspiler = new Bun.Transpiler(reactTranspilerOptions);
+  reactFastRefreshSupported = probeReactFastRefresh();
   svelteExternalCss = new Map;
   SRC_IMPORT_RE = /\/@src\/([^"'?\s]+)/g;
   SRC_URL_PREFIX = SRC_PREFIX;
@@ -16450,13 +16479,22 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { clientPaths, serverPaths } = await compileAngular2(pageEntries, angularDir, true, getStyleTransformConfig(state.config));
   const { getAngularServerVendorPaths: getAngularServerVendorPaths2 } = await Promise.resolve().then(() => exports_devVendorPaths);
   const angServerVendorPaths = getAngularServerVendorPaths2();
+  const ssrPaths = angServerVendorPaths ? serverPaths.map((serverPath) => serverPath.replace(/\.js$/, ".ssr.js")) : serverPaths;
   if (serverPaths.length > 0 && angServerVendorPaths) {
+    const { copyFile } = await import("fs/promises");
     const { rewriteImports: rewriteImports3 } = await Promise.resolve().then(() => (init_rewriteImports(), exports_rewriteImports));
-    await rewriteImports3(serverPaths, angServerVendorPaths);
+    await Promise.all(serverPaths.map((serverPath, idx) => {
+      const ssrPath = ssrPaths[idx];
+      if (!ssrPath)
+        return Promise.resolve();
+      return copyFile(serverPath, ssrPath);
+    }));
+    await rewriteImports3(ssrPaths, angServerVendorPaths);
   }
-  serverPaths.forEach((serverPath) => {
+  serverPaths.forEach((serverPath, idx) => {
     const fileBase = basename10(serverPath, ".js");
-    state.manifest[toPascal(fileBase)] = resolve29(serverPath);
+    const ssrPath = ssrPaths[idx] ?? serverPath;
+    state.manifest[toPascal(fileBase)] = resolve29(ssrPath);
   });
   if (clientPaths.length > 0) {
     await bundleAngularClient(state, clientPaths, state.resolvedPaths.buildDir);
@@ -16480,101 +16518,6 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   broadcastAngularPageUpdates(state, pagesToUpdate, manifest, startTime);
   onRebuildComplete({ hmrState: state, manifest });
   return manifest;
-}, resolveReactEntryForPageFile = (normalized, pagesPathResolved, reactIndexesPath) => {
-  const pageName = basename10(normalized, ".tsx");
-  const indexPath = resolve29(reactIndexesPath, `${pageName}.tsx`);
-  if (!existsSync22(indexPath)) {
-    return;
-  }
-  return indexPath;
-}, resolveReactEntriesFromDeps = (state, normalized, pagesPathResolved, reactIndexesPath, reactEntries) => {
-  const affected = getAffectedFiles(state.dependencyGraph, normalized);
-  affected.forEach((dep) => {
-    if (!dep.startsWith(pagesPathResolved)) {
-      return;
-    }
-    const pageName = basename10(dep, ".tsx");
-    const indexPath = resolve29(reactIndexesPath, `${pageName}.tsx`);
-    if (existsSync22(indexPath) && !reactEntries.includes(indexPath)) {
-      reactEntries.push(indexPath);
-    }
-  });
-}, resolveReactEntryForFile = (state, file3, pagesPathResolved, reactIndexesPath, reactEntries) => {
-  const normalized = resolve29(file3);
-  if (!normalized.startsWith(pagesPathResolved)) {
-    resolveReactEntriesFromDeps(state, normalized, pagesPathResolved, reactIndexesPath, reactEntries);
-    return;
-  }
-  const entry = resolveReactEntryForPageFile(normalized, pagesPathResolved, reactIndexesPath);
-  if (entry) {
-    reactEntries.push(entry);
-  }
-}, collectReactEntries = (state, filesToRebuild, reactPagesPath, reactIndexesPath) => {
-  const reactEntries = [];
-  const pagesPathResolved = resolve29(reactPagesPath);
-  filesToRebuild.forEach((file3) => {
-    resolveReactEntryForFile(state, file3, pagesPathResolved, reactIndexesPath, reactEntries);
-  });
-  return reactEntries;
-}, bundleReactClient = async (state, reactEntries, reactIndexesPath, buildDir) => {
-  const { build: bunBuild7 } = await Promise.resolve(globalThis.Bun);
-  const { generateManifest: generateManifest2 } = await Promise.resolve().then(() => (init_generateManifest(), exports_generateManifest));
-  const { getDevVendorPaths: getDevVendorPaths2 } = await Promise.resolve().then(() => exports_devVendorPaths);
-  const { rewriteReactImports: rewriteReactImports2 } = await Promise.resolve().then(() => (init_rewriteReactImports(), exports_rewriteReactImports));
-  const clientRoot = await computeClientRoot(state.resolvedPaths);
-  const depVendorPaths = globalThis.__depVendorPaths ?? {};
-  const refreshEntry = resolve29(reactIndexesPath, "_refresh.tsx");
-  if (!reactEntries.includes(refreshEntry)) {
-    reactEntries.push(refreshEntry);
-  }
-  let vendorPaths = getDevVendorPaths2();
-  if (!vendorPaths) {
-    const { computeVendorPaths: computeVendorPaths2 } = await Promise.resolve().then(() => (init_buildReactVendor(), exports_buildReactVendor));
-    const { setDevVendorPaths: setDevVendorPaths2 } = await Promise.resolve().then(() => exports_devVendorPaths);
-    vendorPaths = computeVendorPaths2();
-    setDevVendorPaths2(vendorPaths);
-  }
-  const { rmSync: rmSync3 } = await import("fs");
-  rmSync3(resolve29(buildDir, "react", "generated", "indexes"), {
-    force: true,
-    recursive: true
-  });
-  const clientResult = await bunBuild7({
-    entrypoints: reactEntries,
-    format: "esm",
-    jsx: { development: true },
-    naming: "[dir]/[name].[hash].[ext]",
-    outdir: buildDir,
-    plugins: [
-      createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
-    ],
-    reactFastRefresh: true,
-    root: clientRoot,
-    splitting: true,
-    target: "browser",
-    throw: false,
-    ...Object.keys({
-      ...vendorPaths ?? {},
-      ...depVendorPaths
-    }).length > 0 ? {
-      external: Object.keys({
-        ...vendorPaths ?? {},
-        ...depVendorPaths
-      })
-    } : {}
-  });
-  if (!clientResult.success) {
-    return;
-  }
-  if (vendorPaths || Object.keys(depVendorPaths).length > 0) {
-    await rewriteReactImports2(clientResult.outputs.map((art) => art.path), {
-      ...vendorPaths ?? {},
-      ...depVendorPaths
-    });
-  }
-  const clientManifest = generateManifest2(clientResult.outputs, buildDir);
-  Object.assign(state.manifest, clientManifest);
-  await populateAssetStore(state.assetStore, clientManifest, buildDir);
 }, getModuleUrl = async (pageFile) => {
   const { invalidateModule: invalidateModule2, warmCache: warmCache2, SRC_URL_PREFIX: SRC_URL_PREFIX2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
   invalidateModule2(pageFile);
@@ -16631,39 +16574,13 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     manifest: state.manifest
   });
   return state.manifest;
-}, handleReactFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
-  const reactDir = config.reactDirectory ?? "";
-  const reactPagesPath = resolve29(reactDir, "pages");
-  const reactIndexesPath = resolve29(reactDir, "generated", "indexes");
-  const { buildDir } = state.resolvedPaths;
+}, handleReactFastPath = async (state, _config, filesToRebuild, startTime, onRebuildComplete) => {
   const reactFiles = filesToRebuild.filter((file3) => detectFramework(file3, state.resolvedPaths) === "react");
-  if (reactFiles.length > 0) {
-    return handleReactModuleServerPath(state, reactFiles, startTime, onRebuildComplete);
-  }
-  const { generateReactIndexFiles: generateReactIndexFiles2 } = await Promise.resolve().then(() => (init_generateReactIndexes(), exports_generateReactIndexes));
-  await generateReactIndexFiles2(reactPagesPath, reactIndexesPath, true);
-  const reactEntries = collectReactEntries(state, filesToRebuild, reactPagesPath, reactIndexesPath);
-  if (reactEntries.length > 0) {
-    await bundleReactClient(state, reactEntries, reactIndexesPath, buildDir);
+  if (reactFiles.length === 0) {
+    onRebuildComplete({ hmrState: state, manifest: state.manifest });
+    return state.manifest;
   }
-  const { manifest } = state;
-  const duration = Date.now() - startTime;
-  const reactPageFiles = reactFiles.filter((file3) => file3.replace(/\\/g, "/").includes("/pages/"));
-  const sourceFiles = reactPageFiles.length > 0 ? reactPageFiles : reactFiles;
-  logHmrUpdate(sourceFiles[0] ?? reactFiles[0] ?? "", "react", duration);
-  broadcastToClients(state, {
-    data: {
-      framework: "react",
-      hasComponentChanges: true,
-      hasCSSChanges: false,
-      manifest,
-      primarySource: sourceFiles[0],
-      sourceFiles
-    },
-    type: "react-update"
-  });
-  onRebuildComplete({ hmrState: state, manifest });
-  return manifest;
+  return handleReactModuleServerPath(state, reactFiles, startTime, onRebuildComplete);
 }, handleServerManifestUpdate = (state, serverResult) => {
   if (!serverResult?.success) {
     return;
@@ -18237,5 +18154,5 @@ export {
   build
 };
 
-//# debugId=075C1C8286293C6864756E2164756E21
+//# debugId=324E7F2682AE824164756E2164756E21
 //# sourceMappingURL=build.js.map