@absolutejs/absolute 0.19.0-beta.686 → 0.19.0-beta.688

package/dist/angular/index.js

@@ -1351,11 +1351,120 @@ var init_lowerAwaitSlotSyntax = __esm(() => {
   AWAIT_BLOCK_RE = /\{#await\s+([^}]+)\}([\s\S]*?)\{:then(?:\s+([A-Za-z_$][\w$]*))?\}([\s\S]*?)(?:\{:catch(?:\s+([A-Za-z_$][\w$]*))?\}([\s\S]*?))?\{\/await\}/g;
 });
 
+// src/build/stylePreprocessor.ts
+import { readFile } from "fs/promises";
+import { dirname as dirname2, extname } from "path";
+var STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATTERN, importOptionalPeer, isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath), isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less)$/i.test(filePath), getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less)$/i, ""), getStyleLanguage = (filePathOrLanguage) => {
+  const normalized = filePathOrLanguage.toLowerCase();
+  if (normalized === "scss" || normalized.endsWith(".scss"))
+    return "scss";
+  if (normalized === "sass" || normalized.endsWith(".sass"))
+    return "sass";
+  if (normalized === "less" || normalized.endsWith(".less"))
+    return "less";
+  return null;
+}, missingDependencyError = (name, filePath) => new Error(`Unable to compile ${filePath}: install optional dependency "${name}" to use this stylesheet preprocessor.`), compileStyleSource = async (filePath, source, languageHint) => {
+  const language = getStyleLanguage(languageHint ?? filePath);
+  const contents = source ?? await readFile(filePath, "utf-8");
+  if (language === "scss" || language === "sass") {
+    let sass;
+    try {
+      sass = await importOptionalPeer("sass");
+    } catch {
+      throw missingDependencyError("sass", filePath);
+    }
+    const result = sass.compileString(contents, {
+      loadPaths: [dirname2(filePath), process.cwd()],
+      style: "expanded",
+      syntax: language === "sass" ? "indented" : "scss",
+      url: new URL(`file://${filePath}`)
+    });
+    return result.css;
+  }
+  if (language === "less") {
+    let lessModule;
+    try {
+      lessModule = await importOptionalPeer("less");
+    } catch {
+      throw missingDependencyError("less", filePath);
+    }
+    const less = lessModule.render ? lessModule : lessModule.default;
+    const render = less?.render;
+    if (!render)
+      throw missingDependencyError("less", filePath);
+    const result = await render(contents, {
+      filename: filePath,
+      paths: [dirname2(filePath), process.cwd()]
+    });
+    return result.css;
+  }
+  return contents;
+}, stylePreprocessorPlugin, createSvelteStylePreprocessor = () => ({
+  style: async ({
+    attributes,
+    content,
+    filename
+  }) => {
+    const language = typeof attributes.lang === "string" ? attributes.lang : typeof attributes.type === "string" ? attributes.type.replace(/^text\//, "") : null;
+    if (!language || !STYLE_LANGUAGE_PATTERN.test(language))
+      return;
+    const path = filename ?? `style.${language}`;
+    return {
+      code: await compileStyleSource(path, content, language)
+    };
+  }
+}), compileStyleFileIfNeeded = async (filePath) => {
+  if (!isPreprocessableStylePath(filePath)) {
+    return readFile(filePath, "utf-8");
+  }
+  return compileStyleSource(filePath);
+};
+var init_stylePreprocessor = __esm(() => {
+  STYLE_EXTENSION_PATTERN = /\.(s[ac]ss|less)$/i;
+  STYLE_MODULE_EXTENSION_PATTERN = /\.module\.(s[ac]ss|less)$/i;
+  STYLE_LANGUAGE_PATTERN = /^(s[ac]ss|less)$/i;
+  importOptionalPeer = new Function("specifier", "return import(specifier)");
+  stylePreprocessorPlugin = {
+    name: "absolute-style-preprocessor",
+    setup(build) {
+      const cssModuleSources = new Map;
+      build.onResolve({ filter: /^absolute-style-module:/ }, ({ path }) => ({
+        namespace: "absolute-style-module",
+        path: path.slice("absolute-style-module:".length)
+      }));
+      build.onLoad({ filter: /\.module\.css$/i, namespace: "absolute-style-module" }, async ({ path }) => {
+        const sourcePath = cssModuleSources.get(path);
+        if (!sourcePath) {
+          throw new Error(`Unable to resolve CSS module source for ${path}`);
+        }
+        return {
+          contents: await compileStyleSource(sourcePath),
+          loader: "css"
+        };
+      });
+      build.onLoad({ filter: STYLE_EXTENSION_PATTERN }, async ({ path }) => {
+        if (isStyleModulePath(path)) {
+          const cssModulePath = path.replace(STYLE_EXTENSION_PATTERN, ".css");
+          cssModuleSources.set(cssModulePath, path);
+          return {
+            contents: `export { default } from ${JSON.stringify(`absolute-style-module:${cssModulePath}`)};`,
+            loader: "js"
+          };
+        }
+        return {
+          contents: await compileStyleSource(path),
+          loader: "css"
+        };
+      });
+    }
+  };
+});
+
 // src/core/svelteServerModule.ts
 import { mkdir, readdir } from "fs/promises";
-import { basename as basename2, dirname as dirname2, extname, join as join3, relative, resolve as resolve4 } from "path";
+import { basename as basename2, dirname as dirname3, extname as extname2, join as join3, relative, resolve as resolve4 } from "path";
 var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
-  const importPath = relative(dirname2(from), target).replace(/\\/g, "/");
+  const importPath = relative(dirname3(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
   for (const entry of entries) {
@@ -1401,7 +1510,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const basePath = resolve4(dirname2(from), spec);
+  const basePath = resolve4(dirname3(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -1433,8 +1542,8 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const explicitPath = resolve4(dirname2(from), spec);
-  if (extname(explicitPath) === ".svelte") {
+  const explicitPath = resolve4(dirname3(from), spec);
+  if (extname2(explicitPath) === ".svelte") {
     return explicitPath;
   }
   const candidate = `${explicitPath}.svelte`;
@@ -1462,7 +1571,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   const { compile, preprocess } = await import("svelte/compiler");
   const loweredAwaitSource = lowerSvelteAwaitSlotSyntax(source);
   const loweredSource = lowerSvelteIslandSyntax(loweredAwaitSource.code, "server");
-  const preprocessed = await preprocess(loweredSource.code, {});
+  const preprocessed = await preprocess(loweredSource.code, createSvelteStylePreprocessor());
   let transpiled = sourcePath.endsWith(".ts") || sourcePath.endsWith(".svelte.ts") ? transpiler.transformSync(preprocessed.code) : preprocessed.code;
   const childImportSpecs = Array.from(transpiled.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((value) => value !== undefined);
   const resolvedChildModules = await Promise.all(childImportSpecs.map((spec) => resolveSvelteImport(spec, resolutionSourcePath)));
@@ -1512,7 +1621,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
     compiledCode = compiledCode.replaceAll(spec, resolvedModuleImport);
   }
   const compiledModulePath = getCachedModulePath(sourcePath);
-  await mkdir(dirname2(compiledModulePath), { recursive: true });
+  await mkdir(dirname3(compiledModulePath), { recursive: true });
   await writeIfChanged(compiledModulePath, compiledCode);
   compiledModuleCache.set(sourcePath, compiledModulePath);
   return compiledModulePath;
@@ -1521,6 +1630,7 @@ var init_svelteServerModule = __esm(() => {
   init_resolvePackageImport();
   init_lowerIslandSyntax();
   init_lowerAwaitSlotSyntax();
+  init_stylePreprocessor();
   serverCacheRoot = join3(process.cwd(), ".absolutejs", "islands", "svelte");
   compiledModuleCache = new Map;
   originalSourcePathCache = new Map;
@@ -3406,7 +3516,7 @@ __export(exports_compileAngular, {
   compileAngular: () => compileAngular
 });
 import { existsSync as existsSync4, readFileSync as readFileSync3, promises as fs } from "fs";
-import { join as join4, basename as basename3, sep, dirname as dirname3, resolve as resolve5, relative as relative2 } from "path";
+import { join as join4, basename as basename3, sep, dirname as dirname4, resolve as resolve5, relative as relative2 } from "path";
 import ts from "typescript";
 import { createHash } from "crypto";
 var computeConfigHash = () => {
@@ -3470,11 +3580,7 @@ ${registrations}
   return fileName;
 }, compileAngularFile = async (inputPath, outDir) => {
   const islandMetadataExports = buildIslandMetadataExports(readFileSync3(inputPath, "utf-8"));
-  const {
-    readConfiguration,
-    performCompilation,
-    EmitFlags
-  } = await import("@angular/compiler-cli");
+  const { readConfiguration, performCompilation, EmitFlags } = await import("@angular/compiler-cli");
   const configHash = computeConfigHash();
   const cached = globalThis.__angularCompilerCache;
   let host;
@@ -3487,7 +3593,7 @@ ${registrations}
     cached.lastUsed = Date.now();
   } else {
     const tsPath = __require.resolve("typescript");
-    const tsRootDir = dirname3(tsPath);
+    const tsRootDir = dirname4(tsPath);
     tsLibDir = tsRootDir.endsWith("lib") ? tsRootDir : resolve5(tsRootDir, "lib");
     const config = readConfiguration("./tsconfig.json");
     options = {
@@ -3553,7 +3659,7 @@ ${registrations}
     const cached2 = aotTransformCache.get(resolvedPath);
     if (cached2 !== undefined)
       return cached2;
-    const transformed = inlineTemplateAndLowerDeferSync(source, dirname3(resolvedPath)).source;
+    const transformed = inlineTemplateAndLowerDeferSync(source, dirname4(resolvedPath)).source;
     aotTransformCache.set(resolvedPath, transformed);
     return transformed;
   };
@@ -3595,7 +3701,7 @@ ${registrations}
     processedContent += islandMetadataExports;
     return { content: processedContent, target };
   });
-  await Promise.all(entries.map(({ target }) => fs.mkdir(dirname3(target), { recursive: true })));
+  await Promise.all(entries.map(({ target }) => fs.mkdir(dirname4(target), { recursive: true })));
   await Promise.all(entries.map(({ target, content }) => fs.writeFile(target, content, "utf-8")));
   return entries.map(({ target }) => target);
 }, jitContentCache, wrapperOutputCache, escapeTemplateContent = (content) => content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${"), resolveAngularDeferImportSpecifier = () => {
@@ -3730,7 +3836,7 @@ ${fields}
 }, readAndEscapeFile = async (filePath) => {
   if (!existsSync4(filePath))
     return null;
-  const content = await fs.readFile(filePath, "utf-8");
+  const content = await compileStyleFileIfNeeded(filePath);
   return escapeTemplateContent(content);
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = source.match(/templateUrl\s*:\s*['"]([^'"]+)['"]/);
@@ -3884,9 +3990,9 @@ ${fields}
     if (!existsSync4(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname3(actualPath));
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname3(actualPath)).source;
-    const inputDir = dirname3(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname4(actualPath));
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname4(actualPath)).source;
+    const inputDir = dirname4(actualPath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename3(actualPath).replace(/\.ts$/, ".js");
     const targetDir = join4(outDir, relativeDir);
@@ -3914,7 +4020,7 @@ ${fields}
       allOutputs.push(targetPath);
       jitContentCache.set(cacheKey, contentHash);
     }
-    const inputDirForResolve = dirname3(actualPath);
+    const inputDirForResolve = dirname4(actualPath);
     await Promise.all(localImports.map((imp) => {
       const importPath = resolve5(inputDirForResolve, imp);
       return transpileFile(importPath);
@@ -3977,7 +4083,11 @@ ${fields}
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
     const clientFile = join4(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync4(clientFile)) {
-      return { clientPath: clientFile, indexUnchanged: true, serverPath: rawServerFile };
+      return {
+        clientPath: clientFile,
+        indexUnchanged: true,
+        serverPath: rawServerFile
+      };
     }
     let rewritten = original;
     if (!rewritten.includes(`import '@angular/compiler';`)) {
@@ -4134,8 +4244,15 @@ if (pageHasRawStreamingSlots) {
     const indexHash = Bun.hash(hydration).toString(BASE_36_RADIX);
     const indexUnchanged = cachedWrapper?.indexHash === indexHash;
     await fs.writeFile(clientFile, hydration, "utf-8");
-    wrapperOutputCache.set(resolvedEntry, { indexHash, serverHash: serverContentHash });
-    return { clientPath: clientFile, indexUnchanged, serverPath: rawServerFile };
+    wrapperOutputCache.set(resolvedEntry, {
+      indexHash,
+      serverHash: serverContentHash
+    });
+    return {
+      clientPath: clientFile,
+      indexUnchanged,
+      serverPath: rawServerFile
+    };
   });
   const results = await Promise.all(compileTasks);
   const serverPaths = results.map((r) => r.serverPath);
@@ -4150,6 +4267,7 @@ var init_compileAngular = __esm(() => {
   init_constants();
   init_sourceMetadata();
   init_lowerDeferSyntax();
+  init_stylePreprocessor();
   devClientDir = resolveDevClientDir();
   hmrClientPath = join4(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
   hmrRuntimePath = join4(devClientDir, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
@@ -4161,14 +4279,14 @@ var init_compileAngular = __esm(() => {
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 import { mkdir as mkdir2, symlink } from "fs/promises";
 import { tmpdir } from "os";
-import { basename as basename4, dirname as dirname4, join as join5, resolve as resolve6 } from "path";
+import { basename as basename4, dirname as dirname5, join as join5, resolve as resolve6 } from "path";
 var ssrDirty = false, lastSelector = "angular-page", isRecord5 = (value) => typeof value === "object" && value !== null, isAngularComponent = (value) => typeof value === "function", compilerImportPromise = null, ensureAngularCompiler = () => {
   if (!compilerImportPromise) {
     compilerImportPromise = import("@angular/compiler");
   }
   return compilerImportPromise;
 }, readAngularPageModule = (value) => isRecord5(value) ? value : null, resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join5(tmpdir(), "absolutejs", "generated", "angular-ssr"), ensureAngularSsrNodeModules = async (outDir) => {
-  const outRoot = resolve6(dirname4(dirname4(outDir)));
+  const outRoot = resolve6(dirname5(dirname5(outDir)));
   const nodeModulesLink = join5(outRoot, "node_modules");
   if (process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR) {
     return;
@@ -13544,5 +13662,5 @@ export {
   Island
 };
 
-//# debugId=962248461B9BD20764756E2164756E21
+//# debugId=430C10B9B0F9B06E64756E2164756E21
 //# sourceMappingURL=index.js.map