@salty-css/core 0.0.1-alpha.303 → 0.0.1-alpha.304

package/compiler/as-class.cjs

@@ -0,0 +1,592 @@
+"use strict";
+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);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const esbuild = require("esbuild");
+const path = require("path");
+const saltyReset = require("../salty-reset-wJhVT2ys.cjs");
+const promises = require("fs/promises");
+const fs = require("fs");
+const child_process = require("child_process");
+const compiler_helpers = require("./helpers.cjs");
+const defineTemplates = require("../define-templates-Deq1aCbN.cjs");
+const dashCase = require("../dash-case-Cz8wwE9a.cjs");
+const parseStyles = require("../parse-styles-D-p_guRO.cjs");
+const css_merge = require("../css/merge.cjs");
+const parsers_index = require("../parsers/index.cjs");
+const console = require("console");
+const compiler_getFunctionRange = require("./get-function-range.cjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const esbuild__namespace = /* @__PURE__ */ _interopNamespaceDefault(esbuild);
+class SaltyCompiler {
+  constructor(projectRootDir) {
+    __publicField(this, "importFile", (path2) => {
+      const now = Date.now();
+      return import(
+        /* @vite-ignore */
+        `${path2}?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 = path.join(currentDir, ".saltyrc.json");
+      const rcContent = await promises.readFile(rcPath, "utf-8").then(JSON.parse).catch(() => void 0);
+      if (!rcContent) return this.readRCFile(path.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 (dirname) => {
+      var _a, _b;
+      const rcFile = await this.readRCFile(dirname);
+      const projectConfig = (_a = rcFile.projects) == null ? void 0 : _a.find((project) => dirname.endsWith(project.dir || ""));
+      if (!projectConfig) return (_b = rcFile.projects) == null ? void 0 : _b.find((project) => project.dir === rcFile.defaultProject);
+      return projectConfig;
+    });
+    __publicField(this, "getExternalModules", (coreConfigPath) => {
+      if (this.cache.externalModules.length > 0) return this.cache.externalModules;
+      const content = fs.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 = path.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 = path.join(this.projectRootDir, (rcProject == null ? void 0 : rcProject.configDir) || "", "salty.config.ts");
+      const coreConfigDest = path.join(destDir, "salty.config.js");
+      const moduleType = await saltyReset.detectCurrentModuleType(this.projectRootDir);
+      const externalModules = this.getExternalModules(coreConfigPath);
+      await esbuild__namespace.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 = fs.readFileSync(path.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 = path.join(destDir, "cache/config-cache.json");
+      const contents = fs.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 = path.join(destDir, "salty.config.js");
+      const { config } = await this.importFile(coreConfigDest);
+      return css_merge.mergeObjects(config, cached);
+    });
+    /**
+     * 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) saltyReset.logger.info("Generating CSS in production mode! 🔥");
+        else saltyReset.logger.info("Generating CSS in development mode! 🚀");
+        const globalCssFiles = [];
+        const cssFiles = [];
+        const destDir = await this.getDestDir();
+        const cssFile = path.join(destDir, "index.css");
+        const clearDistDir = () => {
+          if (fs.existsSync(destDir)) child_process.execSync("rm -rf " + destDir);
+          fs.mkdirSync(destDir, { recursive: true });
+          fs.mkdirSync(path.join(destDir, "css"));
+          fs.mkdirSync(path.join(destDir, "types"));
+          fs.mkdirSync(path.join(destDir, "js"));
+          fs.mkdirSync(path.join(destDir, "cache"));
+        };
+        if (clean) clearDistDir();
+        const files = /* @__PURE__ */ new Set();
+        const configFiles = /* @__PURE__ */ new Set();
+        async function collectFiles(src) {
+          const foldersToSkip = ["node_modules", "saltygen"];
+          const stats = fs.statSync(src);
+          if (stats.isDirectory()) {
+            const files2 = fs.readdirSync(src);
+            const shouldSkip = foldersToSkip.some((folder) => src.includes(folder));
+            if (shouldSkip) return;
+            await Promise.all(files2.map((file) => collectFiles(path.join(src, file))));
+          } else if (stats.isFile()) {
+            const validFile = compiler_helpers.isSaltyFile(src);
+            if (validFile) {
+              files.add(src);
+              const contents = fs.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 compiler_helpers.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 = path.join(destDir, filePath);
+          globalCssFiles.push(fileName);
+          fs.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 = path.join(destDir, filePath);
+          fs.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 = path.join(destDir, filePath);
+          fs.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 = dashCase.toHash(src, 6);
+            const parsedPath = path.parse(src);
+            const dasherized = dashCase.dashCase(parsedPath.name);
+            const cssFile2 = path.join(destDir, `css/f_${dasherized}-${hashName}.css`);
+            fs.writeFileSync(cssFile2, cssContent2 || `/* Empty file */`);
+          });
+        }
+        const otherGlobalCssFiles = globalCssFiles.map((file) => `@import url('./css/${file}');`).join("\n");
+        const globalCssFilenames = ["_variables.css", "_reset.css", "_global.css", "_templates.css"];
+        const importsWithData = globalCssFilenames.filter((file) => {
+          try {
+            const data = fs.readFileSync(path.join(destDir, "css", file), "utf8");
+            return data.length > 0;
+          } catch {
+            return false;
+          }
+        });
+        const globalImports = importsWithData.map((file) => `@import url('./css/${file}');`);
+        const generatorText = "/*!\n * Generated with Salty CSS (https://salty-css.dev)\n * Do not edit this file directly\n */\n";
+        let cssContent = `${generatorText}@layer reset, global, templates, 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 = path.join(destDir, "css", file);
+              const css = fs.readFileSync(filepath, "utf8");
+              const filepathHash = ((_a = /.*-([^-]+)-\d+.css/.exec(file)) == null ? void 0 : _a.at(1)) || dashCase.toHash(filepath, 6);
+              if (layerAcc.includes(filepathHash)) return layerAcc;
+              return `${layerAcc}
+/*start:${filepathHash}-${file}*/
+${css}
+/*end:${filepathHash}*/
+`;
+            }, "");
+            const layerFileName = `l_${layer}.css`;
+            const layerFilePath = path.join(destDir, "css", layerFileName);
+            const layerContentWithLayer = `@layer l${layer} { ${layerContent}
+ }`;
+            fs.writeFileSync(layerFilePath, layerContentWithLayer);
+            return `${acc}
+@import url('./css/${layerFileName}');`;
+          }, "");
+          cssContent += mergedContent;
+        }
+        fs.writeFileSync(cssFile, cssContent);
+        const end = Date.now();
+        const time = end - start;
+        const emoji = time < 200 ? "🔥" : time < 500 ? "🚀" : time < 1e3 ? "🎉" : time < 2e3 ? "🚗" : time < 5e3 ? "🤔" : "🥴";
+        saltyReset.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: []
+      };
+      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}`));
+          });
+        })
+      );
+      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, path2 = []) => {
+        if (!obj) return [];
+        const promises2 = 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, [...path2, key]);
+            const dottedKey = saltyReset.dotCase(key);
+            const dashedKey = dashCase.dashCase(key);
+            const tsName = [...path2, dottedKey].join(".");
+            variableTokens.add(`"${tsName}"`);
+            const cssName = [...path2.map(dashCase.dashCase), dashedKey].join("-");
+            const result = parseStyles.parseVariableTokens(value2);
+            if (!result) return `--${cssName}: ${value2};`;
+            return `--${cssName}: ${result.transformed};`;
+          };
+          return await parseVariable(value);
+        });
+        const results = await Promise.all(promises2);
+        return results.flat();
+      };
+      const parseResponsiveVariables = async (obj) => {
+        if (!obj) return [];
+        const promises2 = 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(promises2);
+        return results.flat();
+      };
+      const parseConditionalVariables = async (obj) => {
+        if (!obj) return [];
+        const promises2 = Object.entries(obj).map(async ([property, conditions]) => {
+          const promises22 = 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(promises22);
+          return result.flat();
+        });
+        const results = await Promise.all(promises2);
+        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 = css_merge.mergeObjects(getStaticVariables(config.variables), getGeneratedVariables("static"));
+      const staticVariables = await parseVariables(_staticVariables);
+      const _responsiveVariables = css_merge.mergeObjects((_a = config.variables) == null ? void 0 : _a.responsive, getGeneratedVariables("responsive"));
+      const responsiveVariables = await parseResponsiveVariables(_responsiveVariables);
+      const _conditionalVariables = css_merge.mergeObjects((_b = config.variables) == null ? void 0 : _b.conditional, getGeneratedVariables("conditional"));
+      const conditionalVariables = await parseConditionalVariables(_conditionalVariables);
+      const variablesPath = path.join(destDir, "css/_variables.css");
+      const variablesCss = `:root { ${staticVariables.join("")} ${responsiveVariables.join("")} } ${conditionalVariables.join("")}`;
+      fs.writeFileSync(variablesPath, variablesCss);
+      configCacheContent.staticVariables = _staticVariables;
+      const globalStylesPath = path.join(destDir, "css/_global.css");
+      const mergedGlobalStyles = css_merge.mergeObjects(config.global, generationResults.globalStyles);
+      const globalStylesString = await parseStyles.parseAndJoinStyles(mergedGlobalStyles, "");
+      fs.writeFileSync(globalStylesPath, `@layer global { ${globalStylesString} }`);
+      const resetStylesPath = path.join(destDir, "css/_reset.css");
+      const getResetStyles = () => {
+        if (config.reset === "none") return {};
+        if (typeof config.reset === "object") return config.reset;
+        return saltyReset.saltyReset;
+      };
+      const resetStyles = getResetStyles();
+      const resetStylesString = await parseStyles.parseAndJoinStyles(resetStyles, "");
+      fs.writeFileSync(resetStylesPath, `@layer reset { ${resetStylesString} }`);
+      const templateStylesPath = path.join(destDir, "css/_templates.css");
+      const templates = css_merge.mergeObjects(config.templates, generationResults.templates);
+      const templateStylesString = await parsers_index.parseTemplates(templates);
+      const templateTokens = parsers_index.getTemplateTypes(templates);
+      fs.writeFileSync(templateStylesPath, `@layer templates { ${templateStylesString} }`);
+      configCacheContent.templates = templates;
+      const configTemplateFactories = config.templates ? [defineTemplates.defineTemplates(config.templates)._setPath(`config;;${configPath}`)] : [];
+      const templateFactories = css_merge.mergeFactories(generationResults.templates, configTemplateFactories);
+      configCacheContent.templatePaths = Object.fromEntries(Object.entries(templateFactories).map(([key, faktory]) => [key, faktory._path]));
+      const tsTokensPath = path.join(destDir, "types/css-tokens.d.ts");
+      const tsVariableTokens = [...variableTokens].join("|");
+      const tsTokensTypes = `
+      // Variable types
+      type VariableTokens = ${tsVariableTokens || `''`}; 
+      type PropertyValueToken = \`{\${VariableTokens}}\`;
+    
+      // Template types
+      type TemplateTokens = {
+        ${Object.entries(templateTokens).map(([key, value]) => `${key}?: ${value}`).join("\n")}
+      }
+    
+      // Media query types
+      type MediaQueryKeys = ${mediaQueryKeys || `''`};
+      `;
+      fs.writeFileSync(tsTokensPath, tsTokensTypes);
+      const configCachePath = path.join(destDir, "cache/config-cache.json");
+      fs.writeFileSync(configCachePath, JSON.stringify(configCacheContent, null, 2));
+      const corePackageRoot = compiler_helpers.getCorePackageRoot();
+      const configCacheSecondaryPath = path.join(corePackageRoot, "cache/config-cache.json");
+      fs.writeFileSync(configCacheSecondaryPath, JSON.stringify(configCacheContent, null, 2));
+    });
+    __publicField(this, "compileSaltyFile", async (sourceFilePath, outputDirectory) => {
+      const hashedName = dashCase.toHash(sourceFilePath);
+      const tempDir = path.join(outputDirectory, "./temp");
+      if (!fs.existsSync(tempDir)) fs.mkdirSync(tempDir);
+      const parsed = path.parse(sourceFilePath);
+      let currentFile = fs.readFileSync(sourceFilePath, "utf8");
+      currentFile = this.replaceStyledTag(currentFile);
+      currentFile = this.addConfigCache(currentFile);
+      const outputFilePath = path.join(outputDirectory, "js", hashedName + ".js");
+      const rcProject = await this.getRCProjectConfig(this.projectRootDir);
+      const coreConfigPath = path.join(this.projectRootDir, (rcProject == null ? void 0 : rcProject.configDir) || "", "salty.config.ts");
+      const externalModules = this.getExternalModules(coreConfigPath);
+      const moduleType = await saltyReset.detectCurrentModuleType(this.projectRootDir);
+      await esbuild__namespace.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 = fs.readFileSync(args.path, "utf8");
+                const modified = this.replaceStyledTag(original);
+                return { contents: modified, loader: "ts" };
+              });
+            }
+          }
+        ]
+      });
+      const contents = await this.importFile(outputFilePath);
+      return { contents, outputFilePath };
+    });
+    __publicField(this, "minimizeFile", async (file) => {
+      var _a, _b;
+      try {
+        const destDir = await this.getDestDir();
+        const validFile = compiler_helpers.isSaltyFile(file);
+        if (validFile) {
+          const original = fs.readFileSync(file, "utf8");
+          const config = await this.getConfig();
+          const { contents } = await this.compileSaltyFile(file, destDir);
+          let current = original;
+          for (const [name, value] of Object.entries(contents)) {
+            const resolved = await compiler_helpers.resolveExportValue(value, 1);
+            if (resolved.isKeyframes) continue;
+            if (!resolved.generator) continue;
+            const generator = resolved.generator._withBuildContext({
+              callerName: name,
+              isProduction: this.isProduction,
+              config
+            });
+            const [start, end] = await compiler_getFunctionRange.getFunctionRange(current, name);
+            const range = current.slice(start, end);
+            if (resolved.isClassName) {
+              const copy = current;
+              const clientVersion = ` ${name} = className("${generator.classNames}")`;
+              current = current.replace(range, clientVersion);
+              if (copy === current) console.error("Minimize file failed to change content", { name });
+            }
+            if (range.includes("styled")) {
+              const tagName = (_b = (_a = /styled\(([^,]+),/.exec(range)) == null ? void 0 : _a.at(1)) == null ? void 0 : _b.trim();
+              const copy = current;
+              const clientVersion = ` ${name} = styled(${tagName}, "${generator.classNames}", ${JSON.stringify(generator.clientProps)})`;
+              current = current.replace(range, clientVersion);
+              if (copy === current) console.error("Minimize file failed to change content", { name, tagName });
+            }
+          }
+          if (config.importStrategy === "component") {
+            const fileHash = dashCase.toHash(file, 6);
+            const parsed = path.parse(file);
+            const dasherized = dashCase.dashCase(parsed.name);
+            const cssFileName = `f_${dasherized}-${fileHash}.css`;
+            current = `import '../../saltygen/css/${cssFileName}';
+${current}`;
+          }
+          current = current.replace(`@salty-css/react/class-name`, `@salty-css/react/class-name-client`);
+          current = current.replace(`{ styled }`, `{ styledClient as styled }`);
+          current = current.replace(`@salty-css/react/styled`, `@salty-css/react/styled-client`);
+          return current;
+        }
+      } catch (e) {
+        console.error("Error in minimizeFile:", e);
+      }
+      return void 0;
+    });
+    __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 = compiler_helpers.saltyFileExtensions.some((ext) => importPath == null ? void 0 : importPath.includes(ext));
+          if (isSaltyImport) return match;
+        }
+        return "styled('div',";
+      });
+    });
+    this.projectRootDir = projectRootDir;
+    if (typeof process === "undefined") {
+      throw new Error("SaltyServer can only be used in a Node.js environment.");
+    }
+  }
+  get isProduction() {
+    try {
+      return process.env["NODE_ENV"] !== "development";
+    } catch {
+      return false;
+    }
+  }
+}
+exports.SaltyCompiler = SaltyCompiler;

package/compiler/as-class.d.ts

@@ -0,0 +1,35 @@
+export declare class SaltyCompiler {
+    projectRootDir: string;
+    importFile: (path: string) => Promise<any>;
+    private cache;
+    constructor(projectRootDir: string);
+    private get isProduction();
+    /**
+     * 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.
+     */
+    private readRCFile;
+    /**
+     * 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.
+     */
+    private getRCProjectConfig;
+    private getExternalModules;
+    /**
+     * Get the destination directory for generated files based on the project configuration.
+     * Caches the result to avoid redundant computations.
+     */
+    private getDestDir;
+    private generateConfig;
+    private addConfigCache;
+    private getConfigCache;
+    private getConfig;
+    /**
+     * Generate CSS files based on the Salty CSS configuration and source files.
+     */
+    generateCss: (clean?: boolean) => Promise<void>;
+    private generateConfigStyles;
+    private compileSaltyFile;
+    minimizeFile: (file: string) => Promise<string | undefined>;
+    private replaceStyledTag;
+}