@salty-css/core 0.1.0-feat-define-font.0 → 0.1.0-feat-define-import.0

package/README.md

@@ -57,7 +57,7 @@ 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
+- [defineImport](#importing-additional-css) - pull in external CSS files (relative, public, node_modules, or URL)
 - [keyframes](#keyframes-animations) - create CSS keyframes animation that can be used and imported in any styling function
 
 ### Styling helpers & utility
@@ -320,86 +320,47 @@ Example usage:
 styled('div', { base: { textStyle: 'headline.large', card: '20px' } });
 ```
 
-## Custom fonts
+## Importing additional CSS
 
-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
+Use `defineImport` to pull in CSS that lives outside of Salty's authoring API — a reset stylesheet from npm, a Google Fonts URL, an asset in your app's `public/` folder, or a sibling `.css` file. The compiler turns each spec into an `@import` rule in the generated `saltygen/index.css`, so the imported stylesheets travel with the rest of your build.
 
 ```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',
-});
+// /styles/imports.css.ts
+import { defineImport } from '@salty-css/core/factories';
+
+export default defineImport(
+  // Relative to this file
+  './reset.css',
+  // From node_modules (bare specifier — same as Vite / native CSS @import)
+  'modern-normalize/modern-normalize.css',
+  // From node_modules (~ prefix — same resolver, webpack-style)
+  '~normalize.css/normalize.css',
+  // From your app's public/ folder (served at the host root)
+  '/fonts/inter.css',
+  // External URL
+  'https://fonts.googleapis.com/css2?family=Inter&display=swap',
+  // Object form — attach media or supports() conditions
+  { url: './print.css', media: 'print' },
+  { url: './p3.css', supports: 'color(display-p3 1 1 1)' }
+);
 ```
 
-Example usage:
+Path resolution:
 
-```tsx
-import { Inter } from './fonts.css';
-import { styled } from '@salty-css/react/styled';
+| Pattern                     | Behaviour                                                                                |
+| --------------------------- | ---------------------------------------------------------------------------------------- |
+| `http://`, `https://`, `//` | Emitted verbatim                                                                         |
+| Starts with `/`             | Public-folder URL — emitted verbatim, the browser resolves it against your host          |
+| Starts with `./` or `../`   | Resolved at build time relative to the file that called `defineImport`                   |
+| `~package/file.css`         | Stripped of the leading `~`, then resolved from `node_modules` and copied into the build |
+| `package/file.css` (bare)   | Same `node_modules` resolution as the `~` form                                           |
 
-// 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>;
+All imports are placed inside a new `imports` cascade layer that sits **before** `reset`, `global`, `templates`, and your component styles. This means your own styles always win over third-party CSS you pull in — which is what most teams expect when they drop in something like `modern-normalize`.
 
-// `Inter` stringifies to its font-family value (with fallbacks), so it can be used directly.
-export const Heading = styled('h1', {
-  base: {
-    fontFamily: `${Inter}`,
-  },
-});
+The full layer order in the generated `index.css` is:
 
-// Or reference the CSS variable explicitly.
-export const Body = styled('p', {
-  base: {
-    fontFamily: `var(${Inter.variable})`,
-  },
-});
+```css
+@layer imports, reset, global, templates, l0, l1, l2, l3, l4, l5, l6, l7, l8;
 ```
 
 ## Keyframes animations

package/{class-name-generator-B2LriwKm.js → class-name-generator-CMWY5KTJ.js}

@@ -1,7 +1,7 @@
 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 { p as parseAndJoinStyles } from "./parse-styles--vHKY6Mw.js";
+import { p as parseAndJoinStyles } from "./parse-styles-CLMTHo2H.js";
 import { d as dashCase } from "./dash-case-DblXvymC.js";
 import { t as toHash } from "./to-hash-DAN2LcHK.js";
 class StylesGenerator {

package/{class-name-generator-BIYysuhW.cjs → class-name-generator-DB5aQwC_.cjs}

@@ -2,7 +2,7 @@
 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);
