@styleframe/cli 4.0.0 → 4.1.0

package/dist/build-CANA04j1.js

@@ -1,49 +0,0 @@
-import path from "node:path";
-import { loadConfiguration, build as build$1 } from "@styleframe/loader";
-import { defineCommand } from "citty";
-import consola from "consola";
-const build = defineCommand({
-  meta: {
-    name: "build",
-    description: "Build Styleframe project from source files"
-  },
-  args: {
-    entry: {
-      type: "positional",
-      description: "Entry point file(s) for the build",
-      default: "styleframe.config.ts",
-      valueHint: "path"
-    },
-    outputDir: {
-      type: "string",
-      description: "Output directory for built files",
-      default: "styleframe",
-      alias: ["o", "out"],
-      valueHint: "path"
-    },
-    clean: {
-      type: "boolean",
-      description: "Clean output directory before build",
-      default: false
-    }
-  },
-  async run({ args }) {
-    consola.info(
-      `Loading configuration from "${path.relative(process.cwd(), path.resolve(args.entry))}"...`
-    );
-    const instance = await loadConfiguration({ entry: args.entry });
-    consola.info("Building styleframe...");
-    try {
-      await build$1(instance, {
-        outputDir: args.outputDir,
-        clean: args.clean
-      });
-      consola.success("Styleframe built successfully!");
-    } catch (error) {
-      consola.error("Failed to build Styleframe:", error);
-    }
-  }
-});
-export {
-  build as default
-};

package/dist/export-BMneJTdq.cjs

