@salty-css/core 0.1.0-alpha.3 → 0.1.0-alpha.30

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 defineTemplates } from "../define-templates-CVhhgPnd.js";
 import { d as dashCase } from "../dash-case-DblXvymC.js";
 import { t as toHash } from "../to-hash-DAN2LcHK.js";
-import { p as parseAndJoinStyles, b as parseVariableTokens } from "../parse-styles-BTIoYnBr.js";
+import { d as defineTemplates } from "../define-templates-CVhhgPnd.js";
+import { createRequire } from "module";
+import { p as parseAndJoinStyles, c as parseVariableTokens } from "../parse-styles-BBJ3PWyV.js";
 import { mergeObjects, mergeFactories } from "../css/merge.js";
-import { getPackageJson } from "./get-files.js";
-import { parseTemplates, getTemplateTypes } from "../parsers/index.js";
+import { parseTemplates, getTemplateTypes, getTemplateVariantMaps } from "../parsers/index.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}`;
+};
+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);
 };
-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 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 "";
@@ -91,7 +126,7 @@ const saltyReset = {
   }
 };
 class SaltyCompiler {
-  constructor(projectRootDir) {
+  constructor(projectRootDir, options = {}) {
     __publicField(this, "importFile", (path) => {
       const now = Date.now();
       return import(
@@ -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"];
+        const globalCssFilenames = ["_imports.css", "_variables.css", "_reset.css", "_global.css", "_templates.css", "_fonts.css"];
         const importsWithData = globalCssFilenames.filter((file) => {
           try {
             const data = readFileSync(join(destDir, "css", file), "utf8");
@@ -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, l0, l1, l2, l3, l4, l5, l6, l7, l8;
+        let cssContent = `${generatorText}@layer imports, reset, global, templates, fonts, l0, l1, l2, l3, l4, l5, l6, l7, l8;
 
 ${globalImports.join(
           "\n"
@@ -385,7 +424,9 @@ ${css}
         mediaQueries: [],
         globalStyles: [],
         variables: [],
-        templates: []
+        templates: [],
+        imports: [],
+        fonts: []
       };
       await Promise.all(
         [...configFiles].map(async (src) => {
@@ -395,6 +436,8 @@ ${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.isDefineImport) generationResults.imports.push(value._setPath(src));
+            else if (value.isDefineFont) generationResults.fonts.push(value);
           });
         })
       );
@@ -491,23 +534,79 @@ ${css}
       const templates = mergeObjects(config.templates, generationResults.templates);
       const templateStylesString = await parseTemplates(templates);
       const templateTokens = getTemplateTypes(templates);
+      const templateVariantMaps = getTemplateVariantMaps(templates);
       writeFileSync(templateStylesPath, `@layer templates { ${templateStylesString} }`);
       configCacheContent.templates = templates;
+      const importsPath = join(destDir, "css/_imports.css");
+      const importRules = [];
+      for (const factory of generationResults.imports) {
+        const sourceFile = factory._path;
+        if (!sourceFile) continue;
+        for (const spec of factory._current) {
+          try {
+            const { rule } = resolveImport(spec, sourceFile, destDir);
+            importRules.push(rule);
+          } catch (e) {
+            const url = typeof spec === "string" ? spec : spec.url;
+            logger.error(`Failed to resolve defineImport(${JSON.stringify(url)}) from ${sourceFile}: ${e.message}`);
+          }
+        }
+      }
+      writeFileSync(importsPath, importRules.join("\n"));
       const configTemplateFactories = config.templates ? [defineTemplates(config.templates)._setPath(`config;;${configPath}`)] : [];
       const templateFactories = mergeFactories(generationResults.templates, configTemplateFactories);
       configCacheContent.templatePaths = Object.fromEntries(Object.entries(templateFactories).map(([key, faktory]) => [key, faktory._path]));
+      const fontsStylesPath = join(destDir, "css/_fonts.css");
+      if (generationResults.fonts.length === 0) {
+        writeFileSync(fontsStylesPath, "");
+      } else {
+        const fontImports = [];
+        const fontBodies = [];
+        for (const font of generationResults.fonts) {
+          const { imports, body } = font._toCss();
+          fontImports.push(...imports);
+          fontBodies.push(body);
+        }
+        const importBlock = fontImports.length ? `${fontImports.join("\n")}
+
+` : "";
+        writeFileSync(fontsStylesPath, `${importBlock}@layer fonts { ${fontBodies.join(" ")} }`);
+      }
       const tsTokensPath = join(destDir, "types/css-tokens.d.ts");
       const tsVariableTokens = [...variableTokens].join("|");
+      const pascal = (str) => str.split(/[.\-_]/).filter(Boolean).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+      const templateVariantMapEntries = Object.entries(templateVariantMaps);
+      const hasVariantMaps = templateVariantMapEntries.some(([, pathMap]) => Object.keys(pathMap).length > 0);
+      const tsTemplateVariantMap = hasVariantMaps ? `type TemplateVariantTokens = {
+        ${templateVariantMapEntries.filter(([, pathMap]) => Object.keys(pathMap).length > 0).map(([templateKey, pathMap]) => {
+        const pathEntries = Object.entries(pathMap).map(
+          ([dotPath, axes]) => `'${dotPath}': { ${Object.entries(axes).map(([axis, valueType]) => `${axis}?: ${valueType}`).join("; ")} }`
+        ).join(";\n          ");
+        return `${templateKey}: {
+          ${pathEntries}
+        }`;
+      }).join(";\n        ")}
+      }` : `type TemplateVariantTokens = Record<string, Record<string, Record<string, never>>>;`;
+      const tsTemplateVariantAliases = templateVariantMapEntries.flatMap(
+        ([templateKey, pathMap]) => Object.keys(pathMap).map((dotPath) => `type ${pascal(templateKey)}${pascal(dotPath)}Variants = TemplateVariantTokens['${templateKey}']['${dotPath}'];`)
+      ).join("\n      ");
       const tsTokensTypes = `
       // Variable types
-      type VariableTokens = ${tsVariableTokens || `''`}; 
+      type VariableTokens = ${tsVariableTokens || `''`};
       type PropertyValueToken = \`{\${VariableTokens}}\`;
-    
+
       // Template types
       type TemplateTokens = {
-        ${Object.entries(templateTokens).map(([key, value]) => `${key}?: ${value}`).join("\n")}
+        ${Object.entries(templateTokens).map(([key, value]) => {
+        if (!value || value === "any") return `${key}?: ${value || "any"}`;
+        return `${key}?: ${value} | \`\${${value}}@\${string}\``;
+      }).join("\n")}
       }
-    
+
+      // Template variant types (per docs/template-variants-spec.md §7)
+      ${tsTemplateVariantMap}
+      ${tsTemplateVariantAliases}
+
       // Media query types
       type MediaQueryKeys = ${mediaQueryKeys || `''`};
       `;
@@ -526,7 +625,8 @@ ${css}
       let currentFile = readFileSync(sourceFilePath, "utf8");
       currentFile = this.replaceStyledTag(currentFile);
       currentFile = this.addConfigCache(currentFile);
-      const outputFilePath = join(outputDirectory, "js", hashedName + ".js");
+      const currentFileHash = toHash(currentFile);
+      const outputFilePath = join(outputDirectory, "js", `${hashedName}-${currentFileHash}.js`);
       const rcProject = await this.getRCProjectConfig(this.projectRootDir);
       const coreConfigPath = join(this.projectRootDir, (rcProject == null ? void 0 : rcProject.configDir) || "", "salty.config.ts");
       const externalModules = this.getExternalModules(coreConfigPath);
@@ -670,11 +770,13 @@ ${newContent}
       });
     });
     this.projectRootDir = projectRootDir;
+    this.options = options;
     if (typeof process === "undefined") {
       throw new Error("SaltyServer can only be used in a Node.js environment.");
     }
   }
   get isProduction() {
+    if (this.options.mode) return this.options.mode === "production";
     try {
       return process.env["NODE_ENV"] !== "development";
     } catch {

package/config/index.cjs

@@ -5,9 +5,13 @@ 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,15 +1,19 @@
-import { GlobalStylesFactory, VariablesFactory, defineGlobalStyles, defineMediaQuery, defineVariables } from "../factories/index.js";
+import { FontFactory, GlobalStylesFactory, ImportFactory, VariablesFactory, defineFont, 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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const parseStyles = require("../parse-styles-lOMGe_c5.cjs");
+const toHash = require("../to-hash-C05Y906F.cjs");
+const cache_resolveDynamicConfigCache = require("../cache/resolve-dynamic-config-cache.cjs");
+const getDynamicStylesClassName = (styles) => {
+  return toHash.toHash(styles);
+};
+const getDynamicStylesCss = async (styles, scope) => {
+  const config = await cache_resolveDynamicConfigCache.resolveDynamicConfigCache();
+  const parsed = await parseStyles.parseStyles(styles, scope, config);
+  return parsed.join("\n");
+};
+exports.getDynamicStylesClassName = getDynamicStylesClassName;
+exports.getDynamicStylesCss = getDynamicStylesCss;

package/css/dynamic-styles.d.ts

@@ -0,0 +1,10 @@
+import { BaseStyles } from '../types';
+/**
+ * Create a hash of the dynamic styles that then can be used as scope.
+ */
+export declare const getDynamicStylesClassName: (styles: BaseStyles) => string;
+/**
+ * Add any dynamic styles to your app with a custom scope.
+ * Note: this works only with server components.
+ */
+export declare const getDynamicStylesCss: (styles: BaseStyles, scope?: string) => Promise<string>;

package/css/dynamic-styles.js

@@ -0,0 +1,15 @@
+import { a as parseStyles } from "../parse-styles-BBJ3PWyV.js";
+import { t as toHash } from "../to-hash-DAN2LcHK.js";
+import { resolveDynamicConfigCache } from "../cache/resolve-dynamic-config-cache.js";
+const getDynamicStylesClassName = (styles) => {
+  return toHash(styles);
+};
+const getDynamicStylesCss = async (styles, scope) => {
+  const config = await resolveDynamicConfigCache();
+  const parsed = await parseStyles(styles, scope, config);
+  return parsed.join("\n");
+};
+export {
+  getDynamicStylesClassName,
+  getDynamicStylesCss
+};

package/css/index.cjs

@@ -4,9 +4,12 @@ const css_keyframes = require("./keyframes.cjs");
 const css_media = require("./media.cjs");
 const css_token = require("./token.cjs");
 const css_merge = require("./merge.cjs");
+const css_dynamicStyles = require("./dynamic-styles.cjs");
 exports.keyframes = css_keyframes.keyframes;
 exports.MediaQueryFactory = css_media.MediaQueryFactory;
 exports.media = css_media.media;
 exports.token = css_token.token;
 exports.mergeFactories = css_merge.mergeFactories;
 exports.mergeObjects = css_merge.mergeObjects;
+exports.getDynamicStylesClassName = css_dynamicStyles.getDynamicStylesClassName;
+exports.getDynamicStylesCss = css_dynamicStyles.getDynamicStylesCss;

package/css/index.d.ts

@@ -2,3 +2,4 @@ export * from './keyframes';
 export * from './media';
 export * from './token';
 export * from './merge';
+export * from './dynamic-styles';

package/css/index.js

@@ -2,8 +2,11 @@ import { keyframes } from "./keyframes.js";
 import { MediaQueryFactory, media } from "./media.js";
 import { token } from "./token.js";
 import { mergeFactories, mergeObjects } from "./merge.js";
+import { getDynamicStylesClassName, getDynamicStylesCss } from "./dynamic-styles.js";
 export {
   MediaQueryFactory,
+  getDynamicStylesClassName,
+  getDynamicStylesCss,
   keyframes,
   media,
   mergeFactories,

package/css/keyframes.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const parseStyles = require("../parse-styles-CA3TP5n1.cjs");
+const parseStyles = require("../parse-styles-lOMGe_c5.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-BTIoYnBr.js";
+import { p as parseAndJoinStyles } from "../parse-styles-BBJ3PWyV.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-font.d.ts

@@ -0,0 +1,28 @@
+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/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

@@ -1,7 +1,130 @@
 "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 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;
@@ -13,6 +136,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);
 };
@@ -30,8 +167,12 @@ 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,4 +1,6 @@
+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';