-const parseStyles = require("./parse-styles-jPtMfgXH.cjs");
+const parseStyles = require("./parse-styles-C54MOrPg.cjs");
 const dashCase = require("./dash-case-DIwKaYgE.cjs");
 const toHash = require("./to-hash-C05Y906F.cjs");
 class StylesGenerator {

package/compiler/resolve-import.d.ts

@@ -0,0 +1,17 @@
+import { ImportSpec } from '../factories/define-import';
+export interface ResolveImportOptions {
+    /**
+     * Override for node_modules resolution. Receives the bare specifier (with any leading `~` already
+     * stripped) and the source file path of the salty file that called `defineImport`. Must return the
+     * absolute filesystem path of the resolved CSS file. Defaults to `createRequire(sourceFile).resolve`.
+     */
+    resolveModule?: (specifier: string, sourceFile: string) => string;
+    /**
+     * Override for copying resolved node_modules CSS into `<destDir>/imports/`. Receives the absolute
+     * source and destination paths. Defaults to `copyFileSync`.
+     */
+    copyAsset?: (from: string, to: string) => void;
+}
+export declare const resolveImport: (spec: ImportSpec, sourceFile: string, destDir: string, options?: ResolveImportOptions) => {
+    rule: string;
+};

package/compiler/salty-compiler.cjs

@@ -10,15 +10,15 @@ const promises = require("fs/promises");
 const fs = require("fs");
 const child_process = require("child_process");
 const compiler_helpers = require("./helpers.cjs");
-const dashCase = require("../dash-case-DIwKaYgE.cjs");
-const toHash = require("../to-hash-C05Y906F.cjs");
 const defineTemplates = require("../define-templates-Deq1aCbN.cjs");
-const parseStyles = require("../parse-styles-jPtMfgXH.cjs");
+const module$1 = require("module");
+const toHash = require("../to-hash-C05Y906F.cjs");
+const dashCase = require("../dash-case-DIwKaYgE.cjs");
+const parseStyles = require("../parse-styles-C54MOrPg.cjs");
 const css_merge = require("../css/merge.cjs");
 const parsers_index = require("../parsers/index.cjs");
-const compiler_getFiles = require("./get-files.cjs");
+const moduleType = require("../util/module-type");
 const console = require("console");
-var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -44,19 +44,53 @@ const logger = winston.createLogger({
 const logError = (message) => {
   logger.error(message);
 };
-const readPackageJsonModule = async (dirname) => {
-  const packageJsonContent = await compiler_getFiles.getPackageJson(dirname);
-  if (!packageJsonContent) return void 0;
-  return packageJsonContent.type;
+const EXTERNAL_URL = /^(?:[a-z][a-z0-9+.-]*:)?\/\//i;
+const normaliseSpec = (spec) => {
+  if (typeof spec === "string") return { url: spec };
+  return spec;
+};
+const ensureRelativePrefix = (path2) => {
+  if (path2.startsWith(".") || path2.startsWith("/")) return path2;
+  return `./${path2}`;
 };
-let cachedModuleType;
-const detectCurrentModuleType = async (dirname) => {
-  if (cachedModuleType) return cachedModuleType;
-  const packageJsonModule = await readPackageJsonModule(dirname);
-  if (packageJsonModule === "module") cachedModuleType = "esm";
-  else if (packageJsonModule === "commonjs") cachedModuleType = "cjs";
-  else if ((typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("compiler/salty-compiler.cjs", document.baseURI).href).endsWith(".cjs")) cachedModuleType = "cjs";
-  return cachedModuleType || "esm";
+const toPosix = (path2) => path2.split("\\").join("/");
+const defaultResolveModule = (specifier, sourceFile) => {
+  return module$1.createRequire(sourceFile).resolve(specifier);
+};
+const defaultCopyAsset = (from, to) => {
+  const dir = path.dirname(to);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.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 = path.resolve(path.dirname(sourceFile), url);
+    const fromImportsFile = path.relative(path.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.toHash(absolute, 6);
+  const fileName = `${hash}-${path.basename(absolute)}`;
+  const destPath = path.join(destDir, "imports", fileName);
+  copyAsset(absolute, destPath);
+  return { rule: buildRule(`../imports/${fileName}`, opts) };
 };
 function dotCase(str) {
   if (!str) return "";
@@ -173,7 +207,7 @@ class SaltyCompiler {
       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 detectCurrentModuleType(this.projectRootDir);
+      const moduleType$1 = await moduleType.detectCurrentModuleType(this.projectRootDir);
       const externalModules = this.getExternalModules(coreConfigPath);
       await esbuild__namespace.build({
         entryPoints: [coreConfigPath],
@@ -181,7 +215,7 @@ class SaltyCompiler {
         treeShaking: true,
         bundle: true,
         outfile: coreConfigDest,
-        format: moduleType,
+        format: moduleType$1,
         external: externalModules
       });
       const { config } = await this.importFile(coreConfigDest);
@@ -233,6 +267,7 @@ ${currentFile}`;
           fs.mkdirSync(path.join(destDir, "types"));
           fs.mkdirSync(path.join(destDir, "js"));
           fs.mkdirSync(path.join(destDir, "cache"));
+          fs.mkdirSync(path.join(destDir, "imports"));
         };
         if (clean) clearDistDir();
         const files = /* @__PURE__ */ new Set();
@@ -348,7 +383,7 @@ ${currentFile}`;
           });
         }
         const otherGlobalCssFiles = globalCssFiles.map((file) => `@import url('./css/${file}');`).join("\n");
-        const globalCssFilenames = ["_variables.css", "_reset.css", "_global.css", "_templates.css", "_fonts.css"];
+        const globalCssFilenames = ["_imports.css", "_variables.css", "_reset.css", "_global.css", "_templates.css"];
         const importsWithData = globalCssFilenames.filter((file) => {
           try {
             const data = fs.readFileSync(path.join(destDir, "css", file), "utf8");
@@ -357,9 +392,12 @@ ${currentFile}`;
             return false;
           }
         });
-        const globalImports = importsWithData.map((file) => `@import url('./css/${file}');`);
+        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 reset, global, templates, fonts, l0, l1, l2, l3, l4, l5, l6, l7, l8;
+        let cssContent = `${generatorText}@layer imports, reset, global, templates, l0, l1, l2, l3, l4, l5, l6, l7, l8;
 
 ${globalImports.join(
           "\n"
@@ -406,7 +444,7 @@ ${css}
         globalStyles: [],
         variables: [],
         templates: [],
-        fonts: []
+        imports: []
       };
       await Promise.all(
         [...configFiles].map(async (src) => {
@@ -416,7 +454,7 @@ ${css}
             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.isDefineFont) generationResults.fonts.push(value);
+            else if (value.isDefineImport) generationResults.imports.push(value._setPath(src));
           });
         })
       );
@@ -515,25 +553,25 @@ ${css}
       const templateTokens = parsers_index.getTemplateTypes(templates);
       fs.writeFileSync(templateStylesPath, `@layer templates { ${templateStylesString} }`);
       configCacheContent.templates = templates;
+      const importsPath = path.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}`);
+          }
+        }
+      }
+      fs.writeFileSync(importsPath, importRules.join("\n"));
       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 fontsStylesPath = path.join(destDir, "css/_fonts.css");
-      if (generationResults.fonts.length === 0) {
-        fs.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")}
-
-` : "";
-        fs.writeFileSync(fontsStylesPath, `${importBlock}@layer fonts { ${fontBodies.join(" ")} }`);
-      }
       const tsTokensPath = path.join(destDir, "types/css-tokens.d.ts");
       const tsVariableTokens = [...variableTokens].join("|");
       const tsTokensTypes = `
@@ -569,7 +607,7 @@ ${css}
       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 detectCurrentModuleType(this.projectRootDir);
+      const moduleType$1 = await moduleType.detectCurrentModuleType(this.projectRootDir);
       await esbuild__namespace.build({
         stdin: {
           contents: currentFile,
@@ -581,7 +619,7 @@ ${css}
         treeShaking: true,
         bundle: true,
         outfile: outputFilePath,
-        format: moduleType,
+        format: moduleType$1,
         target: ["node20"],
         keepNames: true,
         external: externalModules,

package/compiler/salty-compiler.d.ts

@@ -44,7 +44,7 @@ export declare class SaltyCompiler {
                 isGlobalDefine?: boolean;
                 isDefineVariables?: boolean;
                 isDefineTemplates?: boolean;
-                isDefineFont?: boolean;
+                isDefineImport?: boolean;
                 isKeyframes?: boolean;
                 animationName?: string;
                 css?: Promise<string>;

package/compiler/salty-compiler.js

@@ -2,19 +2,20 @@ 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 { join, parse } from "path";
+import { resolve, dirname, relative, join, basename, parse } from "path";
 import { createLogger, transports, format } from "winston";
 import { readFile } from "fs/promises";
-import { readFileSync, existsSync, mkdirSync, statSync, readdirSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, copyFileSync, readFileSync, statSync, readdirSync, writeFileSync } from "fs";
 import { execSync } from "child_process";
 import { isSaltyFile, resolveExportValue, getCorePackageRoot, saltyFileExtensions } from "./helpers.js";
-import { d as dashCase } from "../dash-case-DblXvymC.js";
-import { t as toHash } from "../to-hash-DAN2LcHK.js";
 import { d as defineTemplates } from "../define-templates-CVhhgPnd.js";
-import { p as parseAndJoinStyles, b as parseVariableTokens } from "../parse-styles--vHKY6Mw.js";
+import { createRequire } from "module";
+import { t as toHash } from "../to-hash-DAN2LcHK.js";
+import { d as dashCase } from "../dash-case-DblXvymC.js";
+import { p as parseAndJoinStyles, b as parseVariableTokens } from "../parse-styles-CLMTHo2H.js";
 import { mergeObjects, mergeFactories } from "../css/merge.js";
 import { parseTemplates, getTemplateTypes } from "../parsers/index.js";
-import { getPackageJson } from "./get-files.js";
+import { detectCurrentModuleType } from "../util/module-type";
 import console from "console";
 const logger = createLogger({
   level: "debug",
@@ -24,19 +25,53 @@ const logger = createLogger({
 const logError = (message) => {
   logger.error(message);
 };
-const readPackageJsonModule = async (dirname) => {
-  const packageJsonContent = await getPackageJson(dirname);
-  if (!packageJsonContent) return void 0;
-  return packageJsonContent.type;
+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}`;
 };
-let cachedModuleType;
-const detectCurrentModuleType = async (dirname) => {
-  if (cachedModuleType) return cachedModuleType;
-  const packageJsonModule = await readPackageJsonModule(dirname);
-  if (packageJsonModule === "module") cachedModuleType = "esm";
-  else if (packageJsonModule === "commonjs") cachedModuleType = "cjs";
-  else if (import.meta.url.endsWith(".cjs")) cachedModuleType = "cjs";
-  return cachedModuleType || "esm";
+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) };
 };
 function dotCase(str) {
   if (!str) return "";
@@ -121,10 +156,10 @@ class SaltyCompiler {
      * 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) => {
+    __publicField(this, "getRCProjectConfig", async (dirname2) => {
       var _a, _b;
-      const rcFile = await this.readRCFile(dirname);
-      const projectConfig = (_a = rcFile.projects) == null ? void 0 : _a.find((project) => dirname.endsWith(project.dir || ""));
+      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;
     });
@@ -213,6 +248,7 @@ ${currentFile}`;
           mkdirSync(join(destDir, "types"));
           mkdirSync(join(destDir, "js"));
           mkdirSync(join(destDir, "cache"));
+          mkdirSync(join(destDir, "imports"));
         };
         if (clean) clearDistDir();
         const files = /* @__PURE__ */ new Set();
@@ -328,7 +364,7 @@ ${currentFile}`;
           });
         }
         const otherGlobalCssFiles = globalCssFiles.map((file) => `@import url('./css/${file}');`).join("\n");
-        const globalCssFilenames = ["_variables.css", "_reset.css", "_global.css", "_templates.css", "_fonts.css"];
+        const globalCssFilenames = ["_imports.css", "_variables.css", "_reset.css", "_global.css", "_templates.css"];
         const importsWithData = globalCssFilenames.filter((file) => {
           try {
             const data = readFileSync(join(destDir, "css", file), "utf8");
@@ -337,9 +373,12 @@ ${currentFile}`;
             return false;
           }
         });
-        const globalImports = importsWithData.map((file) => `@import url('./css/${file}');`);
+        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 reset, global, templates, fonts, l0, l1, l2, l3, l4, l5, l6, l7, l8;
+        let cssContent = `${generatorText}@layer imports, reset, global, templates, l0, l1, l2, l3, l4, l5, l6, l7, l8;
 
 ${globalImports.join(
           "\n"
@@ -386,7 +425,7 @@ ${css}
         globalStyles: [],
         variables: [],
         templates: [],
-        fonts: []
+        imports: []
       };
       await Promise.all(
         [...configFiles].map(async (src) => {
@@ -396,7 +435,7 @@ ${css}
             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.isDefineFont) generationResults.fonts.push(value);
+            else if (value.isDefineImport) generationResults.imports.push(value._setPath(src));
           });
         })
       );
@@ -495,25 +534,25 @@ ${css}
       const templateTokens = getTemplateTypes(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 tsTokensTypes = `

package/config/index.cjs

@@ -5,11 +5,11 @@ const defineTemplates = require("../define-templates-Deq1aCbN.cjs");
 const defineConfig = (config) => {
   return config;
 };
-exports.FontFactory = factories_index.FontFactory;
 exports.GlobalStylesFactory = factories_index.GlobalStylesFactory;
+exports.ImportFactory = factories_index.ImportFactory;
 exports.VariablesFactory = factories_index.VariablesFactory;
-exports.defineFont = factories_index.defineFont;
 exports.defineGlobalStyles = factories_index.defineGlobalStyles;
+exports.defineImport = factories_index.defineImport;
 exports.defineMediaQuery = factories_index.defineMediaQuery;
 exports.defineVariables = factories_index.defineVariables;
 exports.TemplateFactory = defineTemplates.TemplateFactory;

package/config/index.js

@@ -1,17 +1,17 @@
-import { FontFactory, GlobalStylesFactory, VariablesFactory, defineFont, defineGlobalStyles, defineMediaQuery, defineVariables } from "../factories/index.js";
+import { GlobalStylesFactory, ImportFactory, VariablesFactory, defineGlobalStyles, defineImport, defineMediaQuery, defineVariables } from "../factories/index.js";
 import { T, a, d } from "../define-templates-CVhhgPnd.js";
 const defineConfig = (config) => {
   return config;
 };
 export {
-  FontFactory,
   GlobalStylesFactory,
+  ImportFactory,
   T as TemplateFactory,
   a as TemplatesFactory,
   VariablesFactory,
   defineConfig,
-  defineFont,
   defineGlobalStyles,
+  defineImport,
   defineMediaQuery,
   d as defineTemplates,
   defineVariables

package/css/dynamic-styles.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const parseStyles = require("../parse-styles-jPtMfgXH.cjs");
+const parseStyles = require("../parse-styles-C54MOrPg.cjs");
 const toHash = require("../to-hash-C05Y906F.cjs");
 const cache_resolveDynamicConfigCache = require("../cache/resolve-dynamic-config-cache.cjs");
 const getDynamicStylesClassName = (styles) => {

package/css/dynamic-styles.js

@@ -1,4 +1,4 @@
-import { a as parseStyles } from "../parse-styles--vHKY6Mw.js";
+import { a as parseStyles } from "../parse-styles-CLMTHo2H.js";
 import { t as toHash } from "../to-hash-DAN2LcHK.js";
 import { resolveDynamicConfigCache } from "../cache/resolve-dynamic-config-cache.js";
 const getDynamicStylesClassName = (styles) => {

package/css/keyframes.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const parseStyles = require("../parse-styles-jPtMfgXH.cjs");
+const parseStyles = require("../parse-styles-C54MOrPg.cjs");
 const toHash = require("../to-hash-C05Y906F.cjs");
 const keyframes = ({ animationName: _name, params: _params, appendInitialStyles, ...keyframes2 }) => {
   const modifyKeyframes = async (params = {}) => {

package/css/keyframes.js

@@ -1,4 +1,4 @@
-import { p as parseAndJoinStyles } from "../parse-styles--vHKY6Mw.js";
+import { p as parseAndJoinStyles } from "../parse-styles-CLMTHo2H.js";
 import { t as toHash } from "../to-hash-DAN2LcHK.js";
 const keyframes = ({ animationName: _name, params: _params, appendInitialStyles, ...keyframes2 }) => {
   const modifyKeyframes = async (params = {}) => {

package/factories/define-import.d.ts

@@ -0,0 +1,14 @@
+export interface ImportSpecOptions {
+    url: string;
+    media?: string;
+    supports?: string;
+}
+export type ImportSpec = string | ImportSpecOptions;
+export declare class ImportFactory {
+    _current: ImportSpec[];
+    _path?: string;
+    constructor(_current: ImportSpec[]);
+    get isDefineImport(): boolean;
+    _setPath(path: string): this;
+}
+export declare const defineImport: (...specs: ImportSpec[]) => ImportFactory;

package/factories/index.cjs

@@ -3,128 +3,8 @@ 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 dashCase = require("../dash-case-DIwKaYgE.cjs");
-const toHash = require("../to-hash-C05Y906F.cjs");
 const css_media = require("../css/media.cjs");
 const defineTemplates = require("../define-templates-Deq1aCbN.cjs");
-const FONT_FORMAT_BY_EXTENSION = {
-  woff2: "woff2",
-  woff: "woff",
-  ttf: "truetype",
-  otf: "opentype",
-  eot: "embedded-opentype",
-  svg: "svg",
-  ttc: "collection"
-};
-const detectFontFormat = (url) => {
-  const cleaned = url.split("?")[0].split("#")[0];
-  const dot = cleaned.lastIndexOf(".");
-  if (dot === -1) return void 0;
-  const ext = cleaned.slice(dot + 1).toLowerCase();
-  return FONT_FORMAT_BY_EXTENSION[ext];
-};
-const toFontSrc = (entry) => {
-  if (typeof entry === "string") return { url: entry, format: detectFontFormat(entry) };
-  return entry;
-};
-const normalizeSources = (src) => {
-  if (Array.isArray(src)) return src.map(toFontSrc);
-  return [toFontSrc(src)];
-};
-const normalizeVariable = (variable) => {
-  const trimmed = variable.trim();
-  const stripped = trimmed.replace(/^--/, "");
-  if (!stripped) throw new Error(`defineFont: invalid \`variable\` value "${variable}".`);
-  return `--${dashCase.dashCase(stripped)}`;
-};
-const deriveVariable = (options) => {
-  const hashSource = [options.name, options.fallback, "variants" in options ? options.variants : void 0, "import" in options ? options.import : void 0];
-  return `--font-${dashCase.dashCase(options.name)}-${toHash.toHash(hashSource, 6)}`;
-};
-const quoteFamily = (name) => {
-  if (/^["'].*["']$/.test(name)) return name;
-  if (/\s/.test(name)) return `"${name}"`;
-  return name;
-};
-const buildFontFamilyValue = (name, fallback) => {
-  const head = quoteFamily(name);
-  if (!fallback || fallback.length === 0) return head;
-  return [head, fallback].join(", ");
-};
-const formatSrc = (src) => {
-  const parts = [`url("${src.url}")`];
-  if (src.format) parts.push(`format("${src.format}")`);
-  if (src.tech) parts.push(`tech(${src.tech})`);
-  return parts.join(" ");
-};
-const variantToFontFace = (name, variant, defaultDisplay) => {
-  const sources = normalizeSources(variant.src);
-  if (sources.length === 0) {
-    throw new Error(`defineFont(${name}): variant must declare at least one \`src\`.`);
-  }
-  const lines = [`font-family: ${quoteFamily(name)};`, `src: ${sources.map(formatSrc).join(", ")};`, `font-display: ${variant.display ?? defaultDisplay};`];
-  if (variant.weight !== void 0) lines.push(`font-weight: ${variant.weight};`);
-  if (variant.style !== void 0) lines.push(`font-style: ${variant.style};`);
-  if (variant.stretch !== void 0) lines.push(`font-stretch: ${variant.stretch};`);
-  if (variant.unicodeRange !== void 0) lines.push(`unicode-range: ${variant.unicodeRange};`);
-  if (variant.ascentOverride !== void 0) lines.push(`ascent-override: ${variant.ascentOverride};`);
-  if (variant.descentOverride !== void 0) lines.push(`descent-override: ${variant.descentOverride};`);
-  if (variant.lineGapOverride !== void 0) lines.push(`line-gap-override: ${variant.lineGapOverride};`);
-  if (variant.sizeAdjust !== void 0) lines.push(`size-adjust: ${variant.sizeAdjust};`);
-  return `@font-face { ${lines.join(" ")} }`;
-};
-class FontFactory {
-  constructor(_options) {
-    __publicField(this, "variable");
-    __publicField(this, "fontFamily");
-    __publicField(this, "className");
-    this._options = _options;
-    if (!_options || !_options.name) {
-      throw new Error("defineFont: `name` is required.");
-    }
-    if ("variants" in _options && "import" in _options && _options.import !== void 0 && _options.variants !== void 0) {
-      throw new Error("defineFont: provide either `variants` or `import`, not both.");
-    }
-    if (!("variants" in _options && _options.variants) && !("import" in _options && _options.import)) {
-      throw new Error("defineFont: must provide either `variants` or `import`.");
-    }
-    this.variable = _options.variable ? normalizeVariable(_options.variable) : deriveVariable(_options);
-    this.fontFamily = buildFontFamilyValue(_options.name, _options.fallback);
-    this.className = `font-${dashCase.dashCase(_options.name)}`;
-  }
-  get isDefineFont() {
-    return true;
-  }
-  /** Acts as a string equal to the resolved font-family value. */
-  toString() {
-    return this.fontFamily;
-  }
-  /** Inline-style helper: spread onto a React `style` prop. */
-  get style() {
-    return {
-      fontFamily: this.fontFamily,
-      [this.variable]: this.fontFamily
-    };
-  }
-  /** Build the CSS pieces written to `_fonts.css`. */
-  _toCss() {
-    const imports = [];
-    const blocks = [];
-    if ("import" in this._options && this._options.import) {
-      imports.push(`@import url("${this._options.import}");`);
-    } else if ("variants" in this._options && this._options.variants) {
-      const display = this._options.display ?? "swap";
-      for (const variant of this._options.variants) {
-        blocks.push(variantToFontFace(this._options.name, variant, display));
-      }
-    }
-    blocks.push(`:root { ${this.variable}: ${this.fontFamily}; }`, `.${this.className} { font-family: var(${this.variable}); }`);
-    return { imports, body: blocks.join(" ") };
-  }
-}
-const defineFont = (options) => {
-  return new FontFactory(options);
-};
 class GlobalStylesFactory {
   constructor(_current) {
     this._current = _current;
@@ -136,6 +16,20 @@ class GlobalStylesFactory {
 const defineGlobalStyles = (styles) => {
   return new GlobalStylesFactory(styles);
 };
+class ImportFactory {
+  constructor(_current) {
+    __publicField(this, "_path");
+    this._current = _current;
+  }
+  get isDefineImport() {
+    return true;
+  }
+  _setPath(path) {
+    this._path = path;
+    return this;
+  }
+}
+const defineImport = (...specs) => new ImportFactory(specs);
 const defineMediaQuery = (mediaFactory) => {
   return mediaFactory(css_media.media);
 };
@@ -153,10 +47,10 @@ const defineVariables = (variables) => {
 exports.TemplateFactory = defineTemplates.TemplateFactory;
 exports.TemplatesFactory = defineTemplates.TemplatesFactory;
 exports.defineTemplates = defineTemplates.defineTemplates;
-exports.FontFactory = FontFactory;
 exports.GlobalStylesFactory = GlobalStylesFactory;
+exports.ImportFactory = ImportFactory;
 exports.VariablesFactory = VariablesFactory;
-exports.defineFont = defineFont;
 exports.defineGlobalStyles = defineGlobalStyles;
+exports.defineImport = defineImport;
 exports.defineMediaQuery = defineMediaQuery;
 exports.defineVariables = defineVariables;

package/factories/index.d.ts

@@ -1,5 +1,5 @@
-export * from './define-font';
 export * from './define-global-styles';
+export * from './define-import';
 export * from './define-media-query';
 export * from './define-variables';
 export * from './define-templates';

package/factories/index.js

@@ -1,128 +1,8 @@
 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 { d as dashCase } from "../dash-case-DblXvymC.js";
-import { t as toHash } from "../to-hash-DAN2LcHK.js";
 import { media } from "../css/media.js";
 import { T, a, d } from "../define-templates-CVhhgPnd.js";
-const FONT_FORMAT_BY_EXTENSION = {
-  woff2: "woff2",
-  woff: "woff",
-  ttf: "truetype",
-  otf: "opentype",
-  eot: "embedded-opentype",
-  svg: "svg",
-  ttc: "collection"
-};
-const detectFontFormat = (url) => {
-  const cleaned = url.split("?")[0].split("#")[0];
-  const dot = cleaned.lastIndexOf(".");
-  if (dot === -1) return void 0;
-  const ext = cleaned.slice(dot + 1).toLowerCase();
-  return FONT_FORMAT_BY_EXTENSION[ext];
-};
-const toFontSrc = (entry) => {
-  if (typeof entry === "string") return { url: entry, format: detectFontFormat(entry) };
-  return entry;
-};
-const normalizeSources = (src) => {
-  if (Array.isArray(src)) return src.map(toFontSrc);
-  return [toFontSrc(src)];
-};
-const normalizeVariable = (variable) => {
-  const trimmed = variable.trim();
-  const stripped = trimmed.replace(/^--/, "");
-  if (!stripped) throw new Error(`defineFont: invalid \`variable\` value "${variable}".`);
-  return `--${dashCase(stripped)}`;
-};
-const deriveVariable = (options) => {
-  const hashSource = [options.name, options.fallback, "variants" in options ? options.variants : void 0, "import" in options ? options.import : void 0];
-  return `--font-${dashCase(options.name)}-${toHash(hashSource, 6)}`;
-};
-const quoteFamily = (name) => {
-  if (/^["'].*["']$/.test(name)) return name;
-  if (/\s/.test(name)) return `"${name}"`;
-  return name;
-};
-const buildFontFamilyValue = (name, fallback) => {
-  const head = quoteFamily(name);
-  if (!fallback || fallback.length === 0) return head;
-  return [head, fallback].join(", ");
-};
-const formatSrc = (src) => {
-  const parts = [`url("${src.url}")`];
-  if (src.format) parts.push(`format("${src.format}")`);
-  if (src.tech) parts.push(`tech(${src.tech})`);
-  return parts.join(" ");
-};
-const variantToFontFace = (name, variant, defaultDisplay) => {
-  const sources = normalizeSources(variant.src);
-  if (sources.length === 0) {
-    throw new Error(`defineFont(${name}): variant must declare at least one \`src\`.`);
-  }
-  const lines = [`font-family: ${quoteFamily(name)};`, `src: ${sources.map(formatSrc).join(", ")};`, `font-display: ${variant.display ?? defaultDisplay};`];
-  if (variant.weight !== void 0) lines.push(`font-weight: ${variant.weight};`);
-  if (variant.style !== void 0) lines.push(`font-style: ${variant.style};`);
-  if (variant.stretch !== void 0) lines.push(`font-stretch: ${variant.stretch};`);
-  if (variant.unicodeRange !== void 0) lines.push(`unicode-range: ${variant.unicodeRange};`);
-  if (variant.ascentOverride !== void 0) lines.push(`ascent-override: ${variant.ascentOverride};`);
-  if (variant.descentOverride !== void 0) lines.push(`descent-override: ${variant.descentOverride};`);
-  if (variant.lineGapOverride !== void 0) lines.push(`line-gap-override: ${variant.lineGapOverride};`);
-  if (variant.sizeAdjust !== void 0) lines.push(`size-adjust: ${variant.sizeAdjust};`);
-  return `@font-face { ${lines.join(" ")} }`;
-};
-class FontFactory {
-  constructor(_options) {
-    __publicField(this, "variable");
-    __publicField(this, "fontFamily");
-    __publicField(this, "className");
-    this._options = _options;
-    if (!_options || !_options.name) {
-      throw new Error("defineFont: `name` is required.");
-    }
-    if ("variants" in _options && "import" in _options && _options.import !== void 0 && _options.variants !== void 0) {
-      throw new Error("defineFont: provide either `variants` or `import`, not both.");
-    }
-    if (!("variants" in _options && _options.variants) && !("import" in _options && _options.import)) {
-      throw new Error("defineFont: must provide either `variants` or `import`.");
-    }
-    this.variable = _options.variable ? normalizeVariable(_options.variable) : deriveVariable(_options);
-    this.fontFamily = buildFontFamilyValue(_options.name, _options.fallback);
-    this.className = `font-${dashCase(_options.name)}`;
-  }
-  get isDefineFont() {
-    return true;
-  }
-  /** Acts as a string equal to the resolved font-family value. */
-  toString() {
-    return this.fontFamily;
-  }
-  /** Inline-style helper: spread onto a React `style` prop. */
-  get style() {
-    return {
-      fontFamily: this.fontFamily,
-      [this.variable]: this.fontFamily
-    };
-  }
-  /** Build the CSS pieces written to `_fonts.css`. */
-  _toCss() {
-    const imports = [];
-    const blocks = [];
-    if ("import" in this._options && this._options.import) {
-      imports.push(`@import url("${this._options.import}");`);
-    } else if ("variants" in this._options && this._options.variants) {
-      const display = this._options.display ?? "swap";
-      for (const variant of this._options.variants) {
-        blocks.push(variantToFontFace(this._options.name, variant, display));
-      }
-    }
-    blocks.push(`:root { ${this.variable}: ${this.fontFamily}; }`, `.${this.className} { font-family: var(${this.variable}); }`);
-    return { imports, body: blocks.join(" ") };
-  }
-}
-const defineFont = (options) => {
-  return new FontFactory(options);
-};
 class GlobalStylesFactory {
   constructor(_current) {
     this._current = _current;
@@ -134,6 +14,20 @@ class GlobalStylesFactory {
 const defineGlobalStyles = (styles) => {
   return new GlobalStylesFactory(styles);
 };
+class ImportFactory {
+  constructor(_current) {
+    __publicField(this, "_path");
+    this._current = _current;
+  }
+  get isDefineImport() {
+    return true;
+  }
+  _setPath(path) {
+    this._path = path;
+    return this;
+  }
+}
+const defineImport = (...specs) => new ImportFactory(specs);
 const defineMediaQuery = (mediaFactory) => {
   return mediaFactory(media);
 };
@@ -149,13 +43,13 @@ const defineVariables = (variables) => {
   return new VariablesFactory(variables);
 };
 export {
-  FontFactory,
   GlobalStylesFactory,
+  ImportFactory,
   T as TemplateFactory,
   a as TemplatesFactory,
   VariablesFactory,
-  defineFont,
   defineGlobalStyles,
+  defineImport,
   defineMediaQuery,
   d as defineTemplates,
   defineVariables

package/generators/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const classNameGenerator = require("../class-name-generator-BIYysuhW.cjs");
+const classNameGenerator = require("../class-name-generator-DB5aQwC_.cjs");
 const dashCase = require("../dash-case-DIwKaYgE.cjs");
 class StyledGenerator extends classNameGenerator.StylesGenerator {
   constructor(tagName, _params) {

package/generators/index.js

@@ -1,5 +1,5 @@
-import { S as StylesGenerator } from "../class-name-generator-B2LriwKm.js";
-import { C } from "../class-name-generator-B2LriwKm.js";
+import { S as StylesGenerator } from "../class-name-generator-CMWY5KTJ.js";
+import { C } from "../class-name-generator-CMWY5KTJ.js";
 import { d as dashCase } from "../dash-case-DblXvymC.js";
 class StyledGenerator extends StylesGenerator {
   constructor(tagName, _params) {

package/instances/classname-instance.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const classNameGenerator = require("../class-name-generator-BIYysuhW.cjs");
+const classNameGenerator = require("../class-name-generator-DB5aQwC_.cjs");
 const classNameInstance = (params) => {
   const generator = new classNameGenerator.ClassNameGenerator(params);
   const createClass = (classNameStr) => {

package/instances/classname-instance.js

@@ -1,4 +1,4 @@
-import { C as ClassNameGenerator } from "../class-name-generator-B2LriwKm.js";
+import { C as ClassNameGenerator } from "../class-name-generator-CMWY5KTJ.js";
 const classNameInstance = (params) => {
   const generator = new ClassNameGenerator(params);
   const createClass = (classNameStr) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salty-css/core",
-  "version": "0.1.0-feat-define-font.0",
+  "version": "0.1.0-feat-define-import.0",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "typings": "./dist/index.d.ts",

package/{parse-styles-jPtMfgXH.cjs → parse-styles-C54MOrPg.cjs}

@@ -154,7 +154,6 @@ const parseStyles = async (styles, currentScope = "", config, omitTemplates = fa
     if (typeof value === "object") {
       if (!value) return void 0;
       if (value.isColor) return toString(value.toString());
-      if (value.isDefineFont) return toString(value.toString());
       if (_key === "defaultVariants") return void 0;
       if (_key === "variants") {
         const variantEntries = Object.entries(value);

package/{parse-styles--vHKY6Mw.js → parse-styles-CLMTHo2H.js}

@@ -153,7 +153,6 @@ const parseStyles = async (styles, currentScope = "", config, omitTemplates = fa
     if (typeof value === "object") {
       if (!value) return void 0;
       if (value.isColor) return toString(value.toString());
-      if (value.isDefineFont) return toString(value.toString());
       if (_key === "defaultVariants") return void 0;
       if (_key === "variants") {
         const variantEntries = Object.entries(value);

package/parsers/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const parseStyles = require("../parse-styles-jPtMfgXH.cjs");
+const parseStyles = require("../parse-styles-C54MOrPg.cjs");
 const dashCase = require("../dash-case-DIwKaYgE.cjs");
 const toHash = require("../to-hash-C05Y906F.cjs");
 const parseTemplates = async (obj, path = []) => {

package/parsers/index.js

@@ -1,5 +1,5 @@
-import { p as parseAndJoinStyles } from "../parse-styles--vHKY6Mw.js";
-import { a, c, d, b, r } from "../parse-styles--vHKY6Mw.js";
+import { p as parseAndJoinStyles } from "../parse-styles-CLMTHo2H.js";
+import { a, c, d, b, r } from "../parse-styles-CLMTHo2H.js";
 import { d as dashCase } from "../dash-case-DblXvymC.js";
 import { t as toHash } from "../to-hash-DAN2LcHK.js";
 const parseTemplates = async (obj, path = []) => {

package/runtime/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const parseStyles = require("../parse-styles-jPtMfgXH.cjs");
+const parseStyles = require("../parse-styles-C54MOrPg.cjs");
 const defineRuntime = (config) => {
   const getDynamicStylesCss = async (styles, scope) => {
     const parsed = await parseStyles.parseStyles(styles, scope, config);

package/runtime/index.js

@@ -1,4 +1,4 @@
-import { a as parseStyles } from "../parse-styles--vHKY6Mw.js";
+import { a as parseStyles } from "../parse-styles-CLMTHo2H.js";
 const defineRuntime = (config) => {
   const getDynamicStylesCss = async (styles, scope) => {
     const parsed = await parseStyles(styles, scope, config);

package/types/config-types.d.ts

@@ -1,6 +1,5 @@
 import { BaseStyles, CssStyles, MediaQueryStyles } from '../types';
 import { OrString } from '../types/util-types';
-export * from './font-types';
 export type GlobalStyles = Record<string, BaseStyles>;
 export type CssVariableTokensObject = Record<string, unknown>;
 export interface CssResponsiveVariables {
@@ -92,3 +91,4 @@ export interface CachedConfig {
         [key: string]: string;
     };
 }
+export {};

package/factories/define-font.d.ts

@@ -1,28 +0,0 @@
-import { DefineFontOptions } from '../types/font-types';
-export interface FontCss {
-    /** `@import url(...)` lines that must sit at the top of the stylesheet, before any `@layer`. */
-    imports: string[];
-    /** Body that goes inside the `@layer fonts { ... }` wrapper. */
-    body: string;
-}
-export declare class FontFactory {
-    readonly _options: DefineFontOptions;
-    readonly variable: string;
-    readonly fontFamily: string;
-    readonly className: string;
-    constructor(_options: DefineFontOptions);
-    get isDefineFont(): true;
-    /** Acts as a string equal to the resolved font-family value. */
-    toString(): string;
-    /** Inline-style helper: spread onto a React `style` prop. */
-    get style(): Record<string, string>;
-    /** Build the CSS pieces written to `_fonts.css`. */
-    _toCss(): FontCss;
-}
-/**
- * Define a custom font that is registered globally as `@font-face` and exposed
- * as a CSS variable. The returned object stringifies to its `font-family`
- * value, and exposes `.variable`, `.fontFamily`, `.className`, and `.style`
- * for use in styles and components.
- */
-export declare const defineFont: (options: DefineFontOptions) => FontFactory;

package/types/font-types.d.ts

@@ -1,53 +0,0 @@
-export type FontDisplay = 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
-export type FontFormat = 'woff2' | 'woff' | 'truetype' | 'opentype' | 'embedded-opentype' | 'svg' | 'collection';
-export type FontStyle = 'normal' | 'italic' | 'oblique' | (string & {});
-export type FontWeight = number | 'normal' | 'bold' | 'lighter' | 'bolder' | (string & {});
-export interface FontSrc {
-    url: string;
-    format?: FontFormat;
-    /** Optional `tech(...)` descriptor passed straight through to @font-face. */
-    tech?: string;
-}
-export interface FontVariant {
-    weight?: FontWeight;
-    style?: FontStyle;
-    stretch?: string;
-    display?: FontDisplay;
-    unicodeRange?: string;
-    ascentOverride?: string;
-    descentOverride?: string;
-    lineGapOverride?: string;
-    sizeAdjust?: string;
-    /**
-     * One or more font sources. Strings are treated as URLs and the `format()`
-     * descriptor is auto-detected from the file extension when possible. Use
-     * the `{ url, format }` object form for CDN/extensionless URLs where the
-     * format must be set explicitly.
-     */
-    src: string | FontSrc | (string | FontSrc)[];
-}
-interface DefineFontBase {
-    /** CSS `font-family` value users will see in styles. */
-    name: string;
-    /**
-     * CSS variable name. Accepts `--font-inter` or `font-inter`; we normalize.
-     * Optional — when omitted, a deterministic name is derived from the other
-     * inputs as `--font-<name>-<hash>`.
-     */
-    variable?: string;
-    /** Default `font-display` applied to variants that don't set their own. */
-    display?: FontDisplay;
-    /** Family fallback(s) appended after `name` in the generated `font-family` string. */
-    fallback?: string;
-}
-export interface DefineFontVariantsOptions extends DefineFontBase {
-    variants: FontVariant[];
-    import?: never;
-}
-export interface DefineFontImportOptions extends DefineFontBase {
-    /** Remote stylesheet URL (e.g. Google Fonts). Emitted as `@import url(...)`. */
-    import: string;
-    variants?: never;
-}
-export type DefineFontOptions = DefineFontVariantsOptions | DefineFontImportOptions;
-export {};