@kanso-labs/unplugin-style-dictionary 0.10.5 → 0.10.7

package/README.md

@@ -1011,7 +1011,8 @@ export interface UnpluginStyleDictionaryOptions {
   report?: boolean
 
   /**
-   * The directory a relative `config` path is looked up in.
+   * The directory a relative `config` path is looked up in, and a relative
+   * `watch` entry is resolved against.
    *
    * Defaults to the host's own root — Vite's `root`, webpack's `context` —
    * and to the working directory for rollup and rolldown, which offer none.
@@ -1047,6 +1048,13 @@ export interface UnpluginStyleDictionaryOptions {
    * pattern's own directory is registered alongside them, so a token file
    * created later is noticed too.
    *
+   * A relative entry is resolved against `root`, like a relative `config`: both
+   * are options of this plugin rather than paths inside a configuration. That
+   * is not the base `source` and `include` use — Style Dictionary reads those
+   * against the working directory — so where the host's root is somewhere
+   * else, name a file here relative to the root, and in `source` relative to
+   * where the build runs.
+   *
    * What a change to a watched file then triggers is the host's to decide —
    * see the interface documentation above.
    */

package/dist/colour.js

@@ -0,0 +1,16 @@
+//#region src/colour.ts
+function colourAllowed(stream) {
+	if (process.env.NO_COLOR) return false;
+	const forced = process.env.FORCE_COLOR;
+	if (forced === "0") return false;
+	if (forced !== void 0 && forced !== "") return true;
+	if (process.env.TERM === "dumb") return false;
+	return stream.isTTY === true;
+}
+function paint(code, value, allowed) {
+	return allowed ? `\u001B[${code}m${value}\u001B[0m` : value;
+}
+//#endregion
+export { colourAllowed, paint };
+
+//# sourceMappingURL=colour.js.map

package/dist/colour.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"colour.js","names":[],"sources":["../src/colour.ts"],"sourcesContent":["// Whether escapes may be written to this stream.\n//\n// **The three signals are ordered rather than combined into one conjunction**,\n// and that ordering is the whole of it. `FORCE_COLOR=1` on a non-TTY — a CI job\n// that wants colour in a log it will render itself — is the single job that\n// variable has, and\n// `!process.env.NO_COLOR && process.env.FORCE_COLOR !== '0' && stream.isTTY`\n// never honours it: the TTY check has the last word and answers `false`.\n//\n// `NO_COLOR` wins over `FORCE_COLOR` because the convention says so: any\n// non-empty value turns colour off, and nothing may turn it back on.\nexport function colourAllowed(stream: { isTTY?: boolean }): boolean {\n  if (process.env.NO_COLOR) return false\n\n  const forced = process.env.FORCE_COLOR\n  if (forced === '0') return false\n  if (forced !== undefined && forced !== '') return true\n\n  // A terminal that has told us it cannot render escapes. Not one of the three\n  // the issue named, but it is what `TERM=dumb` means and it costs a line.\n  if (process.env.TERM === 'dumb') return false\n\n  return stream.isTTY === true\n}\n\nexport function paint(code: string, value: string, allowed: boolean): string {\n  return allowed ? `\\u001B[${code}m${value}\\u001B[0m` : value\n}\n"],"mappings":";AAWA,SAAgB,cAAc,QAAsC;CAClE,IAAI,QAAQ,IAAI,UAAU,OAAO;CAEjC,MAAM,SAAS,QAAQ,IAAI;CAC3B,IAAI,WAAW,KAAK,OAAO;CAC3B,IAAI,WAAW,KAAA,KAAa,WAAW,IAAI,OAAO;CAIlD,IAAI,QAAQ,IAAI,SAAS,QAAQ,OAAO;CAExC,OAAO,OAAO,UAAU;AAC1B;AAEA,SAAgB,MAAM,MAAc,OAAe,SAA0B;CAC3E,OAAO,UAAU,UAAU,KAAK,GAAG,MAAM,aAAa;AACxD"}

package/dist/compile.js