@@ -1,517 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const promises = require("node:fs/promises");
-const path = require("node:path");
-const loader = require("@styleframe/loader");
-const citty = require("citty");
-const consola = require("consola");
-const dtcg = require("@styleframe/dtcg");
-function isReference(value) {
-  return typeof value === "object" && value !== null && "type" in value && value.type === "reference";
-}
-function isCss(value) {
-  return typeof value === "object" && value !== null && "type" in value && value.type === "css";
-}
-function isPrimitive(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-function resolveReferenceTarget(ref, context) {
-  const visited = context.visited ?? /* @__PURE__ */ new Set();
-  if (visited.has(ref.name)) {
-    return {
-      resolved: null,
-      reason: `Reference cycle: ${[...visited, ref.name].join(" → ")}`
-    };
-  }
-  const target = context.variables.get(ref.name);
-  if (!target) {
-    if (ref.fallback !== void 0 && ref.fallback !== null) {
-      return evaluateValue(ref.fallback, context);
-    }
-    return { resolved: null, reason: `Unknown reference target: ${ref.name}` };
-  }
-  const nextContext = {
-    variables: context.variables,
-    visited: /* @__PURE__ */ new Set([...visited, ref.name]),
-    maxViewport: context.maxViewport
-  };
-  return evaluateValue(target.value, nextContext);
-}
-function evaluateCss(css, context) {
-  const parts = [];
-  let unevaluable = false;
-  let unevaluableReason;
-  for (const part of css.value) {
-    if (typeof part === "string") {
-      parts.push({ kind: "literal", text: part });
-      continue;
-    }
-    const evaluated = evaluateValue(part, context);
-    if (evaluated.resolved === null) {
-      unevaluable = true;
-      unevaluableReason = evaluated.reason;
-      parts.push({ kind: "value", text: "" });
-      continue;
-    }
-    const text = String(evaluated.resolved);
-    const numeric = typeof evaluated.resolved === "number" ? evaluated.resolved : void 0;
-    parts.push({ kind: "value", text, numeric });
-  }
-  const folded = parts.map((p) => p.text).join("");
-  if (unevaluable) {
-    return {
-      resolved: null,
-      cssExpression: folded,
-      reason: unevaluableReason ?? "Computed expression includes an unresolvable reference"
-    };
-  }
-  const isPureArithmetic = parts.every((p) => {
-    if (p.kind === "value") return p.numeric !== void 0;
-    return /^[\d.\s+\-*/()]*$/.test(p.text);
-  });
-  if (isPureArithmetic && parts.some((p) => p.kind === "value")) {
-    try {
-      const result = safeArithmetic(folded.trim());
-      if (typeof result === "number" && Number.isFinite(result)) {
-        return { resolved: result };
-      }
-    } catch (err) {
-      return {
-        resolved: null,
-        cssExpression: folded,
-        reason: `Arithmetic evaluation failed: ${err.message}`
-      };
-    }
-  }
-  const subResult = substituteFluidUnits(folded, context.maxViewport ?? 1440);
-  if (subResult && /^[\d.\s+\-*/()]+$/.test(subResult.rebased)) {
-    try {
-      const result = safeArithmetic(subResult.rebased.trim());
-      if (typeof result === "number" && Number.isFinite(result)) {
-        return {
-          resolved: result,
-          ...subResult.substituted ? { normalisationSource: "fluid-max" } : {}
-        };
-      }
-    } catch {
-    }
-  }
-  return { resolved: folded };
-}
-function substituteFluidUnits(expression, maxViewport) {
-  let substituted = false;
-  let rebased = expression.replace(/\bcalc\b/g, "");
-  if (rebased.includes("100vw")) {
-    rebased = rebased.replace(/100vw/g, String(maxViewport));
-    substituted = true;
-  }
-  if (/(-?\d*\.?\d+)\s*rem/.test(rebased)) {
-    rebased = rebased.replace(/(-?\d*\.?\d+)\s*rem/g, "($1 * 16)");
-    substituted = true;
-  }
-  if (/(-?\d*\.?\d+)\s*px/.test(rebased)) {
-    rebased = rebased.replace(/(-?\d*\.?\d+)\s*px/g, "$1");
-    substituted = true;
-  }
-  if (/[a-zA-Z%]/.test(rebased)) return null;
-  return { rebased, substituted };
-}
-function safeArithmetic(expression) {
-  if (!/^[\d.\s+\-*/()]+$/.test(expression)) {
-    throw new Error(`Disallowed characters in expression: "${expression}"`);
-  }
-  const fn = new Function(`return (${expression});`);
-  return fn();
-}
-function evaluateValue(value, context) {
-  if (value === null || value === void 0) {
-    return { resolved: null, reason: "Value is null/undefined" };
-  }
-  if (isPrimitive(value)) {
-    return { resolved: value };
-  }
-  if (isReference(value)) {
-    const targetResolution = resolveReferenceTarget(value, context);
-    const isTopLevel = !context.visited || context.visited.size === 0;
-    if (isTopLevel && targetResolution.resolved !== null) {
-      return { ...targetResolution, aliasTarget: value.name };
-    }
-    return targetResolution;
-  }
-  if (isCss(value)) {
-    return evaluateCss(value, context);
-  }
-  if (Array.isArray(value)) {
-    return {
-      resolved: null,
-      reason: "Heterogeneous array — DTCG composite encoding not yet implemented"
-    };
-  }
-  return {
-    resolved: null,
-    reason: `Unsupported value shape: ${typeof value}`
-  };
-}
-const TOKENS_SCHEMA_URL = "https://design-tokens.org/schemas/2025.10/tokens.json";
-const RESOLVER_SCHEMA_URL = "https://www.designtokens.org/schemas/2025.10/resolver.json";
-function buildVariableMap(root) {
-  const map = /* @__PURE__ */ new Map();
-  for (const v of root.variables) map.set(v.name, v);
-  for (const theme of root.themes) {
-    for (const v of theme.variables) {
-      if (!map.has(v.name)) map.set(v.name, v);
-    }
-  }
-  return map;
-}
-function processVariable(variable, context) {
-  const evaluation = evaluateValue(variable.value, context);
-  const classification = classifyValueForVariable(variable.name, evaluation);
-  return { name: variable.name, evaluation, classification };
-}
-function classifyValueForVariable(name, evaluation) {
-  if (evaluation.resolved === null) return void 0;
-  return dtcg.classifyValue(evaluation.resolved, { path: name });
-}
-function setNestedToken(doc, dotPath, token) {
-  const segments = dotPath.split(".");
-  let cursor = doc;
-  for (let i = 0; i < segments.length - 1; i++) {
-    const segment = segments[i];
-    const next = cursor[segment];
-    if (typeof next !== "object" || next === null || Array.isArray(next)) {
-      cursor[segment] = {};
-    } else if ("$value" in next) {
-      cursor[segment] = { $root: next };
-    }
-    cursor = cursor[segment];
-  }
-  const leaf = segments[segments.length - 1];
-  const existing = cursor[leaf];
-  if (typeof existing === "object" && existing !== null && !Array.isArray(existing) && !("$value" in existing)) {
-    existing.$root = token;
-  } else {
-    cursor[leaf] = token;
-  }
-}
-function setNestedOverride(context, dotPath, value, type) {
-  const segments = dotPath.split(".");
-  let cursor = context;
-  for (let i = 0; i < segments.length - 1; i++) {
-    const segment = segments[i];
-    const next = cursor[segment];
-    if (typeof next !== "object" || next === null || Array.isArray(next) || "$value" in next) {
-      cursor[segment] = {};
-    }
-    cursor = cursor[segment];
-  }
-  const token = { $value: value };
-  if (type !== void 0) token.$type = type;
-  cursor[segments[segments.length - 1]] = token;
-}
-function makeAliasToken(target, type, description) {
-  const token = { $value: dtcg.formatAlias(target) };
-  if (type !== void 0) token.$type = type;
-  return token;
-}
-function makeValueToken(classification, description, fluidBound) {
-  const token = {
-    $value: classification.value,
-    $type: classification.type
-  };
-  if (fluidBound) {
-    token.$extensions = {
-      "dev.styleframe": { fluidBound }
-    };
-  }
-  return token;
-}
-function makeExpressionToken(expression, description) {
-  const token = {
-    $value: expression,
-    $extensions: {
-      "dev.styleframe": { expression }
-    }
-  };
-  return token;
-}
-function valuesEqual(a, b) {
-  if (a === b) return true;
-  if (typeof a !== typeof b) return false;
-  if (typeof a === "object") return JSON.stringify(a) === JSON.stringify(b);
-  return false;
-}
-function capitalizeContextName(name) {
-  if (name.length === 0) return name;
-  return name.charAt(0).toUpperCase() + name.slice(1);
-}
-function buildDTCG(root, options = {}) {
-  const includeSchema = options.includeSchema ?? true;
-  const schemaUrl = options.schemaUrl ?? TOKENS_SCHEMA_URL;
-  const modifierName = options.modifierName ?? "theme";
-  const collectionName = options.collectionName ?? "Design Tokens";
-  const defaultModeName = options.defaultModeName ?? "Default";
-  const tokensSourceRef = options.tokensSourceRef ?? "tokens.json";
-  const variableMap = buildVariableMap(root);
-  const fluidMaxVariable = variableMap.get("fluid.max-width");
-  const fluidMaxResolved = fluidMaxVariable ? evaluateValue(fluidMaxVariable.value, { variables: variableMap }).resolved : null;
-  const maxViewport = typeof fluidMaxResolved === "number" ? fluidMaxResolved : 1440;
-  const context = { variables: variableMap, maxViewport };
-  const processed = /* @__PURE__ */ new Map();
-  const typeMap = /* @__PURE__ */ new Map();
-  for (const variable of root.variables) {
-    const p = processVariable(variable, context);
-    processed.set(variable.name, p);
-    if (p.classification) typeMap.set(variable.name, p.classification.type);
-  }
-  const resolveTypeFromAliasChain = (name, seen) => {
-    if (seen.has(name)) return void 0;
-    const direct = typeMap.get(name);
-    if (direct) return direct;
-    const p = processed.get(name);
-    if (p?.evaluation.aliasTarget) {
-      return resolveTypeFromAliasChain(
-        p.evaluation.aliasTarget,
-        /* @__PURE__ */ new Set([...seen, name])
-      );
-    }
-    return void 0;
-  };
-  const tokens = {};
-  if (includeSchema) tokens.$schema = schemaUrl;
-  tokens.$extensions = {
-    "dev.styleframe": { collection: collectionName }
-  };
-  const diagnostics = [];
-  let emittedCount = 0;
-  let fluidNormalisedCount = 0;
-  for (const variable of root.variables) {
-    const p = processed.get(variable.name);
-    if (!p) continue;
-    const { evaluation, classification } = p;
-    if (evaluation.aliasTarget) {
-      const targetType = resolveTypeFromAliasChain(
-        evaluation.aliasTarget,
-        /* @__PURE__ */ new Set()
-      );
-      setNestedToken(
-        tokens,
-        variable.name,
-        makeAliasToken(evaluation.aliasTarget, targetType)
-      );
-      emittedCount++;
-      continue;
-    }
-    if (classification) {
-      const fluidBound = evaluation.normalisationSource === "fluid-max" ? "max" : void 0;
-      const promoted = fluidBound && classification.type === "number" && typeof classification.value === "number" ? {
-        type: "dimension",
-        value: { value: classification.value, unit: "px" }
-      } : classification;
-      setNestedToken(
-        tokens,
-        variable.name,
-        makeValueToken(promoted, void 0, fluidBound)
-      );
-      if (fluidBound) fluidNormalisedCount++;
-      emittedCount++;
-      continue;
-    }
-    if (evaluation.cssExpression) {
-      setNestedToken(
-        tokens,
-        variable.name,
-        makeExpressionToken(evaluation.cssExpression)
-      );
-      diagnostics.push({
-        name: variable.name,
-        level: "warn",
-        reason: evaluation.reason ?? "Computed expression — preserved as dev.styleframe.expression extension"
-      });
-      emittedCount++;
-      continue;
-    }
-    if (evaluation.resolved !== null && typeof evaluation.resolved !== "boolean") {
-      setNestedToken(tokens, variable.name, {
-        $value: String(evaluation.resolved),
-        $extensions: { "dev.styleframe": { unknownType: true } }
-      });
-      diagnostics.push({
-        name: variable.name,
-        level: "warn",
-        reason: "Could not infer DTCG $type — emitted as untyped string"
-      });
-      emittedCount++;
-      continue;
-    }
-    diagnostics.push({
-      name: variable.name,
-      level: "warn",
-      reason: evaluation.reason ?? "Unrepresentable value — skipped"
-    });
-  }
-  const themedThemes = root.themes.filter(
-    (t) => t.variables.length > 0
-  );
-  let resolver;
-  if (themedThemes.length > 0) {
-    const contexts = {};
-    for (const theme of themedThemes) {
-      const contextDoc = {};
-      for (const variable of theme.variables) {
-        const themeProcessed = processVariable(variable, context);
-        const defaultProcessed = processed.get(variable.name);
-        let themeValue;
-        let themeType;
-        if (themeProcessed.evaluation.aliasTarget) {
-          themeValue = dtcg.formatAlias(themeProcessed.evaluation.aliasTarget);
-          themeType = resolveTypeFromAliasChain(
-            themeProcessed.evaluation.aliasTarget,
-            /* @__PURE__ */ new Set()
-          );
-        } else if (themeProcessed.classification) {
-          themeValue = themeProcessed.classification.value;
-          themeType = themeProcessed.classification.type;
-        }
-        if (themeValue === void 0) continue;
-        let defaultValue;
-        if (defaultProcessed?.evaluation.aliasTarget) {
-          defaultValue = dtcg.formatAlias(defaultProcessed.evaluation.aliasTarget);
-        } else if (defaultProcessed?.classification) {
-          defaultValue = defaultProcessed.classification.value;
-        }
-        if (defaultValue !== void 0 && valuesEqual(themeValue, defaultValue)) {
-          continue;
-        }
-        setNestedOverride(
-          contextDoc,
-          variable.name,
-          themeValue,
-          themeType
-        );
-      }
-      contexts[capitalizeContextName(theme.name)] = contextDoc;
-    }
-    for (const key of Object.keys(contexts)) {
-      if (Object.keys(contexts[key]).length === 0)
-        delete contexts[key];
-    }
-    const themeContextNames = Object.keys(contexts);
-    if (themeContextNames.length > 0) {
-      const allContexts = {
-        [defaultModeName]: []
-      };
-      for (const name of themeContextNames) {
-        allContexts[name] = [contexts[name]];
-      }
-      resolver = {
-        $schema: RESOLVER_SCHEMA_URL,
-        version: "2025.10",
-        modifiers: {
-          [modifierName]: {
-            contexts: allContexts,
-            default: defaultModeName
-          }
-        },
-        resolutionOrder: [
-          { type: "set", sources: [{ $ref: tokensSourceRef }] },
-          { $ref: `#/modifiers/${modifierName}` }
-        ]
-      };
-    }
-  }
-  return {
-    tokens,
-    resolver,
-    diagnostics,
-    emittedCount,
-    fluidNormalisedCount,
-    maxViewport
-  };
-}
-const _export = citty.defineCommand({
-  meta: {
-    name: "export",
-    description: "Export Styleframe variables to spec-conformant DTCG JSON"
-  },
-  args: {
-    config: {
-      type: "string",
-      description: "Path to the Styleframe config file",
-      default: "styleframe.config.ts",
-      alias: ["c"],
-      valueHint: "path"
-    },
-    output: {
-      type: "string",
-      description: "Output JSON file path",
-      default: "tokens.json",
-      alias: ["o"],
-      valueHint: "path"
-    },
-    collection: {
-      type: "string",
-      description: "Collection name embedded in the export",
-      default: "Design Tokens",
-      alias: ["n", "name"]
-    }
-  },
-  async run({ args }) {
-    const configPath = path.resolve(args.config);
-    const outputPath = path.resolve(args.output);
-    consola.info(
-      `Loading configuration from "${path.relative(process.cwd(), configPath)}"...`
-    );
-    const instance = await loader.loadConfiguration({ entry: configPath });
-    const root = instance.root;
-    consola.info("Building DTCG document...");
-    const {
-      tokens,
-      resolver,
-      diagnostics,
-      emittedCount,
-      fluidNormalisedCount,
-      maxViewport
-    } = buildDTCG(root, {
-      collectionName: args.collection,
-      tokensSourceRef: path.basename(outputPath)
-    });
-    await promises.writeFile(outputPath, `${JSON.stringify(tokens, null, 2)}
-`);
-    consola.info(
-      `Wrote ${emittedCount} tokens to "${path.relative(process.cwd(), outputPath)}"`
-    );
-    if (fluidNormalisedCount > 0) {
-      consola.info(
-        `Normalised ${fluidNormalisedCount} fluid token(s) using max viewport (${maxViewport}px).`
-      );
-    }
-    if (resolver) {
-      const resolverPath = outputPath.replace(/\.json$/, ".resolver.json");
-      await promises.writeFile(resolverPath, `${JSON.stringify(resolver, null, 2)}
-`);
-      consola.info(
-        `Wrote resolver to "${path.relative(process.cwd(), resolverPath)}"`
-      );
-    }
-    const warnings = diagnostics.filter((d) => d.level === "warn");
-    if (warnings.length > 0) {
-      consola.warn(
-        `${warnings.length} variable(s) needed special handling — see Styleframe ↔ DTCG round-trip notes`
-      );
-      for (const w of warnings.slice(0, 10)) {
-        consola.info(`  - ${w.name}: ${w.reason}`);
-      }
-      if (warnings.length > 10) {
-        consola.info(`  ... and ${warnings.length - 10} more`);
-      }
-      consola.info(
-        'Tip: untyped tokens are usually CSS keywords (e.g. "normal", "thin", "italic") with no DTCG equivalent — they round-trip to Figma as STRING variables.'
-      );
-    }
-    consola.success(
-      `Exported ${emittedCount} tokens in DTCG format to "${path.relative(process.cwd(), outputPath)}"`
-    );
-  }
-});
-exports.default = _export;