@salty-css/core 0.1.0-feat-define-font.0 → 0.1.0-refactor-add-additional-paths-to-config-cache.0

package/README.md

@@ -57,7 +57,6 @@ To get help with problems, [Join Salty CSS Discord server](https://discord.gg/R6
 - [defineVariables](#variables) - create CSS variables (tokens) that can be used in any styling function
 - [defineMediaQuery](#media-queries) - create CSS media queries and use them in any styling function
 - [defineTemplates](#templates) - create reusable templates that can be applied when same styles are used over and over again
-- [defineFont](#custom-fonts) - register custom fonts via `@font-face` (or a remote stylesheet) and expose them as a CSS variable
 - [keyframes](#keyframes-animations) - create CSS keyframes animation that can be used and imported in any styling function
 
 ### Styling helpers & utility
@@ -320,88 +319,6 @@ Example usage:
 styled('div', { base: { textStyle: 'headline.large', card: '20px' } });
 ```
 
-## Custom fonts
-
-Register custom fonts that will be emitted as `@font-face` declarations and exposed as a CSS variable. Mirrors the developer experience of Next.js / Astro font loaders, but generated at build time alongside the rest of your Salty CSS output.
-
-The returned object stringifies to its `font-family` value and exposes helpers for explicit usage:
-
-- `Font.variable` → CSS variable name (e.g. `--font-inter`)
-- `Font.fontFamily` → final `font-family` string with fallbacks
-- `Font.className` → class that sets the variable + applies the font on a subtree
-- `Font.style` → object you can spread on a React `style` prop
-
-```ts
-// /styles/fonts.css.ts
-import { defineFont } from '@salty-css/core/factories';
-
-// 1. Local or self-hosted @font-face sources.
-//    URLs are passed through as-is (use a public-folder path or a CDN URL).
-export const Inter = defineFont({
-  name: 'Inter', // CSS font-family value
-  variable: '--font-inter', // Optional — accepts 'font-inter' too; if omitted we derive `--font-<name>-<hash>` from the inputs
-  display: 'swap', // Optional default applied to variants without their own `display`
-  fallback: ['system-ui', 'sans-serif'], // Optional family fallbacks appended after `name`
-  variants: [
-    {
-      weight: 400,
-      style: 'normal',
-      // Shorthand: pass a string and the `format()` descriptor is auto-detected
-      // from the file extension (woff2, woff, ttf, otf, eot, svg, ttc).
-      src: '/fonts/inter-400.woff2',
-    },
-    {
-      weight: 700,
-      style: 'normal',
-      // Multiple sources can be a string array — first entry is preferred;
-      // the browser picks the first format it supports.
-      src: ['/fonts/inter-700.woff2', '/fonts/inter-700.ttf'],
-    },
-    {
-      weight: 400,
-      style: 'italic',
-      // Use the `{ url, format }` object form when the URL has no recognisable
-      // extension (signed CDN URLs, query-only endpoints, etc.). You can also
-      // mix strings and objects in the same array.
-      src: ['/fonts/inter-400-italic.woff2', { url: 'https://cdn.example.com/inter-italic', format: 'woff' }],
-    },
-  ],
-});
-
-// 2. Remote stylesheet (Google Fonts, etc.). Emits `@import url(...)` and still
-//    registers the CSS variable so usage stays the same as the @font-face flow.
-export const InterCdn = defineFont({
-  name: 'Inter',
-  variable: '--font-inter',
-  import: 'https://fonts.googleapis.com/css2?family=Inter:wght@400;700&display=swap',
-});
-```
-
-Example usage:
-
-```tsx
-import { Inter } from './fonts.css';
-import { styled } from '@salty-css/react/styled';
-
-// Apply the font globally by attaching its className high up in the tree.
-// This sets `--font-inter` on the subtree and applies `font-family: var(--font-inter)`.
-export const App = ({ children }) => <div className={Inter.className}>{children}</div>;
-
-// `Inter` stringifies to its font-family value (with fallbacks), so it can be used directly.
-export const Heading = styled('h1', {
-  base: {
-    fontFamily: `${Inter}`,
-  },
-});
-
-// Or reference the CSS variable explicitly.
-export const Body = styled('p', {
-  base: {
-    fontFamily: `var(${Inter.variable})`,
-  },
-});
-```
-
 ## Keyframes animations
 
 ```ts

package/bin/main.cjs

@@ -9,6 +9,7 @@ const path = require("path");
 const promises = require("fs/promises");
 const child_process = require("child_process");
 const ora = require("ora");
+const logger = require("../logger-7xz0pyAz.cjs");
 const pascalCase = require("../pascal-case-By_l58S-.cjs");
 const ejs = require("ejs");
 const promises$1 = require("readline/promises");
@@ -65,9 +66,9 @@ async function formatWithPrettier(filePath) {
     const hasPrettier = hasPrettierInstalled();
     if (!hasPrettier) return;
     await execAsync(`./node_modules/.bin/prettier --write "${filePath}"`);
-    compiler_saltyCompiler.logger.info(`Formatted ${filePath} with Prettier`);
+    logger.logger.info(`Formatted ${filePath} with Prettier`);
   } catch (error) {
-    compiler_saltyCompiler.logger.error(`Error formatting ${filePath} with Prettier:`, error);
+    logger.logger.error(`Error formatting ${filePath} with Prettier:`, error);
   }
 }
 const SALTYRC_FILENAME = ".saltyrc.json";
@@ -110,8 +111,8 @@ const writeProjectToRc = async (cwd, relativeProjectPath, framework) => {
   const existing = await readRawRc(cwd);
   const { content, changed, created } = upsertProjectInRc(existing, relativeProjectPath, framework);
   if (!changed) return false;
-  if (created) compiler_saltyCompiler.logger.info("Creating file: " + path2);
-  else compiler_saltyCompiler.logger.info("Edit file: " + path2);
+  if (created) logger.logger.info("Creating file: " + path2);
+  else logger.logger.info("Edit file: " + path2);
   await promises.writeFile(path2, content);
   await formatWithPrettier(path2);
   return true;
@@ -148,18 +149,18 @@ const buildContext = async (opts) => {
 };
 const registerBuildCommand = (program, defaultProject) => {
   program.command("build [directory]").alias("b").description("Build the Salty-CSS project.").option("-d, --dir <dir>", "Project directory to build the project in.").option("--watch", "Watch for changes and rebuild the project.").option("--mode <mode>", 'Build mode: "production" or "development". Defaults to NODE_ENV-based detection.').action(async function(_dir = defaultProject) {
-    compiler_saltyCompiler.logger.info("Building the Salty-CSS project...");
+    logger.logger.info("Building the Salty-CSS project...");
     const { dir = _dir, watch, mode } = this.opts();
     if (mode !== void 0 && mode !== "production" && mode !== "development") {
-      return compiler_saltyCompiler.logError(`Invalid --mode "${mode}". Expected "production" or "development".`);
+      return logger.logError(`Invalid --mode "${mode}". Expected "production" or "development".`);
     }
     const resolved = dir ?? await getDefaultProject();
-    if (!resolved) return compiler_saltyCompiler.logError("Project directory must be provided. Add it as the first argument after build command or use the --dir option.");
+    if (!resolved) return logger.logError("Project directory must be provided. Add it as the first argument after build command or use the --dir option.");
     const projectDir = resolveProjectDir(resolved);
     const compiler = new compiler_saltyCompiler.SaltyCompiler(projectDir, { mode });
     await compiler.generateCss();
     if (watch) {
-      compiler_saltyCompiler.logger.info("Watching for changes in the project directory...");
+      logger.logger.info("Watching for changes in the project directory...");
       fs.watch(projectDir, { recursive: true }, async (_event, filePath) => {
         const shouldRestart$1 = await shouldRestart.checkShouldRestart(filePath);
         if (shouldRestart$1) {
@@ -245,13 +246,13 @@ const readTemplate = async (key, options) => {
 const registerGenerateCommand = (program, defaultProject) => {
   program.command("generate [file] [directory]").alias("g").description("Generate a new component file.").option("-f, --file <file>", "File to generate.").option("-d, --dir <dir>", "Project directory to generate the file in.").option("-t, --tag <tag>", "HTML tag of the component.", "div").option("-n, --name <name>", "Name of the component.").option("-c, --className <className>", "CSS class of the component.").option("-r, --reactComponent", "Generate a wrapper component file alongside the styled definition.").action(async function(_file, _dir = defaultProject) {
     const { file = _file, dir = _dir, tag, name, className, reactComponent = false } = this.opts();
-    if (!file) return compiler_saltyCompiler.logError("File to generate must be provided. Add it as the first argument after generate command or use the --file option.");
-    if (!dir) return compiler_saltyCompiler.logError("Project directory must be provided. Add it as the second argument after generate command or use the --dir option.");
+    if (!file) return logger.logError("File to generate must be provided. Add it as the first argument after generate command or use the --file option.");
+    if (!dir) return logger.logError("Project directory must be provided. Add it as the second argument after generate command or use the --dir option.");
     let ctx;
     try {
       ctx = await buildContext({ dir, requirePackageJson: false });
     } catch (err) {
-      return compiler_saltyCompiler.logError(err instanceof Error ? err.message : String(err));
+      return logger.logError(err instanceof Error ? err.message : String(err));
     }
     const rcFramework = getFramework(getProjectFramework(ctx.rcFile, ctx.relativeProjectPath));
     const framework = rcFramework ?? await detectFramework(ctx);
@@ -265,13 +266,13 @@ const registerGenerateCommand = (program, defaultProject) => {
     const formattedStyledFilePath = path.format(parsedFilePath);
     const alreadyExists = await promises.readFile(formattedStyledFilePath, "utf-8").catch(() => void 0);
     if (alreadyExists !== void 0) {
-      compiler_saltyCompiler.logger.error("File already exists: " + formattedStyledFilePath);
+      logger.logger.error("File already exists: " + formattedStyledFilePath);
       return;
     }
     let styledComponentName = pascalCase.pascalCase(name || parsedFilePath.base.replace(/\.css\.\w+$/, ""));
     if (reactComponent) {
       if (!framework.templates.component) {
-        return compiler_saltyCompiler.logError(`--reactComponent is not supported for the ${framework.name} framework.`);
+        return logger.logError(`--reactComponent is not supported for the ${framework.name} framework.`);
       }
       const componentName = styledComponentName + "Component";
       styledComponentName = styledComponentName + "Wrapper";
@@ -287,13 +288,13 @@ const registerGenerateCommand = (program, defaultProject) => {
       parsedFilePath.ext = framework.templates.component.wrapperExt;
       parsedFilePath.base = parsedFilePath.name + parsedFilePath.ext;
       const formattedWrapperPath = path.format(parsedFilePath);
-      compiler_saltyCompiler.logger.info("Generating a new file: " + formattedWrapperPath);
+      logger.logger.info("Generating a new file: " + formattedWrapperPath);
       await promises.writeFile(formattedWrapperPath, wrapperContent);
       await formatWithPrettier(formattedWrapperPath);
     }
     const styledKey = reactComponent && framework.templates.component ? framework.templates.component.styled : framework.templates.styled;
     const { content } = await readTemplate(styledKey, { tag, name: styledComponentName, className });
-    compiler_saltyCompiler.logger.info("Generating a new file: " + formattedStyledFilePath);
+    logger.logger.info("Generating a new file: " + formattedStyledFilePath);
     await promises.writeFile(formattedStyledFilePath, content);
     await formatWithPrettier(formattedStyledFilePath);
   });
@@ -394,13 +395,13 @@ const astroIntegration = {
     const existing = await promises.readFile(configPath, "utf-8").catch(() => void 0);
     if (existing === void 0) return null;
     const result = editAstroConfig(existing);
-    if (result.warning) compiler_saltyCompiler.logger.warn(result.warning);
+    if (result.warning) logger.logger.warn(result.warning);
     if (result.content === null) return null;
     const newContent = result.content;
     return {
       packages: [`-D ${astroPackage(ctx.cliVersion)}`],
       execute: async () => {
-        compiler_saltyCompiler.logger.info("Adding Salty-CSS integration to Astro config: " + configPath);
+        logger.logger.info("Adding Salty-CSS integration to Astro config: " + configPath);
         await promises.writeFile(configPath, newContent);
         await formatWithPrettier(configPath);
         return { changed: true };
@@ -467,17 +468,17 @@ const eslintIntegration = {
   plan: async (ctx, configPath) => {
     const existing = await promises.readFile(configPath, "utf-8").catch(() => void 0);
     if (existing === void 0) {
-      compiler_saltyCompiler.logger.error("Could not read ESLint config file.");
+      logger.logger.error("Could not read ESLint config file.");
       return null;
     }
     const result = editEslintConfig(existing, configPath.endsWith("js"));
-    if (result.warning) compiler_saltyCompiler.logger.warn(result.warning);
+    if (result.warning) logger.logger.warn(result.warning);
     if (result.content === null) return null;
     const newContent = result.content;
     return {
       packages: [corePackages.eslintConfigCore(ctx.cliVersion)],
       execute: async () => {
-        compiler_saltyCompiler.logger.info("Edit file: " + configPath);
+        logger.logger.info("Edit file: " + configPath);
         await promises.writeFile(configPath, newContent);
         await formatWithPrettier(configPath);
         return { changed: true };
@@ -520,7 +521,7 @@ const nextIntegration = {
     return {
       packages: [`-D ${nextPackage(ctx.cliVersion)}`],
       execute: async () => {
-        compiler_saltyCompiler.logger.info("Adding Salty-CSS plugin to Next.js config...");
+        logger.logger.info("Adding Salty-CSS plugin to Next.js config...");
         await promises.writeFile(configPath, content);
         await formatWithPrettier(configPath);
         return { changed: true };
@@ -551,8 +552,8 @@ const viteIntegration = {
     return {
       packages: [`-D ${vitePackage(ctx.cliVersion)}`],
       execute: async () => {
-        compiler_saltyCompiler.logger.info("Edit file: " + configPath);
-        compiler_saltyCompiler.logger.info("Adding Salty-CSS plugin to Vite config...");
+        logger.logger.info("Edit file: " + configPath);
+        logger.logger.info("Adding Salty-CSS plugin to Vite config...");
         await promises.writeFile(configPath, content);
         await formatWithPrettier(configPath);
         return { changed: true };
@@ -583,12 +584,12 @@ const applyIntegrationPlans = async (planned) => {
 const writeProjectFile = async (projectDir, fileName, content) => {
   const filePath = path.join(projectDir, fileName);
   if (fs.existsSync(filePath)) {
-    compiler_saltyCompiler.logger.debug("File already exists: " + filePath);
+    logger.logger.debug("File already exists: " + filePath);
     return;
   }
   const additionalFolders = fileName.split("/").slice(0, -1).join("/");
   if (additionalFolders) await promises.mkdir(path.join(projectDir, additionalFolders), { recursive: true });
-  compiler_saltyCompiler.logger.info("Creating file: " + filePath);
+  logger.logger.info("Creating file: " + filePath);
   await promises.writeFile(filePath, content);
   await formatWithPrettier(filePath);
 };
@@ -597,13 +598,13 @@ const ensureGitignoreSaltygen = async (rootDir) => {
   const existing = await promises.readFile(path$1, "utf-8").catch(() => void 0);
   if (existing === void 0) return;
   if (existing.includes("saltygen")) return;
-  compiler_saltyCompiler.logger.info("Edit file: " + path$1);
+  logger.logger.info("Edit file: " + path$1);
   await promises.writeFile(path$1, existing + "\n\n# Salty-CSS\nsaltygen\n");
 };
 const importSaltygenIntoCss = async (projectDir, explicitCssFile) => {
   const target = explicitCssFile ?? await findGlobalCssFile(projectDir);
   if (!target) {
-    compiler_saltyCompiler.logger.warn("Could not find a CSS file to import the generated CSS. Please add it manually.");
+    logger.logger.warn("Could not find a CSS file to import the generated CSS. Please add it manually.");
     return;
   }
   const cssFilePath = path.join(projectDir, target);
@@ -612,14 +613,14 @@ const importSaltygenIntoCss = async (projectDir, explicitCssFile) => {
   if (cssFileContent.includes("saltygen")) return;
   const cssFileFolder = path.join(cssFilePath, "..");
   const relPath = path.relative(cssFileFolder, path.join(projectDir, "saltygen/index.css"));
-  compiler_saltyCompiler.logger.info("Adding global import statement to CSS file: " + cssFilePath);
+  logger.logger.info("Adding global import statement to CSS file: " + cssFilePath);
   await promises.writeFile(cssFilePath, `@import '${relPath}';
 ` + cssFileContent);
   await formatWithPrettier(cssFilePath);
 };
 const wirePrepareScript = async () => {
   const pkg = await readPackageJson().catch(() => {
-    compiler_saltyCompiler.logError("Could not read package.json file.");
+    logger.logError("Could not read package.json file.");
     return void 0;
   });
   if (!pkg) return;
@@ -631,11 +632,11 @@ const registerInitCommand = (program) => {
     try {
       const opts = this.opts();
       const dir = opts.dir ?? _dir;
-      if (!dir) return compiler_saltyCompiler.logError("Project directory must be provided. Add it as the first argument after init command or use the --dir option.");
+      if (!dir) return logger.logError("Project directory must be provided. Add it as the first argument after init command or use the --dir option.");
       const ctx = await buildContext({ dir, skipInstall: opts.skipInstall, yes: opts.yes });
-      compiler_saltyCompiler.logger.info("Initializing a new Salty-CSS project!");
+      logger.logger.info("Initializing a new Salty-CSS project!");
       const framework = await detectFramework(ctx);
-      compiler_saltyCompiler.logger.info(`Detected framework: ${framework.name}`);
+      logger.logger.info(`Detected framework: ${framework.name}`);
       const plannedIntegrations = await planIntegrations(ctx);
       if (!ctx.skipInstall) {
         const packages = [
@@ -654,29 +655,29 @@ const registerInitCommand = (program) => {
       await importSaltygenIntoCss(ctx.projectDir, opts.cssFile);
       await applyIntegrationPlans(plannedIntegrations);
       await wirePrepareScript();
-      compiler_saltyCompiler.logger.info("Running the build to generate initial CSS...");
+      logger.logger.info("Running the build to generate initial CSS...");
       const compiler = new compiler_saltyCompiler.SaltyCompiler(ctx.projectDir);
       await compiler.generateCss();
-      compiler_saltyCompiler.logger.info("🎉 Salty CSS project initialized successfully!");
-      compiler_saltyCompiler.logger.info("Next steps:");
-      compiler_saltyCompiler.logger.info("1. Configure variables and templates in `salty.config.ts`");
-      compiler_saltyCompiler.logger.info("2. Create a new component with `npx salty-css generate [component-name]`");
-      compiler_saltyCompiler.logger.info("3. Run `npx salty-css build` to generate the CSS");
-      compiler_saltyCompiler.logger.info("4. Read about the features in the documentation: https://salty-css.dev");
-      compiler_saltyCompiler.logger.info("5. Star the project on GitHub: https://github.com/margarita-form/salty-css ⭐");
+      logger.logger.info("🎉 Salty CSS project initialized successfully!");
+      logger.logger.info("Next steps:");
+      logger.logger.info("1. Configure variables and templates in `salty.config.ts`");
+      logger.logger.info("2. Create a new component with `npx salty-css generate [component-name]`");
+      logger.logger.info("3. Run `npx salty-css build` to generate the CSS");
+      logger.logger.info("4. Read about the features in the documentation: https://salty-css.dev");
+      logger.logger.info("5. Star the project on GitHub: https://github.com/margarita-form/salty-css ⭐");
     } catch (err) {
-      return compiler_saltyCompiler.logError(err instanceof Error ? err.message : String(err));
+      return logger.logError(err instanceof Error ? err.message : String(err));
     }
   });
 };
 const getSaltyCssPackages = async () => {
   const packageJSONPath = path.join(process.cwd(), "package.json");
-  const packageJson = await readPackageJson(packageJSONPath).catch((err) => compiler_saltyCompiler.logError(err));
-  if (!packageJson) return compiler_saltyCompiler.logError("Could not read package.json file.");
+  const packageJson = await readPackageJson(packageJSONPath).catch((err) => logger.logError(err));
+  if (!packageJson) return logger.logError("Could not read package.json file.");
   const allDependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
   const saltyCssPackages = Object.entries(allDependencies).filter(([name]) => name === "salty-css" || name.startsWith("@salty-css/"));
   if (!saltyCssPackages.length) {
-    return compiler_saltyCompiler.logError(
+    return logger.logError(
       "No Salty-CSS packages found in package.json. Make sure you are running update command in the same directory! Used package.json path: " + packageJSONPath
     );
   }
@@ -686,7 +687,7 @@ const registerUpdateCommand = (program) => {
   program.command("update [version]").alias("up").description("Update Salty-CSS packages to the latest or specified version.").option("-v, --version <version>", "Version to update to.").option("--legacy-peer-deps <legacyPeerDeps>", "Use legacy peer dependencies (not recommended).", false).option("-y, --yes", "Skip confirmation prompts (install and rebuild).").option("-d, --dir <dir>", "Project directory to rebuild after updating.").action(async function(_version = "latest") {
     const { legacyPeerDeps, version = _version, yes = false, dir } = this.opts();
     const saltyCssPackages = await getSaltyCssPackages();
-    if (!saltyCssPackages) return compiler_saltyCompiler.logError("Could not update Salty-CSS packages as any were found in package.json.");
+    if (!saltyCssPackages) return logger.logError("Could not update Salty-CSS packages as any were found in package.json.");
     const cli = await readThisPackageJson();
     const packagesToUpdate = saltyCssPackages.map(([name]) => {
       if (version === "@") return `${name}@${cli.version}`;
@@ -695,16 +696,16 @@ const registerUpdateCommand = (program) => {
     try {
       await confirmInstall(packagesToUpdate, yes);
     } catch (err) {
-      return compiler_saltyCompiler.logError(err instanceof Error ? err.message : String(err));
+      return logger.logError(err instanceof Error ? err.message : String(err));
     }
     if (legacyPeerDeps) {
-      compiler_saltyCompiler.logger.warn("Using legacy peer dependencies to update packages.");
+      logger.logger.warn("Using legacy peer dependencies to update packages.");
       await npmInstall(...packagesToUpdate, "--legacy-peer-deps");
     } else {
       await npmInstall(...packagesToUpdate);
     }
     const updatedPackages = await getSaltyCssPackages();
-    if (!updatedPackages) return compiler_saltyCompiler.logError("Something went wrong while reading the updated packages.");
+    if (!updatedPackages) return logger.logError("Something went wrong while reading the updated packages.");
     const mappedByVersions = updatedPackages.reduce((acc, [name, version2]) => {
       if (!acc[version2]) acc[version2] = [];
       acc[version2].push(name);
@@ -713,41 +714,41 @@ const registerUpdateCommand = (program) => {
     const versionsCount = Object.keys(mappedByVersions).length;
     if (versionsCount === 1) {
       const v = Object.keys(mappedByVersions)[0];
-      compiler_saltyCompiler.logger.info(`Updated to all Salty CSS packages successfully to ${v.replace(/^\^/, "")}`);
+      logger.logger.info(`Updated to all Salty CSS packages successfully to ${v.replace(/^\^/, "")}`);
     } else {
       for (const [v, names] of Object.entries(mappedByVersions)) {
-        compiler_saltyCompiler.logger.info(`Updated to ${v.replace(/^\^/, "")}: ${names.join(", ")}`);
+        logger.logger.info(`Updated to ${v.replace(/^\^/, "")}: ${names.join(", ")}`);
       }
     }
     const project = dir ?? await getDefaultProject();
     if (!project) {
-      compiler_saltyCompiler.logger.warn("Skipping rebuild: no project directory configured. Run `salty-css build [dir]` manually.");
+      logger.logger.warn("Skipping rebuild: no project directory configured. Run `salty-css build [dir]` manually.");
       return;
     }
     const shouldRebuild = await confirmYesNo("Rebuild Salty CSS now?", { yes });
     if (!shouldRebuild) return;
     const projectDir = resolveProjectDir(project);
-    compiler_saltyCompiler.logger.info("Rebuilding Salty-CSS project...");
+    logger.logger.info("Rebuilding Salty-CSS project...");
     await new compiler_saltyCompiler.SaltyCompiler(projectDir).generateCss();
-    compiler_saltyCompiler.logger.info("Rebuild complete.");
+    logger.logger.info("Rebuild complete.");
   });
 };
 const registerVersionOption = (program) => {
   program.option("-v, --version", "Show the current version of Salty-CSS.").action(async function() {
     const cli = await readThisPackageJson();
-    compiler_saltyCompiler.logger.info("CLI is running: " + cli.version);
+    logger.logger.info("CLI is running: " + cli.version);
     const packageJSONPath = path.join(process.cwd(), "package.json");
-    const packageJson = await readPackageJson(packageJSONPath).catch((err) => compiler_saltyCompiler.logError(err));
+    const packageJson = await readPackageJson(packageJSONPath).catch((err) => logger.logError(err));
     if (!packageJson) return;
     const allDependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
     const saltyCssPackages = Object.keys(allDependencies).filter((dep) => dep === "salty-css" || dep.startsWith("@salty-css/"));
     if (!saltyCssPackages.length) {
-      return compiler_saltyCompiler.logError(
+      return logger.logError(
         "No Salty-CSS packages found in package.json. Make sure you are running update command in the same directory! Used package.json path: " + packageJSONPath
       );
     }
     for (const dep of saltyCssPackages) {
-      compiler_saltyCompiler.logger.info(`${dep}: ${allDependencies[dep]}`);
+      logger.logger.info(`${dep}: ${allDependencies[dep]}`);
     }
   });
 };

package/bin/main.js

@@ -1,12 +1,13 @@
 import { Command } from "commander";
 import { existsSync, watch } from "fs";
-import { l as logger, a as logError, SaltyCompiler } from "../compiler/salty-compiler.js";
+import { SaltyCompiler } from "../compiler/salty-compiler.js";
 import { isSaltyFile } from "../compiler/helpers.js";
 import { c as checkShouldRestart } from "../should-restart-CXIO0jxY.js";
 import { join, relative, parse, format } from "path";
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { exec } from "child_process";
 import ora from "ora";
+import { l as logger, a as logError } from "../logger-hHmCwThj.js";
 import { p as pascalCase } from "../pascal-case-F3Usi5Wf.js";
 import ejs from "ejs";
 import { createInterface } from "readline/promises";

package/cache/resolve-dynamic-config-cache.cjs

@@ -2,23 +2,71 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const promises = require("fs/promises");
 const path = require("path");
-const resolveDynamicConfigCache = async () => {
-  const currentDir = process.cwd();
-  const filename = "config-cache.json";
-  const patterns = ["", "saltygen", "src", "src/saltygen", "cache", "src/cache", "saltygen/cache", "src/saltygen/cache"];
-  let contents = "";
-  for (const pattern of patterns) {
-    const potentialPath = path.join(currentDir, pattern, filename);
-    try {
-      contents = await promises.readFile(potentialPath, "utf8");
-      break;
-    } catch {
-    }
+const CACHE_FILENAME = "config-cache.json";
+const ENV_VAR = "SALTY_CONFIG_CACHE_PATH";
+const defaultPatterns = [
+  "",
+  "saltygen",
+  "src",
+  "src/saltygen",
+  "cache",
+  "src/cache",
+  "saltygen/cache",
+  "src/saltygen/cache",
+  "dist",
+  "dist/cache",
+  "dist/saltygen/cache",
+  "build",
+  "build/cache",
+  "build/saltygen/cache",
+  "public/saltygen/cache",
+  ".next",
+  ".next/server",
+  ".next/server/cache",
+  ".vercel/output/functions"
+];
+const memo = /* @__PURE__ */ new Map();
+let warned = false;
+const toAbsolute = (p, cwd) => path.isAbsolute(p) ? p : path.join(cwd, p);
+const candidatePathsFrom = (entry, cwd) => {
+  const abs = toAbsolute(entry, cwd);
+  if (abs.endsWith(".json")) return [abs];
+  return [path.join(abs, CACHE_FILENAME), path.join(abs, "cache", CACHE_FILENAME), path.join(abs, "saltygen", "cache", CACHE_FILENAME)];
+};
+const tryRead = async (path2) => {
+  if (memo.has(path2)) return memo.get(path2);
+  try {
+    const contents = await promises.readFile(path2, "utf8");
+    if (!contents) return void 0;
+    const parsed = JSON.parse(contents);
+    memo.set(path2, parsed);
+    return parsed;
+  } catch {
+    return void 0;
+  }
+};
+const resolveDynamicConfigCache = async (options = {}) => {
+  var _a;
+  const cwd = options.cwd ?? process.cwd();
+  const envPath = typeof process !== "undefined" ? (_a = process.env) == null ? void 0 : _a[ENV_VAR] : void 0;
+  const ordered = [];
+  if (options.primaryPath) ordered.push(...candidatePathsFrom(options.primaryPath, cwd));
+  if (envPath) ordered.push(...candidatePathsFrom(envPath, cwd));
+  if (options.extraPaths) for (const p of options.extraPaths) ordered.push(...candidatePathsFrom(p, cwd));
+  for (const pattern of defaultPatterns) ordered.push(path.join(cwd, pattern, CACHE_FILENAME));
+  for (const candidate of ordered) {
+    const result = await tryRead(candidate);
+    if (result) return result;
   }
-  if (!contents) {
-    console.warn(`Could not find config cache file (${filename}) in any of the expected locations.`);
-    return {};
+  if (!warned) {
+    warned = true;
+    console.warn(`Could not find config cache file (${CACHE_FILENAME}) in any of the expected locations.`);
   }
-  return JSON.parse(contents);
+  return {};
+};
+const _resetDynamicConfigCacheMemo = () => {
+  memo.clear();
+  warned = false;
 };
+exports._resetDynamicConfigCacheMemo = _resetDynamicConfigCacheMemo;
 exports.resolveDynamicConfigCache = resolveDynamicConfigCache;

package/cache/resolve-dynamic-config-cache.d.ts

@@ -1 +1,20 @@
-export declare const resolveDynamicConfigCache: () => Promise<any>;
+export interface ResolveDynamicConfigCacheOptions {
+    /**
+     * Highest-priority path checked first. If it resolves, no other paths are tried.
+     * Absolute, or relative to `cwd`.
+     */
+    primaryPath?: string;
+    /**
+     * Extra paths checked before the built-in defaults. Absolute, or relative to `cwd`.
+     */
+    extraPaths?: string[];
+    /**
+     * Base directory for resolving relative paths. Defaults to `process.cwd()`.
+     */
+    cwd?: string;
+}
+export declare const resolveDynamicConfigCache: (options?: ResolveDynamicConfigCacheOptions) => Promise<Record<string, unknown>>;
+/**
+ * Clear the in-memory cache of parsed config-cache.json files. Test-only.
+ */
+export declare const _resetDynamicConfigCacheMemo: () => void;