@kanso-labs/unplugin-style-dictionary 0.10.12 → 0.10.14

package/README.md

@@ -25,8 +25,9 @@ them.
   bullet follows it rather than standing beside it.
 - **Automatic watching**: Reads the `source` and `include` patterns from your
   Style Dictionary configurations and watches the files they match, including a
-  token package resolved through `node_modules` in a workspace. What a change
-  then triggers depends on the target — see
+  token package resolved through `node_modules` in a workspace — except under
+  `vite build --watch` on Vite 8, whose build watcher is rolldown's. What a
+  change then triggers depends on the target — see
   [Watching, per target](#watching-per-target).
 - **Config flexibility**: Supports file paths (JSON, JSON5, JSONC, JS, MJS, TS),
   configuration objects, or functions — including registering custom formats at
@@ -35,8 +36,16 @@ them.
   the error overlay rather than only to the terminal, and cleared on the next
   one that succeeds.
 - **Atomic writes**: Every generated file is written to a temporary sibling and
-  renamed into place, so code importing a token file while it is being rebuilt
-  never reads a half-written file.
+  renamed into place, and so is every asset the `copy_assets` and
+  `android/copyImages` actions copy, so code reading one while it is being
+  rebuilt never sees it half-written. A file whose contents have not changed is
+  left alone. A custom action gets the same through `vol.promises.writeFile`,
+  `vol.writeFileSync`, `vol.promises.copyFile`, `vol.copyFileSync` and
+  `vol.promises.cp`; anything else it writes with, such as `appendFile` or a
+  write stream, writes in place. A destination that is a symbolic link is
+  written through to the file it points at, and a replaced file keeps its mode.
+  A hard-linked destination is replaced rather than updated, so the other link
+  keeps the old contents.
 - **Multi-configuration**: Can run multiple Style Dictionary configurations in
   one build (useful for multi-brand or multi-theme projects). They are compiled
   one after another on purpose, so two configurations may safely write to the
@@ -165,9 +174,10 @@ so which configuration a build used is answerable from the console.
 it, so a project relying on that default keeps working.
 
 **Two of the four names are modules, and reading a module runs it.** A root
-`sd.config.js` is imported — freshly, on every watch event — and validation
-cannot prevent that, because the check can only look at what the import
-returned. If you name your configuration explicitly, or have none, say so:
+`sd.config.js` is imported when it is first read, and again whenever it changes,
+and validation cannot prevent that, because the check can only look at what the
+import returned. If you name your configuration explicitly, or have none, say
+so:
 
 ```typescript
 StyleDictionary({ config: false })
@@ -335,13 +345,14 @@ Every target compiles tokens before the build that consumes them. What a later
 change to a token file triggers is not the same everywhere, because it depends
 on what the host bundler does with the watch list the plugin registers.
 
-| Target       | Compiles before the build | Rebuilds on a token change     | Safe from rebuild loops |
-| ------------ | ------------------------- | ------------------------------ | ----------------------- |
-| **Vite**     | yes                       | yes, under the dev server      | yes                     |
-| **Rollup**   | yes                       | yes, under `rollup --watch`    | yes                     |
-| **Webpack**  | yes                       | yes, under `webpack --watch`   | yes                     |
-| **Rspack**   | yes                       | yes, under `rspack --watch`    | yes                     |
-| **Rolldown** | yes                       | platform-dependent — see below | yes                     |
+| Target                    | Compiles before the build | Rebuilds on a token change        | Safe from rebuild loops |
+| ------------------------- | ------------------------- | --------------------------------- | ----------------------- |
+| **Vite**                  | yes                       | yes, under the dev server         | yes                     |
+| **Vite**, `build --watch` | yes                       | yes on 6 and 7; on 8, as Rolldown | yes                     |
+| **Rollup**                | yes                       | yes, under `rollup --watch`       | yes                     |
+| **Webpack**               | yes                       | yes, under `webpack --watch`      | yes                     |
+| **Rspack**                | yes                       | yes, under `rspack --watch`       | yes                     |
+| **Rolldown**              | yes                       | platform-dependent — see below    | yes                     |
 
 Patterns and literal paths behave the same way wherever rebuilds happen at all.
 A `source` of `tokens/**/*.json` matches a file sitting directly in `tokens/` as
@@ -365,9 +376,15 @@ the files it registers, by name, on Vite 6, 7 and 8. The rest of `node_modules`
 stays ignored, which matters: handing the whole dependency tree to the watcher
 is thousands of files no token build reads.
 
+`vite build --watch` had the same problem and gets the same fix on Vite 6 and 7,
+which build on rollup's watcher and its chokidar ignore list: the plugin appends
+the same negations to `build.watch.chokidar.ignored`. Vite 8 builds with
+rolldown, which takes no ignore list from there, so what the Rolldown note above
+says holds for it too.
+
 Nothing is needed from you for that. If you had worked around it with a
-`server.watch.ignored` negation of your own, it still works — the plugin appends
-to your list rather than replacing it.
+`server.watch.ignored` or `build.watch.chokidar.ignored` negation of your own,
+it still works — the plugin appends to your list rather than replacing it.
 
 "Safe from rebuild loops" is worth stating because consuming code imports the
 generated file, so every regenerate is itself a change the host reacts to. The
@@ -429,26 +446,46 @@ after dropping `legacy.scss` from a configuration, a clean run left
 
 ## Skipping a Build That Would Change Nothing
 
-A configuration whose output is already newer than everything it reads is not
+A configuration whose output already reflects everything it reads is not
 compiled again. `buildAllPlatforms` is around 80% of a build, and under Vite it
 runs inside `server.listen()` — so without this the dev server refused
 connections for the length of a compile whether or not a token had changed.
 
 Three things are compared: every file the configuration reads (its `source` and
 `include` matches, its own config file, and anything named by `watch`), every
-file it declares, and — for a configuration that is not a file — what the
-configuration looked like when those files were written.
+file it declares, and the configuration that last wrote them. That last one
+covers more than the configuration's own contents. It includes the hooks the
+configuration names — each `format`, `filter`, `fileHeader`, transform,
+transform group, parser and preprocessor it refers to by name — as Style
+Dictionary's registry holds them, and the Style Dictionary version. So a new
+body registered under a name it uses, which is what editing the
+[Custom Formats](#custom-formats) pattern does, rebuilds even though no file
+moved, and so does an upgrade.
+
+Once a configuration has been compiled, the files it reads are compared against
+what that compile saw before it started reading. A token saved while a rebuild
+is compiling is newer than that, so the rebuild queued for it runs, even though
+the output the rebuild went on to write is newer still. The record of what each
+compile read is kept in `node_modules/.cache/unplugin-style-dictionary`, beside
+the nearest `package.json`, so it survives a restart. Where there is no record,
+the files a configuration reads are compared against the files it declares.
+
+A declared file that changed since the compile that wrote it is compiled over
+rather than trusted, whatever its mtime says. Generated output is disposable, so
+an edit made to it by hand does not survive the next build.
 
 Two cases never skip, because neither can be settled from the filesystem:
 
-| Case                                                                                 | Why                                                                                                                                                                                                                                   |
-| ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| The first compile of a process, for a configuration given as an object or a function | There is no config file to stat, so an edit to the object inside `vite.config.ts` moves no mtime. Within one process the resolved configuration is compared against the one last built; across processes there is nothing to compare. |
-| A platform declaring `actions`                                                       | An action writes what no `destination` names, so a skip would leave its work undone.                                                                                                                                                  |
+| Case                                                                                 | Why                                                                                                                                                                                                                                                                                                                                |
+| ------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| The first compile of a process, for a configuration given as an object or a function | There is no config file to stat, so an edit to the object inside `vite.config.ts` moves no mtime. Within one process the resolved configuration is compared against the one last built. An earlier process's record is not trusted for it, because its functions are compared by their source and what they close over can differ. |
+| A platform declaring `actions`                                                       | An action writes what no `destination` names, so a skip would leave its work undone.                                                                                                                                                                                                                                               |
 
-A custom format that reads something off-disk — an environment variable, a
-network call — cannot be detected this way either. Set `cache: false` where that
-is the case, and every build runs.
+A hook's own code is compared, but not what it calls from another module. Name
+that module in `watch` and an edit to it rebuilds on the next start. A custom
+format that reads something off-disk — an environment variable, a network call —
+cannot be detected this way either. Set `cache: false` where that is the case,
+and every build runs.
 
 ## One Compile per Process
 
@@ -517,8 +554,10 @@ StyleDictionary({
 ```
 
 `'warn'` is the level worth knowing about: Style Dictionary's warnings without
-the plugin's own progress lines and size table. `silent: true` is an alias for
-`'silent'`.
+the plugin's own progress lines and size table. Style Dictionary's own lines
+stay — the platform name and the `✔︎` for each file it wrote — because `'warn'`
+leaves its verbosity at the default, and only `'silent'` quiets them.
+`silent: true` is an alias for `'silent'`.
 
 A compile that fails is reported at every level, including `'silent'`, which is
 why there is no `'error'`. `log.warnings` is never touched: if your
@@ -529,12 +568,12 @@ configuration turns a warning into a thrown build, that stays your decision.
 Through your bundler, not straight to the console, and each one takes them its
 own way:
 
-| Target             | Progress lines           | A failed compile                   |
-| ------------------ | ------------------------ | ---------------------------------- |
-| Vite               | `config.logger.info`     | `config.logger.error`              |
-| Rollup, Rolldown   | the plugin context's log | the context's warning channel      |
-| Webpack, Rspack    | the console              | `compilation.warnings`, so `stats` |
-| No host (one-shot) | the console              | the console                        |
+| Target             | Progress lines and size table | A failed compile                   |
+| ------------------ | ----------------------------- | ---------------------------------- |
+| Vite               | `config.logger.info`          | `config.logger.error`              |
+| Rollup, Rolldown   | the plugin context's log      | the context's warning channel      |
+| Webpack, Rspack    | the console                   | `compilation.warnings`, so `stats` |
+| No host (one-shot) | the console                   | the console                        |
 
 That is what makes a `customLogger` and `clearScreen` work under Vite, and what
 puts a failed compile into `stats.toJson()` under webpack — where it reaches CI
@@ -555,9 +594,12 @@ than `compilation.errors`, so `failOnError: false` really does leave the build
 passing.
 
 **Your bundler's own log level applies.** `vite --logLevel silent` silences
-Vite's logger, and the plugin's lines are Vite's logger's now, so they go too.
-Nothing is lost by it that matters: `failOnError` decides whether a broken token
-set stops the build, and it decides that whether or not anything was printed.
+Vite's logger, and the plugin's lines are Vite's logger's now, so they go too —
+the size table included. Style Dictionary's own lines are not among them: the
+platform name and the `✔︎` for each file it wrote are its own `console` calls, so
+they still print unless the plugin's `logLevel` is `'silent'`. Nothing is lost
+by it that matters: `failOnError` decides whether a broken token set stops the
+build, and it decides that whether or not anything was printed.
 
 Colour follows the usual conventions, which it previously ignored entirely: no
 escapes when `NO_COLOR` is set, or when the stream is not a terminal, or under
@@ -632,10 +674,12 @@ StyleDictionary({
 ```
 
 `files` holds the absolute, platform-native path of every file the build
-declares, sorted. It is what the build declares rather than what it happened to
-write this time: a configuration skipped because its output was already current
-contributes its destinations too, so a post-processing step still sees the whole
-set on a rebuild that changed one file.
+declares that is on disk, sorted. It is what the build declares rather than what
+it happened to write this time: a configuration skipped because its output was
+already current contributes its destinations too, so a post-processing step
+still sees the whole set on a rebuild that changed one file. A declared file
+Style Dictionary declined to write, such as one whose filter matched no tokens,
+is left out.
 
 A rebuild is a build, so all three fire again on every watch-triggered one.
 
@@ -690,14 +734,21 @@ const plugin = styleDictionary.rollup({ config: 'sd.config.json' })
  * build (e.g. `tsdown`/`rolldown build` without `--watch`) only builds once, in
  * `buildStart`.
  *
- * Everything the plugin says goes through the host rather than to the console:
- * Vite's `config.logger`, the plugin context under rollup and rolldown, and
- * `compilation.warnings` under webpack, which is what puts a failed compile in
- * `stats.toJson()`. A failure is reported on the warning channel and never the
- * error one — rollup's `this.error` aborts the bundle, and that decision is
- * `failOnError`'s alone. Where no host offers a channel the console is used,
- * with colour gated on `NO_COLOR`, `FORCE_COLOR` and whether the stream is a
- * terminal.
+ * What the plugin says goes through the host wherever the host has a channel
+ * for it: Vite's `config.logger`, the plugin context under rollup and
+ * rolldown, and `compilation.warnings` under webpack and rspack, which is what
+ * puts a failed compile in `stats.toJson()`. The progress lines and the size
+ * table take the host's `info` channel, and webpack and rspack have none, so
+ * there both go to the console. A failure is reported on the warning channel
+ * and never the error one — rollup's `this.error` aborts the bundle, and that
+ * decision is `failOnError`'s alone. Where no host offers a channel the console
+ * is used, with colour gated on `NO_COLOR`, `FORCE_COLOR` and whether the
+ * stream is a terminal.
+ *
+ * Style Dictionary's own lines are not the plugin's. The platform name and the
+ * `✔︎` for each file it wrote are its own `console` calls, so they reach the
+ * console under every host, whatever the host's log level. `logLevel: 'silent'`
+ * quiets them, as does `log.verbosity: 'silent'` in the configuration.
  *
  * The three `onBuild*` hooks are called synchronously and their return value
  * is not awaited, so a build never waits for one. A hook may still be written
@@ -747,8 +798,8 @@ export interface StyleDictionaryConfigContext {
   /**
    * Whether the host will keep rebuilding.
    *
-   * `true` under Vite's dev server, `rollup --watch`, `rolldown.watch()` and
-   * `webpack --watch`; `false` for a one-shot build. It is read from the
+   * `true` under Vite's dev server and `vite build --watch`, `rollup --watch`,
+   * `rolldown.watch()` and `webpack --watch`; `false` for a one-shot build. It is read from the
    * host — the plugin context's `meta.watchMode` on the three rollup-shaped
    * targets, and `compiler.watchMode` on webpack — rather than inferred from
    * `command`, because `rollup --watch` both watches and builds.
@@ -765,8 +816,28 @@ export interface UnpluginStyleDictionaryOptions {
    * 4,000-token, two-platform configuration — and under Vite it runs inside
    * `server.listen()`, so the dev server does not accept a connection until
    * it finishes whether or not a token changed. A configuration is treated as
-   * up to date when every file it declares exists and is newer than every
-   * file it reads, its own config file included.
+   * up to date when every file its last compile wrote exists and is as that
+   * compile left it, and nothing it reads, its own config file included, has
+   * changed since that compile read it. A file it declares and Style
+   * Dictionary declined to write — a filter matching no tokens — does not stop
+   * it being skipped, since that file was never going to be there.
+   *
+   * "Since" means since the moment that compile began reading, so a token
+   * saved while a rebuild is compiling is rebuilt rather than taken for part
+   * of the output the rebuild went on to write. What each compile read is
+   * kept in `node_modules/.cache/unplugin-style-dictionary` beside the nearest
+   * `package.json`, so a restart still knows it. Where nothing is recorded,
+   * the files a configuration reads are compared against the files it
+   * declares instead.
+   *
+   * A compile is also recorded against the configuration that ran it: its
+   * contents, the hooks it names as Style Dictionary's registry holds them —
+   * each `format`, `filter`, `fileHeader`, transform, transform group,
+   * parser and preprocessor it refers to by name — and the Style Dictionary
+   * version. A new body registered under a name it uses, or an upgrade,
+   * rebuilds even though no file moved. What a hook's code calls from another
+   * module is not part of that code, so an edit there is not seen; naming the
+   * module in `watch` makes the next start rebuild.
    *
    * Two things are never skipped, because neither can be told from the
    * filesystem:
@@ -775,7 +846,9 @@ export interface UnpluginStyleDictionaryOptions {
    *   object or a function.** There is no config file to stat, so an edit to
    *   the object inside `vite.config.ts` moves no mtime. Within one process
    *   the resolved configuration is compared against the one that was last
-   *   built; across processes there is nothing to compare, so it builds.
+   *   built. An earlier process's record is not trusted for it, because its
+   *   functions are compared by their source and what they close over can
+   *   differ from one process to the next, so it builds.
    * - **A platform declaring `actions`.** An action writes what no
    *   `destination` names, so a skip would leave its work undone.
    *
@@ -814,8 +887,9 @@ export interface UnpluginStyleDictionaryOptions {
    *
    * **`false` turns discovery off.** Two of the four names are modules rather
    * than data, and reading a module means running it: a `sd.config.js` in the
-   * root is imported, freshly, on every watch event. Validation cannot prevent
-   * that, because the check can only look at what the import returned — so a
+   * root is imported when it is first read, and again whenever it or a file
+   * named in `watch` changes. Validation cannot prevent that, because the
+   * check can only look at what the import returned — so a
    * project that names its configuration explicitly, or has none, should say
    * `config: false` rather than rely on there being nothing to find.
    */
@@ -907,15 +981,17 @@ export interface UnpluginStyleDictionaryOptions {
   logLevel?: 'info' | 'silent' | 'verbose' | 'warn'
 
   /**
-   * Called once a build has finished, with every file it declares and how long
-   * it took in milliseconds.
+   * Called once a build has finished, with every file it declares that is on
+   * disk and how long it took in milliseconds.
    *
    * The paths are absolute and platform-native, sorted so two runs of the same
    * configuration hand back the same order. They are what the build declares
    * rather than what it wrote this time: a configuration skipped by `cache`
    * contributes its destinations too, because they are on disk and current,
    * and a post-processing step that ignored them would leave half the output
-   * untouched on a rebuild that changed one file.
+   * untouched on a rebuild that changed one file. A declared file Style
+   * Dictionary declined to write — a filter matching no tokens — is left out,
+   * since there is nothing there to open.
    *
    * This is where formatting the generated files, type-checking them, or
    * telling something else they have landed belongs.
@@ -1055,6 +1131,11 @@ export interface UnpluginStyleDictionaryOptions {
    * else, name a file here relative to the root, and in `source` relative to
    * where the build runs.
    *
+   * A configuration module is imported again when a file named here changes,
+   * so a data file it reads when it loads is picked up. A module that a
+   * configuration or a token module itself imports is evaluated once per
+   * process, though: naming it here buys a rebuild, not a re-read.
+   *
    * What a change to a watched file then triggers is the host's to decide —
    * see the interface documentation above.
    */

package/dist/compile.js

@@ -1,27 +1,42 @@
 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 { sizeTable } from "./size-report.js";
+import { configFingerprint, declaredDestinations, isUpToDate, newestSourceOf, readPersistedRecords, recordOf, recordsFileFor, writePersistedRecords, writtenDestination } from "./up-to-date.js";
+import fs from "node:fs";
+import path from "node:path";
 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 { cache, destinationRecords, failOnError, generatedDestinations, log, logTable, notifyBuildOutcome, onBuildEnd, onBuildError, onBuildStart, persistedRecordFiles, platformsOption, quiet, report, verbosity, volume, watch } = instance;
 	const root = instance.root();
 	const startTime = Date.now();
 	const generatedFiles = /* @__PURE__ */ new Set();
 	let skipped = 0;
+	let recordsFile = cache ? persistedRecordFiles.get(root) : void 0;
+	if (cache && recordsFile === void 0) {
+		recordsFile = recordsFileFor(root);
+		persistedRecordFiles.set(root, recordsFile);
+		for (const [destination, record] of readPersistedRecords(recordsFile)) if (!destinationRecords.has(destination)) destinationRecords.set(destination, record);
+	}
+	const recorded = /* @__PURE__ */ new Map();
 	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,
+			if (declared) checkSelection(item, index, selectedPlatforms, declared.platforms);
+			const newestSource = declared ? await newestSourceOf({
 				log,
 				root,
 				watch
+			}, item, declared) : null;
+			const fingerprint = declared ? configFingerprint(root, item, declared) : null;
+			if (declared && isUpToDate({
+				destinationRecords,
+				fingerprint,
+				newestSource
 			}, item, declared, selectedPlatforms)) {
 				for (const destination of declaredDestinations(declared)) generatedFiles.add(destination);
 				skipped++;
@@ -41,18 +56,25 @@ async function runBuilds(instance, resolvedConfigs, context) {
 					`Nothing was written. Set failOnError to false to build anyway.`
 				].join(" "));
 			}
-			sd.volume = volume;
+			const wrote = /* @__PURE__ */ new Set();
+			sd.volume = notingWrites(volume, wrote);
+			const writing = declaredDestinations({ platforms: sd.platforms }, selectedPlatforms);
+			for (const destination of writing) destinationRecords.delete(destination);
 			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(", ")}.`);
+				checkSelection(item, index, selectedPlatforms, sd.platforms);
 				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);
+			if (fingerprint !== null) for (const destination of writing) {
+				const record = recordOf(destination, fingerprint, newestSource, wrote.has(destination));
+				if (record) {
+					destinationRecords.set(destination, record);
+					recorded.set(destination, record);
+				}
+			}
 		}