@@ -0,0 +1,114 @@
+import { asError, errorMessage } from "./errors.js";
+import { configForBuild, describeConfig, readConfigObject } from "./config.js";
+import { patternsMatchingNothing, sourcePatternsOf } from "./patterns.js";
+import { reportSizes } from "./size-report.js";
+import { configFingerprint, declaredDestinations, isUpToDate, writtenDestination } from "./up-to-date.js";
+import StyleDictionary from "style-dictionary";
+//#region src/compile.ts
+async function runBuilds(instance, resolvedConfigs, context) {
+	const { cache, compiledFingerprints, failOnError, generatedDestinations, log, notifyBuildOutcome, onBuildEnd, onBuildError, onBuildStart, platformsOption, quiet, report, stdoutColour, verbosity, volume, watch } = instance;
+	const root = instance.root();
+	const startTime = Date.now();
+	const generatedFiles = /* @__PURE__ */ new Set();
+	let skipped = 0;
+	try {
+		if (!context) log("Compiling design tokens...", "info");
+		if (onBuildStart) callHook(log, "onBuildStart", onBuildStart);
+		for (const [index, item] of resolvedConfigs.entries()) {
+			const declared = cache ? await readConfigObject(item) : null;
+			const selectedPlatforms = platformsFor(platformsOption, context);
+			if (declared && await isUpToDate({
+				compiledFingerprints,
+				log,
+				root,
+				watch
+			}, item, declared, selectedPlatforms)) {
+				for (const destination of declaredDestinations(declared)) generatedFiles.add(destination);
+				skipped++;
+				continue;
+			}
+			const sd = new StyleDictionary(await configForBuild(item), { init: false });
+			await sd.extend(void 0, {
+				mutateOriginal: true,
+				verbosity
+			});
+			if (sd.allTokens.length === 0) {
+				const asObject = await readConfigObject(item);
+				const barren = asObject ? await patternsMatchingNothing(sourcePatternsOf(asObject)) : [];
+				throw new Error([
+					`${describeConfig(item, index)} resolved no tokens, so its output would be emptied.`,
+					barren.length > 0 ? `These patterns matched no files: ${barren.join(", ")}` : `It declares no source or include patterns that matched anything.`,
+					`Nothing was written. Set failOnError to false to build anyway.`
+				].join(" "));
+			}
+			sd.volume = volume;
+			if (selectedPlatforms === void 0) await sd.buildAllPlatforms();
+			else {
+				const defined = Object.keys(sd.platforms);
+				const unknown = selectedPlatforms.filter((name) => !defined.includes(name));
+				if (unknown.length > 0) throw new Error(`${describeConfig(item, index)} does not define the platform(s) ${unknown.join(", ")}. It defines ${defined.join(", ")}.`);
+				for (const name of selectedPlatforms) await sd.buildPlatform(name);
+			}
+			for (const platform of Object.values(sd.platforms)) for (const file of platform.files ?? []) if (file.destination) generatedFiles.add(writtenDestination(platform.buildPath, file.destination));
+			const fingerprint = configFingerprint(root, item);
+			if (fingerprint !== null) compiledFingerprints.add(fingerprint);
+		}
+		generatedDestinations.clear();
+		for (const destination of generatedFiles) generatedDestinations.add(destination.replace(/\\/g, "/"));
+	} catch (err) {
+		log(`Compilation failed after ${Date.now() - startTime}ms: ${errorMessage(err)}`, "error");
+		notifyBuildOutcome(asError(err));
+		if (onBuildError) callHook(log, "onBuildError", onBuildError, err);
+		if (failsTheBuild(failOnError, context)) throw err;
+		return;
+	}
+	notifyBuildOutcome(null);
+	const duration = Date.now() - startTime;
+	if (onBuildEnd) callHook(log, "onBuildEnd", onBuildEnd, Array.from(generatedFiles).sort((left, right) => left.localeCompare(right)), duration);
+	const everythingSkipped = skipped === resolvedConfigs.length;
+	if (context) {
+		log(everythingSkipped ? `Design tokens already up to date after change in ${context} (${duration}ms)` : `Rebuilt design tokens due to change in ${context} (${duration}ms)`, "success");
+		return;
+	}
+	if (report && !quiet && !everythingSkipped && generatedFiles.size > 0) try {
+		reportSizes({
+			root,
+			stdoutColour
+		}, generatedFiles);
+	} catch (err) {
+		log(`Failed to report generated file sizes: ${errorMessage(err)}`, "error");
+	}
+	if (everythingSkipped) {
+		log(`Design tokens are already up to date (${duration}ms)`, "success");
+		return;
+	}
+	log(skipped > 0 ? `Compiled successfully! (${duration}ms, ${skipped} already up to date)` : `Compiled successfully! (${duration}ms)`, "success");
+}
+function callHook(log, name, hook, ...args) {
+	let result;
+	try {
+		result = hook(...args);
+	} catch (err) {
+		log(`The ${name} hook threw: ${errorMessage(err)}`, "error");
+		return;
+	}
+	if (!isThenable(result)) return;
+	Promise.resolve(result).catch((err) => {
+		log(`The ${name} hook rejected: ${errorMessage(err)}`, "error");
+	});
+}
+function failsTheBuild(failOnError, context) {
+	return failOnError === true || (context === void 0 ? failOnError === "build" : failOnError === "serve");
+}
+function isThenable(value) {
+	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function platformsFor(platformsOption, context) {
+	if (platformsOption === void 0) return void 0;
+	if (Array.isArray(platformsOption)) return platformsOption;
+	return context === void 0 ? platformsOption.build : platformsOption.watch;
+}
+//#endregion
+export { runBuilds };
+
+//# sourceMappingURL=compile.js.map

package/dist/compile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.js","names":[],"sources":["../src/compile.ts"],"sourcesContent":["// One compile of every resolved configuration: building each one through the\n// atomic volume, recording what it wrote, and saying how it went.\n//\n// Nothing here holds state. What a plugin instance owns is handed in as a\n// `PluginInstance`, which the factory builds once, and the two parts of it\n// that are assigned after the factory has run — `root` and the overlay\n// callback — are reached through it when a compile runs rather than copied\n// when it was built.\n\nimport type fs from 'node:fs'\n\nimport StyleDictionary from 'style-dictionary'\n\nimport type { ResolvedConfig } from './config.js'\nimport type { UnpluginStyleDictionaryOptions } from './types.js'\n\nimport { configForBuild, describeConfig, readConfigObject } from './config.js'\nimport { asError, errorMessage } from './errors.js'\nimport { patternsMatchingNothing, sourcePatternsOf } from './patterns.js'\nimport { reportSizes } from './size-report.js'\nimport {\n  configFingerprint,\n  declaredDestinations,\n  isUpToDate,\n  writtenDestination,\n} from './up-to-date.js'\n\n// What `runBuilds` reads from the plugin instance it compiles for.\n//\n// `root` and `notifyBuildOutcome` are functions for the same reason: each is\n// assigned after the factory has run — `root` by `adoptCompiler` or\n// `configResolved`, the overlay callback by `configureServer` — so a value\n// copied when this was built would be the working directory and `undefined`\n// for good. `generatedDestinations` is the instance's own record of what it\n// wrote, and `compiledFingerprints` is the process's; neither lives here.\nexport interface PluginInstance {\n  cache: boolean\n  compiledFingerprints: Set<string>\n  failOnError: NonNullable<UnpluginStyleDictionaryOptions['failOnError']>\n  generatedDestinations: Set<string>\n  log: (message: string, type: 'error' | 'info' | 'success') => void\n  notifyBuildOutcome: (error: Error | null) => void\n  onBuildEnd: UnpluginStyleDictionaryOptions['onBuildEnd']\n  onBuildError: UnpluginStyleDictionaryOptions['onBuildError']\n  onBuildStart: UnpluginStyleDictionaryOptions['onBuildStart']\n  platformsOption: UnpluginStyleDictionaryOptions['platforms']\n  quiet: boolean\n  report: boolean\n  root: () => string\n  stdoutColour: boolean\n  verbosity: 'default' | 'silent' | 'verbose' | undefined\n  volume: typeof fs\n  watch: UnpluginStyleDictionaryOptions['watch']\n}\n\n// Compile design tokens\nexport async function runBuilds(\n  instance: PluginInstance,\n  resolvedConfigs: ResolvedConfig[],\n  context?: string,\n): Promise<void> {\n  const {\n    cache,\n    compiledFingerprints,\n    failOnError,\n    generatedDestinations,\n    log,\n    notifyBuildOutcome,\n    onBuildEnd,\n    onBuildError,\n    onBuildStart,\n    platformsOption,\n    quiet,\n    report,\n    stdoutColour,\n    verbosity,\n    volume,\n    watch,\n  } = instance\n\n  // Read when this compile starts rather than when the instance was built,\n  // because the host assigns it after the factory has run.\n  const root = instance.root()\n\n  const startTime = Date.now()\n\n  // Ahead of the `try` rather than inside it, because the reporting below\n  // reads it and that reporting is deliberately outside.\n  const generatedFiles = new Set<string>()\n\n  // How many configurations were already up to date. Read by the reporting\n  // below, which is why it sits out here with `generatedFiles`.\n  let skipped = 0\n\n  try {\n    if (!context) {\n      log('Compiling design tokens...', 'info')\n    }\n\n    // Before anything is resolved or built, and once per build — a watch\n    // rebuild is a build, so this fires again for each one.\n    if (onBuildStart) callHook(log, 'onBuildStart', onBuildStart)\n\n    // Configurations are built one after another rather than with\n    // `Promise.all`, and that is load-bearing. Two configurations may name\n    // the same destination file, and each instance gets the atomic volume\n    // swapped onto it below — overlapping builds would interleave those\n    // writes and hand a reader a file assembled from both.\n    for (const [index, item] of resolvedConfigs.entries()) {\n      // Read ahead of the instance, because avoiding the instance is the\n      // point: construction plus `extend` is the 15-30% of a build that\n      // parses the token sources, and `buildAllPlatforms` is the rest.\n      //\n      // Without a `report`, so a configuration that will not parse says\n      // nothing here — the build below hands Style Dictionary the path and\n      // lets its own message through, which is more specific than anything\n      // this could say.\n      const declared = cache ? await readConfigObject(item) : null\n      const selectedPlatforms = platformsFor(platformsOption, context)\n\n      if (\n        declared &&\n        (await isUpToDate(\n          { compiledFingerprints, log, root, watch },\n          item,\n          declared,\n          selectedPlatforms,\n        ))\n      ) {\n        // The destinations still have to be collected. They are what stops\n        // the plugin's own output being treated as a watched source, so a\n        // skipped configuration that contributed none would have its files\n        // rebuild the moment a watcher noticed them.\n        for (const destination of declaredDestinations(declared)) {\n          generatedFiles.add(destination)\n        }\n\n        skipped++\n        continue\n      }\n\n      // `{ init: false }` is the escape hatch Style Dictionary documents on\n      // this constructor, and it is what makes a bad configuration\n      // catchable. Left to itself the constructor ends in a call to\n      // `init()` whose promise it neither stores nor returns, so a config\n      // that fails to load rejects a promise nobody holds: the `catch`\n      // below never runs, and the host dies with a raw stack or — where an\n      // `unhandledRejection` handler suppresses it — hangs on a\n      // `buildStart` that never settles. `await sd.hasInitialized` cannot\n      // observe it either, since that promise is only ever resolved, at the\n      // tail of a successful extend.\n      //\n      // It is handed the configuration as an object rather than as a path\n      // for the same reason: Style Dictionary imports a path with no\n      // cache-busting query of its own, so under a long-lived dev server\n      // every rebuild after the first built the config the process started\n      // with while the watch list followed the edit.\n      const sd = new StyleDictionary(await configForBuild(item), {\n        init: false,\n      })\n\n      // One initialisation rather than two. `init()` is `extend()` with\n      // `mutateOriginal`, so the old pair loaded the configuration and\n      // combined every source twice — running a custom parser or\n      // preprocessor twice with it — and the first of the two ran at\n      // default verbosity, which is how Style Dictionary's own warnings\n      // escaped this plugin's `silent`. `config` defaults to the one the\n      // constructor was handed.\n      //\n      // `verbosity` is `undefined` unless a consumer asked for a level, and\n      // Style Dictionary falls through an unset one to the configuration's\n      // own `log.verbosity`. Overwriting it here is what silenced the one\n      // line explaining why a build wrote nothing. `log.warnings` is not\n      // touched either way: a consumer's `warnings: 'error'` turning a\n      // missing output file into a thrown build is their decision.\n      await sd.extend(undefined, { mutateOriginal: true, verbosity })\n\n      // **Before the build, and that is the whole of it.** A token set that\n      // resolved to nothing is not an error anywhere in this stack: Style\n      // Dictionary writes the file with no custom properties in it, prints\n      // its usual `✔︎` line at any verbosity, and returns. So a token file\n      // deleted mid-session took the generated output down with it and\n      // reported `Rebuilt design tokens` while doing it, and a `source`\n      // matching nothing shipped an empty stylesheet from a build that\n      // exited 0.\n      //\n      // Checked here because `buildAllPlatforms` truncates and rewrites the\n      // destination: one line later the previous good output is already gone\n      // and an error would be accurate and useless.\n      if (sd.allTokens.length === 0) {\n        // The configuration as an object, so its own patterns can be named.\n        // Without a `report`, because a configuration that will not parse\n        // never reaches here — the `extend` above would have thrown first.\n        const asObject = await readConfigObject(item)\n        const barren = asObject\n          ? await patternsMatchingNothing(sourcePatternsOf(asObject))\n          : []\n\n        // Thrown rather than reported, so it takes the path `failOnError`\n        // already owns — the same decision, made in one place, rather than a\n        // second way for a build to fail.\n        throw new Error(\n          [\n            `${describeConfig(item, index)} resolved no tokens, so its output would be emptied.`,\n            barren.length > 0\n              ? `These patterns matched no files: ${barren.join(', ')}`\n              : `It declares no source or include patterns that matched anything.`,\n            `Nothing was written. Set failOnError to false to build anyway.`,\n          ].join(' '),\n        )\n      }\n\n      // Swap in the atomic volume only now that the instance has finished\n      // reading its configs and token sources, so every write below lands\n      // through `rename` while the read path stays exactly as it was.\n      sd.volume = volume\n\n      if (selectedPlatforms === undefined) {\n        await sd.buildAllPlatforms()\n      } else {\n        // Named, so a typo is an error rather than a platform silently not\n        // built — which is what Style Dictionary's own CLI means by \"Must be\n        // defined in the config\".\n        const defined = Object.keys(sd.platforms)\n        const unknown = selectedPlatforms.filter(\n          (name) => !defined.includes(name),\n        )\n        if (unknown.length > 0) {\n          throw new Error(\n            `${describeConfig(item, index)} does not define the platform(s) ${unknown.join(', ')}. It defines ${defined.join(', ')}.`,\n          )\n        }\n\n        // One after another, matching the loop this sits inside: two\n        // platforms may name the same destination, and `buildAllPlatforms`\n        // fanning its own out with `Promise.all` is Style Dictionary's\n        // choice over configurations it owns, not this plugin's over a\n        // selection a consumer wrote.\n        for (const name of selectedPlatforms) {\n          await sd.buildPlatform(name)\n        }\n      }\n\n      // Every declared platform, not only the ones this compile built. A\n      // file an unselected platform wrote on an earlier build is still the\n      // plugin's own output, and dropping it from this set would let a\n      // watcher treat it as a token source and rebuild on it forever.\n      //\n      // Collected on every build rather than only on the ones whose size\n      // report prints it below. The set is also what keeps a rebuild from\n      // being triggered by the write it just made, and a rebuild passes a\n      // `context` — so gating the collection on `!context` left it empty on\n      // exactly the builds a watcher is live for.\n      //\n      // Named by `writtenDestination`, the one place that knows where Style\n      // Dictionary writes a file. Every copy of that rule this code has had\n      // named files that were never written — against `root` until #362, and\n      // an absolute destination until #367 — and handed them to `onBuildEnd`,\n      // the size report and this very set.\n      for (const platform of Object.values(sd.platforms)) {\n        for (const file of platform.files ?? []) {\n          if (file.destination) {\n            generatedFiles.add(\n              writtenDestination(platform.buildPath, file.destination),\n            )\n          }\n        }\n      }\n\n      // Recorded only now, so a configuration whose build threw is never\n      // treated as one this process has compiled.\n      const fingerprint = configFingerprint(root, item)\n      if (fingerprint !== null) compiledFingerprints.add(fingerprint)\n    }\n\n    // Replaced wholesale rather than added to, so a destination dropped from\n    // a configuration stops being treated as ours and becomes watchable\n    // again. A build that throws never reaches this and leaves the previous\n    // set standing, which is the safe direction: the files it wrote before\n    // failing are still ours.\n    generatedDestinations.clear()\n    for (const destination of generatedFiles) {\n      generatedDestinations.add(destination.replace(/\\\\/g, '/'))\n    }\n  } catch (err) {\n    const duration = Date.now() - startTime\n    log(`Compilation failed after ${duration}ms: ${errorMessage(err)}`, 'error')\n\n    // Ahead of the throw decision on purpose, so the overlay sees a failure\n    // whatever `failOnError` does with it. Under the dev server's default\n    // the line below does not throw, and reading the outcome from a caller's\n    // `catch` would see a rebuild that looked like it succeeded.\n    notifyBuildOutcome(asError(err))\n\n    // Ahead of the throw decision for the same reason as the line above: a\n    // rebuild under the dev server's default does not throw, and a hook that\n    // only fired when something else was about to fail would be silent on\n    // exactly the builds a consumer is watching.\n    if (onBuildError) callHook(log, 'onBuildError', onBuildError, err)\n\n    // Reported, and then rethrown so the host stops. Swallowing it left\n    // every target exiting 0 with the previous run's tokens still on disk\n    // and in the bundle — a green build shipping stale values.\n    if (failsTheBuild(failOnError, context)) throw err\n\n    // Explicit, now that the reporting below sits outside the `try`. This\n    // `catch` used to end the function by falling off the end of it; a\n    // failure that is not rethrown would otherwise carry on to announce a\n    // compile that did not happen.\n    return\n  }\n\n  // The compile is what the overlay reflects, so this is said here rather\n  // than at the end: everything below is reporting, it returns early in\n  // three places, and a size table that throws must not leave a successful\n  // build looking unfinished.\n  notifyBuildOutcome(null)\n\n  // One measurement, read by the hook below and by the reporting under it.\n  const duration = Date.now() - startTime\n\n  // Beside the overlay notification, and for the same reason it sits here\n  // rather than at the end of the function: the reporting below returns\n  // early in three places, and a build that finished has finished whether or\n  // not a size table gets printed for it.\n  //\n  // Sorted, so two runs of one configuration hand back the same order —\n  // `generatedFiles` is a set in platform-then-file order, which is stable\n  // in practice and guaranteed by nothing. The paths stay platform-native:\n  // this is a list a consumer is going to open files with, not one the\n  // watcher compares against.\n  if (onBuildEnd) {\n    // `toSorted` is what the linter asks for and what this cannot use:\n    // `lib` is ES2022 here and `toSorted` is ES2023, so it types as an error\n    // even though every Node this package supports has it. The rule guards\n    // against mutating an array someone else holds, and this one was built\n    // from the set on the line it appears on.\n    // oxlint-disable-next-line unicorn/no-array-sort\n    const files = Array.from(generatedFiles).sort((left, right) =>\n      left.localeCompare(right),\n    )\n    callHook(log, 'onBuildEnd', onBuildEnd, files, duration)\n  }\n\n  // The `try` ends above, and everything from here down is reporting. Style\n  // Dictionary has finished writing by now and `generatedDestinations` is\n  // already replaced, so nothing below can put a file on disk in doubt —\n  // which is why a throw from it must not be caught as a compile failure.\n  // It used to be: a fault in the padding arithmetic printed `Compilation\n  // failed after 19ms` over a build whose every token file was correct, and\n  // with `failOnError` defaulting to `'build'` that stopped the bundler.\n\n  // Every configuration was already current, so nothing was written. Said\n  // rather than left implied: a build that prints its opening line and then\n  // finishes in two milliseconds reads as one that silently did nothing.\n  const everythingSkipped = skipped === resolvedConfigs.length\n\n  if (context) {\n    log(\n      everythingSkipped\n        ? `Design tokens already up to date after change in ${context} (${duration}ms)`\n        : `Rebuilt design tokens due to change in ${context} (${duration}ms)`,\n      'success',\n    )\n    return\n  }\n\n  // The table is skipped when nothing was written, on top of `report` and\n  // `quiet`. It reads every generated file in full and gzips it, and\n  // reprinting the sizes of files this build did not touch is the one case\n  // where that cost buys nothing at all.\n  if (report && !quiet && !everythingSkipped && generatedFiles.size > 0) {\n    try {\n      reportSizes({ root, stdoutColour }, generatedFiles)\n    } catch (err) {\n      // At `'error'`, so it is said at every level including `silent`,\n      // exactly as a compile failure is — and worded so it cannot be read\n      // as one. Not rethrown: the build succeeded.\n      log(\n        `Failed to report generated file sizes: ${errorMessage(err)}`,\n        'error',\n      )\n    }\n  }\n\n  if (everythingSkipped) {\n    log(`Design tokens are already up to date (${duration}ms)`, 'success')\n    return\n  }\n\n  log(\n    skipped > 0\n      ? `Compiled successfully! (${duration}ms, ${skipped} already up to date)`\n      : `Compiled successfully! (${duration}ms)`,\n    'success',\n  )\n}\n\n// Runs one of the consumer's `onBuild*` hooks without letting it decide the\n// fate of the build that called it.\n//\n// Two ways a hook can go wrong, and neither may propagate. A throw is caught\n// here, because a post-processing step that fails must not undo a compile the\n// plugin itself completed — the files are written and correct. A rejected\n// promise is the quieter one: the return value is deliberately not awaited,\n// so a rejection has nothing holding it and reaches the host as an unhandled\n// rejection, which under Node's default takes the process down — a dev server\n// killed from inside a hook that was only meant to reformat a file.\n//\n// Both are reported at `'error'`, so they are said at every level including\n// `silent`, and worded so neither can be read as the compile having failed.\nfunction callHook<A extends unknown[]>(\n  log: PluginInstance['log'],\n  name: string,\n  hook: (...args: A) => Promise<void> | void,\n  ...args: A\n): void {\n  let result: unknown\n\n  try {\n    // Captured rather than dropped, because the promise an `async` hook\n    // returns is the thing the check below needs. Wrapping this call in a\n    // block-bodied arrow — which is what the linter asks for when the return\n    // type is plain `void` — discarded it, and the rejection escaped exactly\n    // as it had before any of this existed.\n    result = hook(...args)\n  } catch (err) {\n    log(`The ${name} hook threw: ${errorMessage(err)}`, 'error')\n    return\n  }\n\n  if (!isThenable(result)) return\n\n  void Promise.resolve(result).catch((err: unknown) => {\n    log(`The ${name} hook rejected: ${errorMessage(err)}`, 'error')\n  })\n}\n\n// Whether a failure in this compile should be thrown rather than only\n// reported. The two compiles are told apart by `runBuilds`'s `context`,\n// which only the rebuild paths pass.\nfunction failsTheBuild(\n  failOnError: NonNullable<UnpluginStyleDictionaryOptions['failOnError']>,\n  context: string | undefined,\n): boolean {\n  return (\n    failOnError === true ||\n    (context === undefined ? failOnError === 'build' : failOnError === 'serve')\n  )\n}\n\n// A hook is the consumer's code, and what it hands back is not this plugin's to\n// assume. A predicate rather than `instanceof Promise`, which answers `false`\n// for a thenable from another realm or from a promise library — exactly the\n// case where letting a rejection escape does the damage.\nfunction isThenable(value: unknown): value is PromiseLike<unknown> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'then' in value &&\n    typeof value.then === 'function'\n  )\n}\n\n// Which platforms this compile covers, or `undefined` for all of them.\n//\n// The array form applies to every build; the object form splits the first\n// compile from the watch rebuilds, and `context` is what tells them apart —\n// only the rebuild paths pass one. An absent key means every platform, so\n// `{ watch: ['css'] }` builds everything once and then only css.\nfunction platformsFor(\n  platformsOption: UnpluginStyleDictionaryOptions['platforms'],\n  context: string | undefined,\n): string[] | undefined {\n  if (platformsOption === undefined) return undefined\n  if (Array.isArray(platformsOption)) return platformsOption\n\n  return context === undefined ? platformsOption.build : platformsOption.watch\n}\n"],"mappings":"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"}

package/dist/config.js

@@ -0,0 +1,113 @@
+import { errorMessage } from "./errors.js";
+import fs from "node:fs";
+import path from "node:path";
+import JSON5 from "json5";
+import { pathToFileURL } from "node:url";
+//#region src/config.ts
+const IMPORTED_CONFIG_EXTENSIONS = [
+	".js",
+	".mjs",
+	".ts"
+];
+async function configForBuild(item) {
+	const { config } = item;
+	if (typeof config !== "string" || !isImportedConfig(config)) return config;
+	const loaded = await readConfigObject(item);
+	if (!loaded) return item.config;
+	try {
+		return structuredClone(loaded);
+	} catch {
+		return loaded;
+	}
+}
+function describeConfig(item, index) {
+	return item.file ? `The configuration ${item.file}` : `The configuration at position ${index + 1}`;
+}
+async function readConfigObject(item, report) {
+	if (typeof item.config !== "string") return item.config;
+	try {
+		const loaded = isImportedConfig(item.config) ? await importConfigModule(item.config) : JSON5.parse(fs.readFileSync(item.config, "utf-8"));
+		if (isConfig(loaded)) return loaded;
+		if (report) report(`Config file did not resolve to a configuration object: ${item.config}`, "error");
+	} catch (err) {
+		if (report) report(`Failed to parse config file: ${item.config}. Error: ${errorMessage(err)}`, "error");
+	}
+	return null;
+}
+async function resolveConfigOption({ config, configContext, discovery, log, root }) {
+	let rawConfig = config;
+	if (rawConfig === false) return [];
+	if (!rawConfig) {
+		const defaults = [
+			"sd.config.json",
+			"config.json",
+			"sd.config.js",
+			"sd.config.mjs"
+		];
+		const rejected = [];
+		for (const file of defaults) {
+			const fullPath = path.resolve(root, file);
+			if (!fs.existsSync(fullPath)) continue;
+			if (!looksLikeConfig(await readConfigObject({
+				config: fullPath,
+				file: fullPath
+			}))) {
+				rejected.push(file);
+				continue;
+			}
+			if (!discovery.announced) {
+				discovery.announced = true;
+				log(`Using the configuration it found at ${fullPath}`, "info");
+			}
+			rawConfig = file;
+			break;
+		}
+		if (rejected.length > 0) log(`Ignored ${rejected.join(", ")} in ${root}: nothing there declares platforms, source, include or tokens, so it does not look like a Style Dictionary configuration. Name it with the config option if it is one, or set config to false to stop looking.`, "error");
+	}
+	if (!rawConfig) {
+		log("No configuration specified and no default config file found. Style Dictionary will not compile.", "error");
+		return [];
+	}
+	if (typeof rawConfig === "function") rawConfig = await rawConfig(configContext());
+	return (Array.isArray(rawConfig) ? rawConfig : [rawConfig]).map((conf) => {
+		if (typeof conf === "string") {
+			const fullPath = path.resolve(root, conf);
+			return {
+				config: fullPath,
+				file: fullPath
+			};
+		} else return { config: conf };
+	});
+}
+async function importConfigModule(file) {
+	let version;
+	try {
+		version = fs.statSync(file).mtimeMs;
+	} catch {
+		version = Date.now();
+	}
+	const key = String(version).replace(".", "_");
+	return unwrapDefault(await import(`${pathToFileURL(file).href}?t=${key}`));
+}
+function isConfig(value) {
+	return typeof value === "object" && value !== null;
+}
+function isImportedConfig(file) {
+	return IMPORTED_CONFIG_EXTENSIONS.some((extension) => file.endsWith(extension));
+}
+function looksLikeConfig(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return [
+		"include",
+		"platforms",
+		"source",
+		"tokens"
+	].some((key) => key in value);
+}
+function unwrapDefault(value) {
+	return typeof value === "object" && value !== null && "default" in value ? value.default ?? value : value;
+}
+//#endregion
+export { configForBuild, describeConfig, readConfigObject, resolveConfigOption };
+
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":[],"sources":["../src/config.ts"],"sourcesContent":["// Where a configuration comes from and what it says: the `config` option\n// resolved into a list, each item read as an object, and the form Style\n// Dictionary is handed to build from.\n//\n// Nothing here holds state. One module serves every plugin instance in the\n// process, so what an instance owns — its root, its logger, whether it has\n// announced a discovery yet — is handed in on each call.\n\nimport type { Config } from 'style-dictionary'\n\nimport JSON5 from 'json5'\nimport fs from 'node:fs'\nimport path from 'node:path'\nimport { pathToFileURL } from 'node:url'\n\nimport type {\n  StyleDictionaryConfigContext,\n  UnpluginStyleDictionaryOptions,\n} from './types.js'\n\nimport { errorMessage } from './errors.js'\n\n// The plugin's logger, narrowed to the two levels anything here reports at. It\n// is handed on as a function rather than as the host it writes to, so it goes\n// on reading whichever host has claimed the plugin's messages by the time it\n// is called.\nexport type Log = (message: string, type: 'error' | 'info') => void\n\n// A configuration as `resolveConfigOption` hands it on: either the object the\n// consumer passed or the path it was read from, plus the directory relative\n// paths inside it resolve against.\nexport interface ResolvedConfig {\n  config: Config | string\n  file?: string\n}\n\n// The config extensions Style Dictionary loads with `import` rather than by\n// parsing the file — the `case` list in its own `loadFile`. They are the only\n// ones Node's permanent module cache applies to, and so the only ones this\n// plugin has to read on the build's behalf.\n//\n// Everything else Style Dictionary parses as JSON5, including `.json`, and\n// this list is what makes the plugin split the same way. Reading the two\n// halves apart is what silently unwatched a whole family of configurations:\n// a `.json5` or `.jsonc` file went down the import branch and failed there\n// while the build succeeded, and a `.json` file carrying a comment or a\n// trailing comma failed strict `JSON.parse` for the same reason.\nconst IMPORTED_CONFIG_EXTENSIONS = ['.js', '.mjs', '.ts']\n\n// What `new StyleDictionary` is handed for an item. Only a path in the JS\n// family becomes an object, because those are exactly the extensions Style\n// Dictionary's own `loadFile` reaches with `import` — the ones whose module\n// record Node then caches forever, and so the only ones a build could read\n// stale. The JSON5 family stays a path because there is nothing to gain:\n// those are read from disk on every pass either way, so a build can never\n// see one as it stood earlier in the process.\nexport async function configForBuild(\n  item: ResolvedConfig,\n): Promise<Config | string> {\n  const { config } = item\n\n  if (typeof config !== 'string' || !isImportedConfig(config)) return config\n\n  const loaded = await readConfigObject(item)\n\n  // A config that could not be read falls back to the path, so the failure\n  // stays Style Dictionary's to report — it knows more about why an import\n  // failed than this does, a `.ts` config without type stripping especially.\n  if (!loaded) return item.config\n\n  // `loadFile` clones what it imports before handing it on, and passing an\n  // object skips that. It matters more here than it does there: the module\n  // record now outlives the build, and `extend` is called with\n  // `mutateOriginal`. Cloning throws on a config carrying functions — an\n  // inline transform — and Style Dictionary's own fallback in that case is\n  // to use the original, so this one matches it.\n  try {\n    return structuredClone(loaded)\n  } catch {\n    return loaded\n  }\n}\n\n// How to name a configuration in a message. A path is what a consumer\n// recognises; a configuration passed as an object or returned by a function has\n// no name, so it is identified by where it sits in the list rather than by a\n// stringified dump of itself.\nexport function describeConfig(item: ResolvedConfig, index: number): string {\n  return item.file\n    ? `The configuration ${item.file}`\n    : `The configuration at position ${index + 1}`\n}\n\n// What a configuration item says, as an object. `report` is where a failure is\n// said, and leaving it out is what stops the two readers of this from saying\n// the same thing twice: a bad config has nowhere else to surface when the\n// watch list is being built, while a build falls back to handing Style\n// Dictionary the path and lets its message through instead.\nexport async function readConfigObject(\n  item: ResolvedConfig,\n  report?: Log,\n): Promise<Config | null> {\n  if (typeof item.config !== 'string') return item.config\n\n  try {\n    // JSON5 rather than `JSON.parse`, because that is what Style Dictionary\n    // reads these files with — it is a superset, so a plain `.json` config\n    // parses identically and one carrying a comment stops being a config\n    // the build understands and the watch list does not.\n    const loaded: unknown = isImportedConfig(item.config)\n      ? await importConfigModule(item.config)\n      : JSON5.parse(fs.readFileSync(item.config, 'utf-8'))\n\n    if (isConfig(loaded)) return loaded\n\n    if (report) {\n      report(\n        `Config file did not resolve to a configuration object: ${item.config}`,\n        'error',\n      )\n    }\n  } catch (err) {\n    if (report) {\n      report(\n        `Failed to parse config file: ${item.config}. Error: ${errorMessage(err)}`,\n        'error',\n      )\n    }\n  }\n\n  return null\n}\n\n// Resolve config file paths / objects\n//\n// Everything a plugin instance owns arrives as an argument, and none of it is\n// kept. `root` is read by the caller on each call because the host assigns it\n// after the factory has run, and `configContext` is a function rather than a\n// value for the same reason: it is asked only once a consumer's `config`\n// function is about to run.\nexport async function resolveConfigOption({\n  config,\n  configContext,\n  discovery,\n  log,\n  root,\n}: {\n  config: UnpluginStyleDictionaryOptions['config']\n  configContext: () => StyleDictionaryConfigContext\n  discovery: { announced: boolean }\n  log: Log\n  root: string\n}): Promise<ResolvedConfig[]> {\n  let rawConfig = config\n\n  // Checked ahead of the discovery below, and by identity rather than\n  // truthiness: `false` is falsy, so the `!rawConfig` test that triggers\n  // discovery would treat \"do not discover anything\" as \"go and look\".\n  if (rawConfig === false) return []\n\n  // If config is not defined, look for default configuration files\n  if (!rawConfig) {\n    const defaults = [\n      'sd.config.json',\n      'config.json',\n      'sd.config.js',\n      'sd.config.mjs',\n    ]\n\n    const rejected: string[] = []\n\n    for (const file of defaults) {\n      const fullPath = path.resolve(root, file)\n      if (!fs.existsSync(fullPath)) continue\n\n      // Read before adopting. For the two `.json` names this is a parse and\n      // nothing more; for the two module names it is an import, and the\n      // module has already run by the time there is anything to check —\n      // which is what `config: false` exists for and why validation alone\n      // does not cover them.\n      const candidate = await readConfigObject({\n        config: fullPath,\n        file: fullPath,\n      })\n\n      if (!looksLikeConfig(candidate)) {\n        rejected.push(file)\n        continue\n      }\n\n      // Announced, because \"which configuration did it pick\" was not\n      // answerable from the console at all, and discovery picks from four\n      // generic names.\n      if (!discovery.announced) {\n        discovery.announced = true\n        log(`Using the configuration it found at ${fullPath}`, 'info')\n      }\n\n      rawConfig = file\n      break\n    }\n\n    // Said whether or not something usable turned up after them. A skipped\n    // candidate is the interesting half of \"no configuration found\": the\n    // file is right there, and the reason it was not used is not guessable.\n    if (rejected.length > 0) {\n      log(\n        `Ignored ${rejected.join(', ')} in ${root}: nothing there declares platforms, source, include or tokens, so it does not look like a Style Dictionary configuration. Name it with the config option if it is one, or set config to false to stop looking.`,\n        'error',\n      )\n    }\n  }\n\n  if (!rawConfig) {\n    log(\n      'No configuration specified and no default config file found. Style Dictionary will not compile.',\n      'error',\n    )\n    return []\n  }\n\n  // Evaluate function if provided\n  if (typeof rawConfig === 'function') {\n    rawConfig = await rawConfig(configContext())\n  }\n\n  const configs = Array.isArray(rawConfig) ? rawConfig : [rawConfig]\n\n  return configs.map((conf) => {\n    if (typeof conf === 'string') {\n      const fullPath = path.resolve(root, conf)\n      return { config: fullPath, file: fullPath }\n    } else {\n      return { config: conf }\n    }\n  })\n}\n\n// Imports a config module, re-evaluating it only when the file itself has\n// changed. The query string is what decides that, and it is not decoration:\n// Node's ESM cache is permanent and keyed on the specifier, so a config\n// imported without one is evaluated once and never read again — which is\n// how an edited `.mjs` config went on building the platform map the process\n// started with, for the rest of the session.\n//\n// `Date.now()` fixed that staleness and bought two problems. Every watcher\n// event registered another module record in a map nothing prunes, re-running\n// the config's own `registerFormat` side effects for a file nobody touched.\n// And its millisecond granularity meant an edit landing inside the same\n// millisecond as the previous import shared that import's key, and was\n// served the old module anyway. `mtimeMs` carries sub-millisecond\n// resolution and only moves when the file does.\nasync function importConfigModule(file: string): Promise<unknown> {\n  let version: number\n  try {\n    version = fs.statSync(file).mtimeMs\n  } catch {\n    // A config that cannot be stat'd is about to fail its import too. The\n    // old key is what keeps that failure the import's to report.\n    version = Date.now()\n  }\n\n  // The dot goes, and that is not cosmetic. `mtimeMs` is fractional, so the\n  // query it produces ends in something that reads as a file extension to\n  // anything deriving a loader from the specifier without stripping the\n  // query first — `sd.config.ts?t=1789565080284.6606` is then a `.6606`\n  // file, and a TypeScript config gets parsed as JavaScript. Replacing the\n  // one dot keeps every distinct mtime a distinct key.\n  const key = String(version).replace('.', '_')\n\n  // Sequential on purpose: a config module runs arbitrary code at import\n  // time — `registerFormat` and friends — and Style Dictionary's registries\n  // are global, so importing several at once would interleave those\n  // registrations.\n  return unwrapDefault(await import(`${pathToFileURL(file).href}?t=${key}`))\n}\n\n// A config file is an untyped boundary: `JSON.parse` and a dynamic `import`\n// both hand back `any`, and an `any` assigned to `configObj` spreads through\n// every read of it downstream. These two narrow that boundary once, here.\n// They are type predicates rather than assertions on purpose — a predicate is\n// a check the compiler verifies, where a cast is only a claim.\nfunction isConfig(value: unknown): value is Config {\n  return typeof value === 'object' && value !== null\n}\n\n// Whether a config path is one Style Dictionary imports rather than parses.\nfunction isImportedConfig(file: string): boolean {\n  return IMPORTED_CONFIG_EXTENSIONS.some((extension) =>\n    file.endsWith(extension),\n  )\n}\n\n// Whether a discovered file looks like a Style Dictionary configuration at all.\n//\n// Only applied to a file the plugin went looking for, never to one a consumer\n// named: an explicit `config` is their choice and second-guessing it would\n// reject shapes Style Dictionary accepts and this does not know about.\n//\n// `config.json` is an extremely common name for something else entirely, and\n// the plugin used to adopt whatever it found under that name, add it to the\n// watch set, and report a successful compile over it.\nfunction looksLikeConfig(value: unknown): boolean {\n  if (typeof value !== 'object' || value === null) return false\n\n  // The four keys any usable configuration has at least one of. `platforms`\n  // alone is enough because a configuration can declare its tokens inline\n  // under `tokens`, or read them through `source`/`include`.\n  return ['include', 'platforms', 'source', 'tokens'].some(\n    (key) => key in value,\n  )\n}\n\n// A config module may expose its config as a `default` export or as the\n// namespace itself. `'default' in value` is what lets the compiler reach\n// `.default` without a cast.\nfunction unwrapDefault(value: unknown): unknown {\n  return typeof value === 'object' && value !== null && 'default' in value\n    ? (value.default ?? value)\n    : value\n}\n"],"mappings":"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"}

package/dist/errors.js

@@ -0,0 +1,11 @@
+//#region src/errors.ts
+function asError(error) {
+	return error instanceof Error ? error : new Error(errorMessage(error));
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { asError, errorMessage };
+
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["// A rejected promise must carry an Error, and `catch` binds `unknown`. What\n// Style Dictionary throws is already one; anything else is wrapped rather than\n// handed on raw.\nexport function asError(error: unknown): Error {\n  return error instanceof Error ? error : new Error(errorMessage(error))\n}\n\n// `catch` binds `unknown`, and a thrown non-Error — a string, a rejected\n// value out of a config module — carries no `.message`. The `as Error` casts\n// this replaces claimed otherwise and printed `undefined` for exactly those\n// cases, which is the least useful thing a failure log can say.\nexport function errorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error)\n}\n"],"mappings":";AAGA,SAAgB,QAAQ,OAAuB;CAC7C,OAAO,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,aAAa,KAAK,CAAC;AACvE;AAMA,SAAgB,aAAa,OAAwB;CACnD,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D"}