@absolutejs/absolute 0.19.0-beta.763 → 0.19.0-beta.764

package/dist/index.js

@@ -43931,9 +43931,76 @@ ${registrations}
   if (typeof hostSource === "string")
     return hostSource;
   return fs2.readFile(fileName, "utf-8");
+}, safeStableStringify = (value2) => {
+  const seen = new WeakSet;
+  return JSON.stringify(value2, (_key, entry) => {
+    if (typeof entry === "function")
+      return `[Function:${entry.name}]`;
+    if (!entry || typeof entry !== "object")
+      return entry;
+    if (seen.has(entry))
+      return "[Circular]";
+    seen.add(entry);
+    if (Array.isArray(entry))
+      return entry;
+    return Object.fromEntries(Object.entries(entry).sort(([left], [right]) => left.localeCompare(right)));
+  });
+}, collectAngularResourcePaths = (source, fileDir) => {
+  const paths = [];
+  const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
+  if (templateUrlMatch?.[1])
+    paths.push(join15(fileDir, templateUrlMatch[1]));
+  const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
+  if (styleUrlMatch?.[1])
+    paths.push(join15(fileDir, styleUrlMatch[1]));
+  const styleUrlsMatch = findUncommentedMatch(source, /styleUrls\s*:\s*\[([^\]]+)\]/);
+  const urlMatches = styleUrlsMatch?.[1]?.match(/['"]([^'"]+)['"]/g);
+  if (urlMatches) {
+    for (const urlMatch of urlMatches) {
+      paths.push(join15(fileDir, urlMatch.replace(/['"]/g, "")));
+    }
+  }
+  return paths.map((path2) => resolve19(path2));
+}, readResourceCacheFile = async (cachePath) => {
+  try {
+    const entry = JSON.parse(await fs2.readFile(cachePath, "utf-8"));
+    if (entry.version !== 1 || typeof entry.source !== "string") {
+      return null;
+    }
+    return entry;
+  } catch {
+    return null;
+  }
+}, writeResourceCacheFile = async (cachePath, source) => {
+  await fs2.mkdir(dirname11(cachePath), { recursive: true });
+  await fs2.writeFile(cachePath, JSON.stringify({
+    source,
+    version: 1
+  }), "utf-8");
+}, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
+  const resourcePaths = collectAngularResourcePaths(source, dirname11(filePath));
+  const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
+    const content = await fs2.readFile(resourcePath, "utf-8");
+    return `${resourcePath}\x00${content}`;
+  }));
+  const cacheInput = [
+    "v1",
+    filePath,
+    source,
+    ...resourceContents,
+    safeStableStringify(stylePreprocessors ?? null)
+  ].join("\x00");
+  const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
+  return join15(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile4, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
+  const stats = {
+    cacheHits: 0,
+    cacheMisses: 0,
+    filesVisited: 0,
+    transformedFiles: 0
+  };
   const transformFile = async (filePath) => {
     const resolvedPath = resolve19(filePath);
     if (visited.has(resolvedPath))
@@ -43941,10 +44008,23 @@ ${registrations}
     visited.add(resolvedPath);
     if (!existsSync16(resolvedPath) || resolvedPath.endsWith(".d.ts"))
       return;
+    stats.filesVisited += 1;
     const source = await readFileForAotTransform(resolvedPath, readFile4);
-    const transformed = await inlineResources(source, dirname11(resolvedPath), stylePreprocessors);
-    if (transformed.source !== source) {
-      transformedSources.set(resolvedPath, transformed.source);
+    const cachePath = await resolveResourceTransformCachePath(resolvedPath, source, stylePreprocessors);
+    const cached = await readResourceCacheFile(cachePath);
+    let transformedSource;
+    if (cached) {
+      stats.cacheHits += 1;
+      transformedSource = cached.source;
+    } else {
+      stats.cacheMisses += 1;
+      const transformed = await inlineResources(source, dirname11(resolvedPath), stylePreprocessors);
+      transformedSource = transformed.source;
+      await writeResourceCacheFile(cachePath, transformedSource);
+    }
+    if (transformedSource !== source) {
+      stats.transformedFiles += 1;
+      transformedSources.set(resolvedPath, transformedSource);
     }
     const imports = extractLocalImportSpecifiers(source, resolvedPath);
     await Promise.all(imports.map(async (specifier) => {
@@ -43954,7 +44034,7 @@ ${registrations}
     }));
   };
   await Promise.all(inputPaths.map((inputPath) => transformFile(inputPath)));
-  return transformedSources;
+  return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
     const outputPath = resolve19(join15(outDir, relative9(process.cwd(), resolve19(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
@@ -44015,7 +44095,15 @@ ${registrations}
     emitted[relativePath] = text;
   };
   const originalReadFile = host.readFile;
-  const aotTransformedSources = await traceAngularPhase("aot/precompute-resources", () => precomputeAotResourceTransforms(inputPaths, originalReadFile?.bind(host), stylePreprocessors), { entries: inputPaths.length });
+  const { stats: aotResourceTransformStats, transformedSources } = await traceAngularPhase("aot/precompute-resources", () => precomputeAotResourceTransforms(inputPaths, originalReadFile?.bind(host), stylePreprocessors), { entries: inputPaths.length });
+  await traceAngularPhase("aot/resource-cache-summary", () => {
+    return;
+  }, {
+    cacheHits: aotResourceTransformStats.cacheHits,
+    cacheMisses: aotResourceTransformStats.cacheMisses,
+    filesVisited: aotResourceTransformStats.filesVisited,
+    transformedFiles: aotResourceTransformStats.transformedFiles
+  });
   host.readFile = (fileName) => {
     const source = originalReadFile ? originalReadFile.call(host, fileName) : undefined;
     if (typeof source !== "string")
@@ -44024,11 +44112,11 @@ ${registrations}
       return source;
     }
     const resolvedPath = resolve19(fileName);
-    return aotTransformedSources.get(resolvedPath) ?? source;
+    return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError2) => {
-    const source = aotTransformedSources.get(resolve19(fileName));
+    const source = transformedSources.get(resolve19(fileName));
     if (source) {
       return ts2.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -58675,5 +58763,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=2F07E1892FE8624964756E2164756E21
+//# debugId=076CED2F51B54E1564756E2164756E21
 //# sourceMappingURL=index.js.map