+		if (recordsFile !== void 0 && recorded.size > 0) writePersistedRecords(recordsFile, recorded);
 		generatedDestinations.clear();
 		for (const destination of generatedFiles) generatedDestinations.add(destination.replace(/\\/g, "/"));
 	} catch (err) {
@@ -64,17 +86,17 @@ async function runBuilds(instance, resolvedConfigs, context) {
 	}
 	notifyBuildOutcome(null);
 	const duration = Date.now() - startTime;
-	if (onBuildEnd) callHook(log, "onBuildEnd", onBuildEnd, Array.from(generatedFiles).sort((left, right) => left.localeCompare(right)), duration);
+	if (onBuildEnd) callHook(log, "onBuildEnd", onBuildEnd, Array.from(generatedFiles).filter((file) => fs.existsSync(file)).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);
+		logTable((colour) => sizeTable({
+			colour,
+			root
+		}, generatedFiles));
 	} catch (err) {
 		log(`Failed to report generated file sizes: ${errorMessage(err)}`, "error");
 	}
@@ -97,12 +119,27 @@ function callHook(log, name, hook, ...args) {
 		log(`The ${name} hook rejected: ${errorMessage(err)}`, "error");
 	});
 }
+function checkSelection(item, index, selected, platforms) {
+	if (selected === void 0) return;
+	const defined = Object.keys(platforms ?? {});
+	const unknown = selected.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(", ")}.`);
+}
 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 notingWrites(volume, into) {
+	const note = (file) => {
+		if (typeof file === "string") into.add(path.resolve(file));
+	};
+	return Object.create(volume, { promises: { value: Object.create(volume.promises, { writeFile: { value: async (...args) => {
+		note(args[0]);
+		await volume.promises.writeFile(...args);
+	} } }) } });
+}
 function platformsFor(platformsOption, context) {
 	if (platformsOption === void 0) return void 0;
 	if (Array.isArray(platformsOption)) return platformsOption;

package/dist/compile.js.map

@@ -1 +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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"}
+{"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 fs from 'node:fs'\nimport path from 'node:path'\nimport StyleDictionary from 'style-dictionary'\n\nimport type { ResolvedConfig } from './config.js'\nimport type { UnpluginStyleDictionaryOptions } from './types.js'\nimport type { DestinationRecord } from './up-to-date.js'\n\nimport { configForBuild, describeConfig, readConfigObject } from './config.js'\nimport { asError, errorMessage } from './errors.js'\nimport { patternsMatchingNothing, sourcePatternsOf } from './patterns.js'\nimport { sizeTable } from './size-report.js'\nimport {\n  configFingerprint,\n  declaredDestinations,\n  isUpToDate,\n  newestSourceOf,\n  readPersistedRecords,\n  recordOf,\n  recordsFileFor,\n  writePersistedRecords,\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. `log` and `logTable` read the message host when they are called,\n// for the same reason. `generatedDestinations` is the instance's own record of what it\n// wrote, and `destinationRecords` is the process's record of which\n// configuration last wrote each file and what it read, with\n// `persistedRecordFiles` naming the file each root's copy persists to;\n// none of them lives here.\nexport interface PluginInstance {\n  cache: boolean\n  destinationRecords: Map<string, DestinationRecord>\n  failOnError: NonNullable<UnpluginStyleDictionaryOptions['failOnError']>\n  generatedDestinations: Set<string>\n  log: (message: string, type: 'error' | 'info' | 'success') => void\n  logTable: (render: (colour: boolean) => string[]) => void\n  notifyBuildOutcome: (error: Error | null) => void\n  onBuildEnd: UnpluginStyleDictionaryOptions['onBuildEnd']\n  onBuildError: UnpluginStyleDictionaryOptions['onBuildError']\n  onBuildStart: UnpluginStyleDictionaryOptions['onBuildStart']\n  persistedRecordFiles: Map<string, string>\n  platformsOption: UnpluginStyleDictionaryOptions['platforms']\n  quiet: boolean\n  report: boolean\n  root: () => string\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    destinationRecords,\n    failOnError,\n    generatedDestinations,\n    log,\n    logTable,\n    notifyBuildOutcome,\n    onBuildEnd,\n    onBuildError,\n    onBuildStart,\n    persistedRecordFiles,\n    platformsOption,\n    quiet,\n    report,\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  // The records an earlier process persisted for this root, loaded the first\n  // time this process compiles for it and never over a record this process\n  // wrote itself. Only with `cache` on, the one case that reads or keeps\n  // them: every other build compiles regardless.\n  let recordsFile = cache ? persistedRecordFiles.get(root) : undefined\n  if (cache && recordsFile === undefined) {\n    recordsFile = recordsFileFor(root)\n    persistedRecordFiles.set(root, recordsFile)\n    for (const [destination, record] of readPersistedRecords(recordsFile)) {\n      if (!destinationRecords.has(destination)) {\n        destinationRecords.set(destination, record)\n      }\n    }\n  }\n\n  // What this compile recorded, and so what it adds to the persisted copy.\n  const recorded = new Map<string, DestinationRecord>()\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      // Ahead of the up-to-date check, which judges a selection by the\n      // destinations the configuration declares for it and so cannot see a\n      // name it does not define: `['css', 'andriod']` was judged on `css`\n      // alone, and with `css` current the whole build was skipped and the typo\n      // went unreported until a source changed. The build path checks again\n      // below, for the builds that reach it without `declared`.\n      if (declared) {\n        checkSelection(item, index, selectedPlatforms, declared.platforms)\n      }\n\n      // What this configuration reads, as it stands before the compile below\n      // reads any of it. The up-to-date check needs it now, and the record\n      // needs it afterwards: it is what the next check measures \"changed\n      // since\" against. Only asked with `cache` on, the one case that reads it.\n      const newestSource = declared\n        ? await newestSourceOf({ log, root, watch }, item, declared)\n        : null\n\n      // Who this configuration is: its contents, the hooks it names as the\n      // registry holds them now, and the Style Dictionary version. Taken here,\n      // after the `config` function's `register*` calls have landed, and once:\n      // the check compares it with each destination's record, and the record\n      // keeps it. Only with `cache` on, because nothing compares it otherwise\n      // and reading a configuration module to compute it would run it again.\n      const fingerprint = declared\n        ? configFingerprint(root, item, declared)\n        : null\n\n      if (\n        declared &&\n        isUpToDate(\n          { destinationRecords, fingerprint, newestSource },\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. Seen\n      // through a layer that notes what this build writes, which the record\n      // below needs: a declared file is not necessarily a written one.\n      const wrote = new Set<string>()\n      sd.volume = notingWrites(volume, wrote)\n\n      // The files this compile is about to write, named exactly as the\n      // up-to-date check names them, and only the selected platforms' — a\n      // scoped build leaves the others' files, and whatever wrote them, alone.\n      const writing = declaredDestinations(\n        { platforms: sd.platforms },\n        selectedPlatforms,\n      )\n\n      // Forgotten before the first write rather than overwritten after the\n      // last, because a build that throws partway has already replaced some\n      // of these files. A record left standing would vouch for output that\n      // no longer matches the configuration it names.\n      for (const destination of writing) {\n        destinationRecords.delete(destination)\n      }\n\n      if (selectedPlatforms === undefined) {\n        await sd.buildAllPlatforms()\n      } else {\n        // `cache: false`, and a configuration that would not parse ahead of\n        // `extend`, arrive here without the check above having run.\n        checkSelection(item, index, selectedPlatforms, sd.platforms)\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 once for every change\n      // to it. Not a loop: a scoped rebuild never rewrites that file.\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 build that threw vouches for none of what it\n      // wrote before throwing. Every configuration is recorded, a file-backed\n      // one included: an object configuration naming the same file has to\n      // see that something else wrote it last.\n      //\n      // `newestSource` goes in beside the fingerprint. It was taken before\n      // this compile read anything, so a source saved while it ran is newer\n      // than it, and the rebuild queued for that save is not skipped. So does\n      // each file's mtime as this compile left it, byte-identical skip and\n      // all: a later check trusts the record only while the file still has\n      // it. A file Style Dictionary declined to write is recorded as such, so\n      // a later check does not go looking for it; one it wrote and that is\n      // already gone gets no record, so the next build compiles.\n      //\n      // Only a compile with `cache` on has a fingerprint to record. One with it\n      // off has still forgotten what it rewrote, above, which is what keeps\n      // every other instance from vouching for its output.\n      if (fingerprint !== null) {\n        for (const destination of writing) {\n          const record = recordOf(\n            destination,\n            fingerprint,\n            newestSource,\n            wrote.has(destination),\n          )\n          if (record) {\n            destinationRecords.set(destination, record)\n            recorded.set(destination, record)\n          }\n        }\n      }\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    // Once per compile rather than per configuration, and only after every\n    // configuration succeeded. A compile that throws persists nothing, which\n    // is safe: whatever it rewrote no longer has the mtime its old record\n    // names, so that record vouches for nothing.\n    if (recordsFile !== undefined && recorded.size > 0) {\n      writePersistedRecords(recordsFile, recorded)\n    }\n\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  //\n  // Only the declared files that are on disk. One whose filter matched no\n  // tokens is declared and never written, and a hook opening it got an ENOENT.\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    const files = Array.from(generatedFiles)\n      .filter((file) => fs.existsSync(file))\n      // oxlint-disable-next-line unicorn/no-array-sort\n      .sort((left, right) => left.localeCompare(right))\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      logTable((colour) => sizeTable({ colour, root }, 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// Throws when `selected` names a platform that `platforms` does not define.\n// Named, so a typo is an error rather than a platform silently not built —\n// which is what Style Dictionary's own CLI means by \"Must be defined in the\n// config\" — and one function, so the check ahead of the up-to-date skip and\n// the one on the build path say exactly the same thing.\nfunction checkSelection(\n  item: ResolvedConfig,\n  index: number,\n  selected: string[] | undefined,\n  platforms: Record<string, unknown> | undefined,\n): void {\n  if (selected === undefined) return\n\n  const defined = Object.keys(platforms ?? {})\n  const unknown = selected.filter((name) => !defined.includes(name))\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\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// `volume`, with every path Style Dictionary writes through it noted in\n// `into`, resolved as `writtenDestination` resolves a declared one. Each file\n// a build writes reaches `promises.writeFile` (`buildPlatform` in\n// `lib/StyleDictionary.js`) — a byte-identical one included, since the atomic\n// writer decides to skip the rename only once it has been handed the file — so\n// `into` ends up holding exactly what the build wrote, and a file it declined\n// to write never appears in it. Built per compile, over the atomic volume\n// rather than in place of it.\n//\n// The sync writer is inherited untouched. Only an action reaches it, a\n// configuration with actions is never skipped, and `tests/index.test.ts`\n// checks that an action is handed the atomic writer itself.\nfunction notingWrites(volume: typeof fs, into: Set<string>): typeof fs {\n  const note = (file: unknown) => {\n    if (typeof file === 'string') into.add(path.resolve(file))\n  }\n\n  /* oxlint-disable typescript/no-unsafe-type-assertion */\n  return Object.create(volume, {\n    promises: {\n      value: Object.create(volume.promises, {\n        writeFile: {\n          value: async (...args: Parameters<typeof fs.promises.writeFile>) => {\n            note(args[0])\n            await volume.promises.writeFile(...args)\n          },\n        },\n      }) as typeof fs.promises,\n    },\n  }) as typeof fs\n  /* oxlint-enable typescript/no-unsafe-type-assertion */\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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"}