@salty-css/core 0.2.1 → 0.2.2-refactor-vite-8.4

package/compiler/salty-compiler.js

@@ -1,827 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import * as esbuild from "esbuild";
-import { resolve, dirname, relative, join, basename, parse } from "path";
-import { createLogger, transports, format } from "winston";
-import { readFile } from "fs/promises";
-import { existsSync, mkdirSync, copyFileSync, readFileSync, statSync, readdirSync, writeFileSync } from "fs";
-import { execSync } from "child_process";
-import { isSaltyFile, resolveExportValue, saltyFileExtensions } from "./helpers.js";
-import { t as toHash, d as dashCase } from "../to-hash-DSoCPs8D.js";
-import { n as normalizePath, i as isPathAllowed } from "../glob-match-C28iYp1A.js";
-import { d as defineTemplates } from "../define-templates-CVhhgPnd.js";
-import { createRequire } from "module";
-import { p as parseAndJoinStyles, c as parseVariableTokens } from "../parse-styles-BlUpavVg.js";
-import { mergeObjects, mergeFactories } from "../css/merge.js";
-import { getPackageJson } from "./get-files.js";
-import { parseTemplates, getTemplateTypes, getTemplateVariantMaps } from "../parsers/index.js";
-import console from "console";
-const logger = createLogger({
-  level: "debug",
-  format: format.combine(format.colorize(), format.cli()),
-  transports: [new transports.Console({})]
-});
-const logError = (message) => {
-  logger.error(message);
-};
-const EXTERNAL_URL = /^(?:[a-z][a-z0-9+.-]*:)?\/\//i;
-const normaliseSpec = (spec) => {
-  if (typeof spec === "string") return { url: spec };
-  return spec;
-};
-const ensureRelativePrefix = (path) => {
-  if (path.startsWith(".") || path.startsWith("/")) return path;
-  return `./${path}`;
-};
-const toPosix = (path) => path.split("\\").join("/");
-const defaultResolveModule = (specifier, sourceFile) => {
-  return createRequire(sourceFile).resolve(specifier);
-};
-const defaultCopyAsset = (from, to) => {
-  const dir = dirname(to);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  copyFileSync(from, to);
-};
-const buildRule = (url, { media, supports }) => {
-  let rule = `@import url('${url}')`;
-  if (supports) rule += ` supports(${supports})`;
-  if (media) rule += ` ${media}`;
-  return `${rule};`;
-};
-const resolveImport = (spec, sourceFile, destDir, options = {}) => {
-  const opts = normaliseSpec(spec);
-  const { url } = opts;
-  const resolveModule = options.resolveModule ?? defaultResolveModule;
-  const copyAsset = options.copyAsset ?? defaultCopyAsset;
-  if (EXTERNAL_URL.test(url)) {
-    return { rule: buildRule(url, opts) };
-  }
-  if (url.startsWith("/")) {
-    return { rule: buildRule(url, opts) };
-  }
-  if (url.startsWith("./") || url.startsWith("../")) {
-    const absolute2 = resolve(dirname(sourceFile), url);
-    const fromImportsFile = relative(join(destDir, "css"), absolute2);
-    return { rule: buildRule(ensureRelativePrefix(toPosix(fromImportsFile)), opts) };
-  }
-  const specifier = url.startsWith("~") ? url.slice(1) : url;
-  const absolute = resolveModule(specifier, sourceFile);
-  const hash = toHash(absolute, 6);
-  const fileName = `${hash}-${basename(absolute)}`;
-  const destPath = join(destDir, "imports", fileName);
-  copyAsset(absolute, destPath);
-  return { rule: buildRule(`../imports/${fileName}`, opts) };
-};
-const readPackageJsonModule = async (dirname2) => {
-  const packageJsonContent = await getPackageJson(dirname2);
-  if (!packageJsonContent) return void 0;
-  return packageJsonContent.type;
-};
-let cachedModuleType;
-const detectCurrentModuleType = async (dirname2) => {
-  if (cachedModuleType) return cachedModuleType;
-  const packageJsonModule = await readPackageJsonModule(dirname2);
-  if (packageJsonModule === "module") cachedModuleType = "esm";
-  else if (packageJsonModule === "commonjs") cachedModuleType = "cjs";
-  else if (import.meta.url.endsWith(".cjs")) cachedModuleType = "cjs";
-  return cachedModuleType || "esm";
-};
-function dotCase(str) {
-  if (!str) return "";
-  if (typeof str !== "string") return dotCase(String(str));
-  return str.replace(/[^\d\w]/g, ".");
-}
-const saltyReset = {
-  /** Set box model to border-box */
-  "*, *::before, *::after": {
-    boxSizing: "border-box"
-  },
-  /** Remove default margin and padding */
-  "*": {
-    margin: 0
-  },
-  /** Remove adjust font properties */
-  html: {
-    lineHeight: 1.15,
-    textSizeAdjust: "100%",
-    WebkitFontSmoothing: "antialiased"
-  },
-  /** Make media elements responsive */
-  "img, picture, video, canvas, svg": {
-    display: "block",
-    maxWidth: "100%"
-  },
-  /** Avoid overflow of text */
-  "p, h1, h2, h3, h4, h5, h6": {
-    overflowWrap: "break-word"
-  },
-  /** Improve text wrapping */
-  p: {
-    textWrap: "pretty"
-  },
-  "h1, h2, h3, h4, h5, h6": {
-    textWrap: "balance"
-  },
-  /** Improve link color */
-  a: {
-    color: "currentColor"
-  },
-  /** Improve button line height */
-  button: {
-    lineHeight: "1em",
-    color: "currentColor"
-  },
-  /** Improve form elements */
-  "input, optgroup, select, textarea": {
-    fontFamily: "inherit",
-    fontSize: "100%",
-    lineHeight: "1.15em"
-  }
-};
-class SaltyCompiler {
-  constructor(projectRootDir, options = {}) {
-    __publicField(this, "importFile", (path) => {
-      const now = Date.now();
-      return import(
-        /* @vite-ignore */
-        `${path}?t=${now}`
-      );
-    });
-    __publicField(this, "cache", {
-      rcFile: null,
-      destDir: null,
-      externalModules: []
-    });
-    /**
-     * Locate and read the .saltyrc.json file starting from the current directory and moving up the directory tree.
-     * Caches the result to avoid redundant file reads.
-     */
-    __publicField(this, "readRCFile", async (currentDir = this.projectRootDir) => {
-      if (this.cache.rcFile) return this.cache.rcFile;
-      if (currentDir === "/") throw new Error("Could not find .saltyrc.json file");
-      const rcPath = join(currentDir, ".saltyrc.json");
-      const rcContent = await readFile(rcPath, "utf-8").then(JSON.parse).catch(() => void 0);
-      if (!rcContent) return this.readRCFile(join(currentDir, ".."));
-      this.cache.rcFile = rcContent;
-      return rcContent;
-    });
-    /**
-     * Get the project configuration from the .saltyrc.json file based on the current directory.
-     * If no specific project configuration is found, it falls back to the default project.
-     */
-    __publicField(this, "getRCProjectConfig", async (dirname2) => {
-      var _a, _b;
-      const rcFile = await this.readRCFile(dirname2);
-      const projectConfig = (_a = rcFile.projects) == null ? void 0 : _a.find((project) => dirname2.endsWith(project.dir || ""));
-      if (!projectConfig) return (_b = rcFile.projects) == null ? void 0 : _b.find((project) => project.dir === rcFile.defaultProject);
-      return projectConfig;
-    });
-    /**
-     * Read the optional `include` / `exclude` glob filters for the current project from
-     * `.saltyrc.json`. Used to scope which files the compiler discovers and watches.
-     */
-    __publicField(this, "getPathFilter", async () => {
-      const projectConfig = await this.getRCProjectConfig(this.projectRootDir);
-      return { include: projectConfig == null ? void 0 : projectConfig.include, exclude: projectConfig == null ? void 0 : projectConfig.exclude };
-    });
-    /**
-     * Whether a file should be compiled: it must be a salty file and pass the project's
-     * `include` / `exclude` filters. `relPath` is the path relative to the project root.
-     */
-    __publicField(this, "isAllowedSaltyFile", (file, filter) => {
-      if (!isSaltyFile(file)) return false;
-      const relPath = normalizePath(relative(this.projectRootDir, file));
-      return isPathAllowed(relPath, filter);
-    });
-    __publicField(this, "getExternalModules", (coreConfigPath) => {
-      if (this.cache.externalModules.length > 0) return this.cache.externalModules;
-      const content = readFileSync(coreConfigPath, "utf8");
-      const match = content.match(/externalModules:\s?\[(.*)\]/);
-      if (!match) return [];
-      const externalModules = match[1].split(",").map((d) => d.replace(/['"`]/g, "").trim());
-      this.cache.externalModules = externalModules;
-      return externalModules;
-    });
-    /**
-     * Get the destination directory for generated files based on the project configuration.
-     * Caches the result to avoid redundant computations.
-     */
-    __publicField(this, "getDestDir", async () => {
-      if (this.cache.destDir) return this.cache.destDir;
-      const projectConfig = await this.getRCProjectConfig(this.projectRootDir);
-      const destDir = join(this.projectRootDir, (projectConfig == null ? void 0 : projectConfig.saltygenDir) || "saltygen");
-      this.cache.destDir = destDir;
-      return destDir;
-    });
-    __publicField(this, "generateConfig", async () => {
-      const rcProject = await this.getRCProjectConfig(this.projectRootDir);
-      const destDir = await this.getDestDir();
-      const coreConfigPath = join(this.projectRootDir, (rcProject == null ? void 0 : rcProject.configDir) || "", "salty.config.ts");
-      const coreConfigDest = join(destDir, "salty.config.js");
-      const moduleType = await detectCurrentModuleType(this.projectRootDir);
-      const externalModules = this.getExternalModules(coreConfigPath);
-      await esbuild.build({
-        entryPoints: [coreConfigPath],
-        minify: true,
-        treeShaking: true,
-        bundle: true,
-        outfile: coreConfigDest,
-        format: moduleType,
-        external: externalModules
-      });
-      const { config } = await this.importFile(coreConfigDest);
-      return { config, path: coreConfigDest };
-    });
-    __publicField(this, "addConfigCache", (currentFile) => {
-      try {
-        const saltyCachedConfig = readFileSync(join(this.projectRootDir, "saltygen/cache/config-cache.json"), "utf8");
-        if (!saltyCachedConfig) return `globalThis.saltyConfig = {};
-
-${currentFile}`;
-        return `globalThis.saltyConfig = ${saltyCachedConfig};
-
-${currentFile}`;
-      } catch {
-        return currentFile;
-      }
-    });
-    __publicField(this, "getConfigCache", async () => {
-      const destDir = await this.getDestDir();
-      const coreConfigDest = join(destDir, "cache/config-cache.json");
-      const contents = readFileSync(coreConfigDest, "utf8");
-      if (!contents) throw new Error("Could not find config cache file");
-      return JSON.parse(contents);
-    });
-    __publicField(this, "getConfig", async () => {
-      const cached = await this.getConfigCache();
-      const destDir = await this.getDestDir();
-      const coreConfigDest = join(destDir, "salty.config.js");
-      const { config } = await this.importFile(coreConfigDest);
-      return mergeObjects(cached, config);
-    });
-    /**
-     * Generate CSS files based on the Salty CSS configuration and source files.
-     */
-    __publicField(this, "generateCss", async (clean = true) => {
-      try {
-        const start = Date.now();
-        if (this.isProduction) logger.info("Generating CSS in production mode! 🔥");
-        else logger.info("Generating CSS in development mode! 🚀");
-        const globalCssFiles = [];
-        const cssFiles = [];
-        const destDir = await this.getDestDir();
-        const cssFile = join(destDir, "index.css");
-        const clearDistDir = () => {
-          if (existsSync(destDir)) execSync("rm -rf " + destDir);
-          mkdirSync(destDir, { recursive: true });
-          mkdirSync(join(destDir, "css"));
-          mkdirSync(join(destDir, "types"));
-          mkdirSync(join(destDir, "js"));
-          mkdirSync(join(destDir, "cache"));
-          mkdirSync(join(destDir, "imports"));
-        };
-        if (clean) clearDistDir();
-        const files = /* @__PURE__ */ new Set();
-        const configFiles = /* @__PURE__ */ new Set();
-        const pathFilter = await this.getPathFilter();
-        const { exclude } = pathFilter;
-        const projectRootDir = this.projectRootDir;
-        async function collectFiles(src) {
-          const foldersToSkip = ["node_modules", "saltygen"];
-          const stats = statSync(src);
-          if (stats.isDirectory()) {
-            const shouldSkip = foldersToSkip.some((folder) => src.includes(folder));
-            if (shouldSkip) return;
-            if (exclude == null ? void 0 : exclude.length) {
-              const relDir = normalizePath(relative(projectRootDir, src));
-              if (relDir && !isPathAllowed(relDir, { exclude })) return;
-            }
-            const files2 = readdirSync(src);
-            await Promise.all(files2.map((file) => collectFiles(join(src, file))));
-          } else if (stats.isFile()) {
-            const validFile = isSaltyFile(src) && isPathAllowed(normalizePath(relative(projectRootDir, src)), pathFilter);
-            if (validFile) {
-              files.add(src);
-              const contents = readFileSync(src, "utf8");
-              const hasDefineFunction = /define[\w\d]+\(/.test(contents);
-              if (hasDefineFunction) configFiles.add(src);
-            }
-          }
-        }
-        await collectFiles(this.projectRootDir);
-        await this.generateConfigStyles(configFiles);
-        const generationResults = {
-          keyframes: [],
-          components: [],
-          classNames: []
-        };
-        await Promise.all(
-          [...files].map(async (src) => {
-            const { contents } = await this.compileSaltyFile(src, destDir);
-            for (const [name, value] of Object.entries(contents)) {
-              const resolved = await resolveExportValue(value, 1);
-              if (resolved.isKeyframes) {
-                generationResults.keyframes.push({
-                  value: resolved,
-                  src,
-                  name
-                });
-              } else if (resolved.isClassName) {
-                generationResults.classNames.push({
-                  ...value,
-                  src,
-                  name
-                });
-              } else if (resolved.generator) {
-                generationResults.components.push({
-                  ...value,
-                  src,
-                  name
-                });
-              }
-            }
-          })
-        );
-        const config = await this.getConfig();
-        for (const keyframes of generationResults.keyframes) {
-          const { value } = keyframes;
-          const fileName = `a_${value.animationName}.css`;
-          const filePath = `css/${fileName}`;
-          const cssPath = join(destDir, filePath);
-          globalCssFiles.push(fileName);
-          writeFileSync(cssPath, value.css);
-        }
-        const localCssFiles = {};
-        for (const componentResult of generationResults.components) {
-          const { src, name } = componentResult;
-          if (!localCssFiles[src]) localCssFiles[src] = [];
-          const generator = componentResult.generator._withBuildContext({
-            callerName: name,
-            isProduction: this.isProduction,
-            config
-          });
-          if (!cssFiles[generator.priority]) cssFiles[generator.priority] = [];
-          const styles = await generator.css;
-          if (!styles) continue;
-          cssFiles[generator.priority].push(generator.cssFileName);
-          const filePath = `css/${generator.cssFileName}`;
-          const cssPath = join(destDir, filePath);
-          writeFileSync(cssPath, styles);
-          if (config.importStrategy === "component") {
-            localCssFiles[src].push(generator.cssFileName);
-          }
-        }
-        for (const classNameResult of generationResults.classNames) {
-          const { src, name } = classNameResult;
-          if (!localCssFiles[src]) localCssFiles[src] = [];
-          const generator = classNameResult.generator._withBuildContext({
-            callerName: name,
-            isProduction: this.isProduction,
-            config
-          });
-          const styles = await generator.css;
-          if (!styles) continue;
-          if (!cssFiles[generator.priority]) cssFiles[generator.priority] = [];
-          cssFiles[generator.priority].push(generator.cssFileName);
-          const filePath = `css/${generator.cssFileName}`;
-          const cssPath = join(destDir, filePath);
-          writeFileSync(cssPath, styles);
-          if (config.importStrategy === "component") {
-            localCssFiles[src].push(generator.cssFileName);
-          }
-        }
-        if (config.importStrategy === "component") {
-          Object.entries(localCssFiles).forEach(([src, localCssFile]) => {
-            const cssContent2 = localCssFile.map((file) => `@import url('./${file}');`).join("\n");
-            const hashName = toHash(src, 6);
-            const parsedPath = parse(src);
-            const dasherized = dashCase(parsedPath.name);
-            const cssFile2 = join(destDir, `css/f_${dasherized}-${hashName}.css`);
-            writeFileSync(cssFile2, cssContent2 || `/* Empty file */`);
-          });
-        }
-        const otherGlobalCssFiles = globalCssFiles.map((file) => `@import url('./css/${file}');`).join("\n");
-        const globalCssFilenames = ["_imports.css", "_variables.css", "_reset.css", "_global.css", "_templates.css", "_fonts.css"];
-        const importsWithData = globalCssFilenames.filter((file) => {
-          try {
-            const data = readFileSync(join(destDir, "css", file), "utf8");
-            return data.length > 0;
-          } catch {
-            return false;
-          }
-        });
-        const globalImports = importsWithData.map((file) => {
-          const layerSuffix = file === "_imports.css" ? " layer(imports)" : "";
-          return `@import url('./css/${file}')${layerSuffix};`;
-        });
-        const generatorText = "/*!\n * Generated with Salty CSS (https://salty-css.dev)\n * Do not edit this file directly\n */\n";
-        let cssContent = `${generatorText}@layer imports, reset, global, templates, fonts, l0, l1, l2, l3, l4, l5, l6, l7, l8;
-
-${globalImports.join(
-          "\n"
-        )}
-${otherGlobalCssFiles}`;
-        if (config.importStrategy !== "component") {
-          const mergedContent = cssFiles.reduce((acc, val, layer) => {
-            const layerContent = val.reduce((layerAcc, file) => {
-              var _a;
-              const filepath = join(destDir, "css", file);
-              const css = readFileSync(filepath, "utf8");
-              const filepathHash = ((_a = /.*-([^-]+)-\d+.css/.exec(file)) == null ? void 0 : _a.at(1)) || toHash(filepath, 6);
-              if (layerAcc.includes(filepathHash)) return layerAcc;
-              return `${layerAcc}
-/*start:${filepathHash}-${file}*/
-${css}
-/*end:${filepathHash}*/
-`;
-            }, "");
-            const layerFileName = `l_${layer}.css`;
-            const layerFilePath = join(destDir, "css", layerFileName);
-            const layerContentWithLayer = `@layer l${layer} { ${layerContent}
- }`;
-            writeFileSync(layerFilePath, layerContentWithLayer);
-            return `${acc}
-@import url('./css/${layerFileName}');`;
-          }, "");
-          cssContent += mergedContent;
-        }
-        writeFileSync(cssFile, cssContent);
-        const end = Date.now();
-        const time = end - start;
-        const emoji = time < 200 ? "🔥" : time < 500 ? "🚀" : time < 1e3 ? "🎉" : time < 2e3 ? "🚗" : time < 5e3 ? "🤔" : "🥴";
-        logger.info(`Generated CSS in ${time}ms! ${emoji}`);
-      } catch (e) {
-        console.error(e);
-      }
-    });
-    __publicField(this, "generateConfigStyles", async (configFiles) => {
-      var _a, _b;
-      const destDir = await this.getDestDir();
-      const generationResults = {
-        mediaQueries: [],
-        globalStyles: [],
-        variables: [],
-        templates: [],
-        imports: [],
-        fonts: []
-      };
-      await Promise.all(
-        [...configFiles].map(async (src) => {
-          const { contents, outputFilePath } = await this.compileSaltyFile(src, destDir);
-          Object.entries(contents).forEach(([name, value]) => {
-            if (value.isMedia) generationResults.mediaQueries.push([name, value]);
-            else if (value.isGlobalDefine) generationResults.globalStyles.push(value);
-            else if (value.isDefineVariables) generationResults.variables.push(value);
-            else if (value.isDefineTemplates) generationResults.templates.push(value._setPath(`${name};;${outputFilePath}`));
-            else if (value.isDefineImport) generationResults.imports.push(value._setPath(src));
-            else if (value.isDefineFont) generationResults.fonts.push(value);
-          });
-        })
-      );
-      const { config, path: configPath } = await this.generateConfig();
-      const configCacheContent = { ...config };
-      const { mediaQueries } = generationResults;
-      configCacheContent.mediaQueries = Object.fromEntries(mediaQueries.map(([name, value]) => [`@${name}`, value]));
-      const mediaQueryKeys = mediaQueries.map(([name]) => `'@${name}'`).join(" | ");
-      const variableTokens = /* @__PURE__ */ new Set();
-      const parseVariables = async (obj, path = []) => {
-        if (!obj) return [];
-        const promises = Object.entries(obj).map(async ([key, value]) => {
-          const parseVariable = async (value2) => {
-            if (!value2) return void 0;
-            if (value2 instanceof Promise) return await parseVariable(await value2);
-            if (typeof value2 === "function") return await parseVariable(await value2());
-            if (typeof value2 === "object") return await parseVariables(value2, [...path, key]);
-            const dottedKey = dotCase(key);
-            const dashedKey = dashCase(key);
-            const tsName = [...path, dottedKey].join(".");
-            variableTokens.add(`"${tsName}"`);
-            const cssName = [...path.map(dashCase), dashedKey].join("-");
-            const result = parseVariableTokens(value2);
-            if (!result) return `--${cssName}: ${value2};`;
-            return `--${cssName}: ${result.transformed};`;
-          };
-          return await parseVariable(value);
-        });
-        const results = await Promise.all(promises);
-        return results.flat();
-      };
-      const parseResponsiveVariables = async (obj) => {
-        if (!obj) return [];
-        const promises = Object.entries(obj).map(async ([mediaQuery, values]) => {
-          const variables = await parseVariables(values);
-          if (mediaQuery === "base") return variables.join("");
-          if (configCacheContent.mediaQueries[mediaQuery]) {
-            const mediaQueryValue = configCacheContent.mediaQueries[mediaQuery];
-            return `${mediaQueryValue} { ${variables.join("")} }`;
-          }
-          return `${mediaQuery} { ${variables.join("")} }`;
-        });
-        const results = await Promise.all(promises);
-        return results.flat();
-      };
-      const parseConditionalVariables = async (obj) => {
-        if (!obj) return [];
-        const promises = Object.entries(obj).map(async ([property, conditions]) => {
-          const promises2 = Object.entries(conditions).map(async ([condition, values]) => {
-            const variables = await parseVariables(values, [property]);
-            const conditionScope = `.${property}-${condition}, [data-${property}="${condition}"]`;
-            const combined = variables.join("");
-            return `${conditionScope} { ${combined} }`;
-          });
-          const result = await Promise.all(promises2);
-          return result.flat();
-        });
-        const results = await Promise.all(promises);
-        return results.flat();
-      };
-      const getStaticVariables = (variables = {}) => {
-        return { ...variables, responsive: void 0, conditional: void 0 };
-      };
-      const getGeneratedVariables = (type) => {
-        return generationResults.variables.map((factory) => {
-          if (type === "static") return getStaticVariables(factory._current);
-          return factory._current[type];
-        });
-      };
-      const _staticVariables = mergeObjects(getStaticVariables(config.variables), getGeneratedVariables("static"));
-      const staticVariables = await parseVariables(_staticVariables);
-      const _responsiveVariables = mergeObjects((_a = config.variables) == null ? void 0 : _a.responsive, getGeneratedVariables("responsive"));
-      const responsiveVariables = await parseResponsiveVariables(_responsiveVariables);
-      const _conditionalVariables = mergeObjects((_b = config.variables) == null ? void 0 : _b.conditional, getGeneratedVariables("conditional"));
-      const conditionalVariables = await parseConditionalVariables(_conditionalVariables);
-      const variablesPath = join(destDir, "css/_variables.css");
-      const variablesCss = `:root { ${staticVariables.join("")} ${responsiveVariables.join("")} } ${conditionalVariables.join("")}`;
-      writeFileSync(variablesPath, variablesCss);
-      configCacheContent.staticVariables = _staticVariables;
-      const globalStylesPath = join(destDir, "css/_global.css");
-      const mergedGlobalStyles = mergeObjects(config.global, generationResults.globalStyles);
-      const globalStylesString = await parseAndJoinStyles(mergedGlobalStyles, "");
-      writeFileSync(globalStylesPath, `@layer global { ${globalStylesString} }`);
-      const resetStylesPath = join(destDir, "css/_reset.css");
-      const getResetStyles = () => {
-        if (config.reset === "none") return {};
-        if (typeof config.reset === "object") return config.reset;
-        return saltyReset;
-      };
-      const resetStyles = getResetStyles();
-      const resetStylesString = await parseAndJoinStyles(resetStyles, "");
-      writeFileSync(resetStylesPath, `@layer reset { ${resetStylesString} }`);
-      const templateStylesPath = join(destDir, "css/_templates.css");
-      const templates = mergeObjects(config.templates, generationResults.templates);
-      const templateStylesString = await parseTemplates(templates);
-      const templateTokens = getTemplateTypes(templates);
-      const templateVariantMaps = getTemplateVariantMaps(templates);
-      writeFileSync(templateStylesPath, `@layer templates { ${templateStylesString} }`);
-      configCacheContent.templates = templates;
-      const importsPath = join(destDir, "css/_imports.css");
-      const importRules = [];
-      for (const factory of generationResults.imports) {
-        const sourceFile = factory._path;
-        if (!sourceFile) continue;
-        for (const spec of factory._current) {
-          try {
-            const { rule } = resolveImport(spec, sourceFile, destDir);
-            importRules.push(rule);
-          } catch (e) {
-            const url = typeof spec === "string" ? spec : spec.url;
-            logger.error(`Failed to resolve defineImport(${JSON.stringify(url)}) from ${sourceFile}: ${e.message}`);
-          }
-        }
-      }
-      writeFileSync(importsPath, importRules.join("\n"));
-      const configTemplateFactories = config.templates ? [defineTemplates(config.templates)._setPath(`config;;${configPath}`)] : [];
-      const templateFactories = mergeFactories(generationResults.templates, configTemplateFactories);
-      configCacheContent.templatePaths = Object.fromEntries(Object.entries(templateFactories).map(([key, faktory]) => [key, faktory._path]));
-      const fontsStylesPath = join(destDir, "css/_fonts.css");
-      if (generationResults.fonts.length === 0) {
-        writeFileSync(fontsStylesPath, "");
-      } else {
-        const fontImports = [];
-        const fontBodies = [];
-        for (const font of generationResults.fonts) {
-          const { imports, body } = font._toCss();
-          fontImports.push(...imports);
-          fontBodies.push(body);
-        }
-        const importBlock = fontImports.length ? `${fontImports.join("\n")}
-
-` : "";
-        writeFileSync(fontsStylesPath, `${importBlock}@layer fonts { ${fontBodies.join(" ")} }`);
-      }
-      const tsTokensPath = join(destDir, "types/css-tokens.d.ts");
-      const tsVariableTokens = [...variableTokens].join("|");
-      const pascal = (str) => str.split(/[.\-_]/).filter(Boolean).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
-      const templateVariantMapEntries = Object.entries(templateVariantMaps);
-      const hasVariantMaps = templateVariantMapEntries.some(([, pathMap]) => Object.keys(pathMap).length > 0);
-      const tsTemplateVariantMap = hasVariantMaps ? `type TemplateVariantTokens = {
-        ${templateVariantMapEntries.filter(([, pathMap]) => Object.keys(pathMap).length > 0).map(([templateKey, pathMap]) => {
-        const pathEntries = Object.entries(pathMap).map(
-          ([dotPath, axes]) => `'${dotPath}': { ${Object.entries(axes).map(([axis, valueType]) => `${axis}?: ${valueType}`).join("; ")} }`
-        ).join(";\n          ");
-        return `${templateKey}: {
-          ${pathEntries}
-        }`;
-      }).join(";\n        ")}
-      }` : `type TemplateVariantTokens = Record<string, Record<string, Record<string, never>>>;`;
-      const tsTemplateVariantAliases = templateVariantMapEntries.flatMap(
-        ([templateKey, pathMap]) => Object.keys(pathMap).map((dotPath) => `type ${pascal(templateKey)}${pascal(dotPath)}Variants = TemplateVariantTokens['${templateKey}']['${dotPath}'];`)
-      ).join("\n      ");
-      const tsTokensTypes = `
-      // Variable types
-      type VariableTokens = ${tsVariableTokens || `''`};
-      type PropertyValueToken = \`{\${VariableTokens}}\`;
-
-      // Template types
-      type TemplateTokens = {
-        ${Object.entries(templateTokens).map(([key, value]) => {
-        if (!value || value === "any") return `${key}?: ${value || "any"}`;
-        return `${key}?: ${value} | \`\${${value}}@\${string}\``;
-      }).join("\n")}
-      }
-
-      // Template variant types (per docs/template-variants-spec.md §7)
-      ${tsTemplateVariantMap}
-      ${tsTemplateVariantAliases}
-
-      // Media query types
-      type MediaQueryKeys = ${mediaQueryKeys || `''`};
-      `;
-      writeFileSync(tsTokensPath, tsTokensTypes);
-      const configCachePath = join(destDir, "cache/config-cache.json");
-      writeFileSync(configCachePath, JSON.stringify(configCacheContent, null, 2));
-    });
-    __publicField(this, "compileSaltyFile", async (sourceFilePath, outputDirectory) => {
-      const hashedName = toHash(sourceFilePath);
-      const tempDir = join(outputDirectory, "./temp");
-      if (!existsSync(tempDir)) mkdirSync(tempDir);
-      const parsed = parse(sourceFilePath);
-      let currentFile = readFileSync(sourceFilePath, "utf8");
-      currentFile = this.replaceStyledTag(currentFile);
-      currentFile = this.addConfigCache(currentFile);
-      const currentFileHash = toHash(currentFile);
-      const outputFilePath = join(outputDirectory, "js", `${hashedName}-${currentFileHash}.js`);
-      const rcProject = await this.getRCProjectConfig(this.projectRootDir);
-      const coreConfigPath = join(this.projectRootDir, (rcProject == null ? void 0 : rcProject.configDir) || "", "salty.config.ts");
-      const externalModules = this.getExternalModules(coreConfigPath);
-      const moduleType = await detectCurrentModuleType(this.projectRootDir);
-      await esbuild.build({
-        stdin: {
-          contents: currentFile,
-          sourcefile: parsed.base,
-          resolveDir: parsed.dir,
-          loader: "tsx"
-        },
-        minify: false,
-        treeShaking: true,
-        bundle: true,
-        outfile: outputFilePath,
-        format: moduleType,
-        target: ["node20"],
-        keepNames: true,
-        external: externalModules,
-        packages: "external",
-        plugins: [
-          {
-            name: "test",
-            setup: (build) => {
-              build.onLoad({ filter: /.*\.css|salty|styles|styled\.ts/ }, (args) => {
-                const original = readFileSync(args.path, "utf8");
-                const modified = this.replaceStyledTag(original);
-                return { contents: modified, loader: "ts" };
-              });
-            }
-          }
-        ]
-      });
-      const contents = await this.importFile(outputFilePath);
-      return { contents, outputFilePath };
-    });
-    /**
-     * Read the framework field from the current project's entry in `.saltyrc.json`.
-     * Used by framework-aware bundler plugins to dispatch to the right transform.
-     */
-    __publicField(this, "getFramework", async () => {
-      const projectConfig = await this.getRCProjectConfig(this.projectRootDir);
-      return projectConfig == null ? void 0 : projectConfig.framework;
-    });
-    __publicField(this, "generateFile", async (file) => {
-      try {
-        const destDir = await this.getDestDir();
-        const pathFilter = await this.getPathFilter();
-        const validFile = this.isAllowedSaltyFile(file, pathFilter);
-        if (validFile) {
-          const cssFiles = [];
-          const config = await this.getConfig();
-          const { contents } = await this.compileSaltyFile(file, destDir);
-          for (const [name, value] of Object.entries(contents)) {
-            const resolved = await resolveExportValue(value, 1);
-            if (resolved.isKeyframes && resolved.css) {
-              const fileName = `a_${resolved.animationName}.css`;
-              const filePath2 = `css/${fileName}`;
-              const cssPath2 = join(destDir, filePath2);
-              writeFileSync(cssPath2, await resolved.css);
-              continue;
-            }
-            if (resolved.isClassName) {
-              const generator2 = resolved.generator._withBuildContext({
-                callerName: name,
-                isProduction: this.isProduction,
-                config
-              });
-              const styles2 = await generator2.css;
-              if (!styles2) continue;
-              if (!cssFiles[generator2.priority]) cssFiles[generator2.priority] = [];
-              cssFiles[generator2.priority].push(generator2.cssFileName);
-              const filePath2 = `css/${generator2.cssFileName}`;
-              const cssPath2 = join(destDir, filePath2);
-              writeFileSync(cssPath2, styles2);
-              continue;
-            }
-            if (!resolved.generator) continue;
-            const generator = resolved.generator._withBuildContext({
-              callerName: name,
-              isProduction: this.isProduction,
-              config
-            });
-            const styles = await generator.css;
-            if (!styles) continue;
-            const filePath = `css/${generator.cssFileName}`;
-            const cssPath = join(destDir, filePath);
-            writeFileSync(cssPath, styles);
-            if (!cssFiles[generator.priority]) cssFiles[generator.priority] = [];
-            cssFiles[generator.priority].push(generator.cssFileName);
-          }
-          if (config.importStrategy !== "component") {
-            cssFiles.forEach((val, layer) => {
-              const layerFileName = `l_${layer}.css`;
-              const layerFilePath = join(destDir, "css", layerFileName);
-              let currentLayerFileContent = readFileSync(layerFilePath, "utf8");
-              val.forEach((file2) => {
-                var _a;
-                const filepath = join(destDir, "css", file2);
-                const filepathHash = ((_a = /.*-([^-]+)-\d+.css/.exec(file2)) == null ? void 0 : _a.at(1)) || toHash(filepath, 6);
-                const found = currentLayerFileContent.includes(filepathHash);
-                if (!found) {
-                  const css = readFileSync(filepath, "utf8");
-                  const newContent = `/*start:${filepathHash}-${file2}*/
-${css}
-/*end:${filepathHash}*/
-`;
-                  currentLayerFileContent = `${currentLayerFileContent.replace(/\}$/, "")}
-${newContent}
-}`;
-                }
-              });
-              writeFileSync(layerFilePath, currentLayerFileContent);
-            });
-          } else {
-            const cssContent = cssFiles.flat().map((file2) => `@import url('./${file2}');`).join("\n");
-            const hashName = toHash(file, 6);
-            const parsedPath = parse(file);
-            const dasherized = dashCase(parsedPath.name);
-            const cssFile = join(destDir, `css/f_${dasherized}-${hashName}.css`);
-            writeFileSync(cssFile, cssContent || `/* Empty file */`);
-          }
-        }
-      } catch (e) {
-        console.error(e);
-      }
-    });
-    __publicField(this, "replaceStyledTag", (currentFile) => {
-      return currentFile.replace(/styled\(([^"'`{,]+),/g, (match, tag) => {
-        const isString = /^['"`]/.test(tag);
-        if (isString) return match;
-        const isImportedRegExp = new RegExp(`import[^;]*${tag}[,\\s{][^;]*from\\s?([^{};]+);`);
-        const isImported = isImportedRegExp.test(currentFile);
-        if (!isImported) return match;
-        const importResult = isImportedRegExp.exec(currentFile);
-        if (importResult) {
-          const importPath = importResult.at(1);
-          const isSaltyImport = saltyFileExtensions.some((ext) => importPath == null ? void 0 : importPath.includes(ext));
-          if (isSaltyImport) return match;
-        }
-        return "styled('div',";
-      });
-    });
-    this.projectRootDir = projectRootDir;
-    this.options = options;
-    if (typeof process === "undefined") {
-      throw new Error("SaltyServer can only be used in a Node.js environment.");
-    }
-  }
-  get isProduction() {
-    if (this.options.mode) return this.options.mode === "production";
-    try {
-      return process.env["NODE_ENV"] !== "development";
-    } catch {
-      return false;
-    }
-  }
-}
-export {
-  SaltyCompiler,
-  logError as a,
-  logger as l
-};