@kanso-labs/unplugin-style-dictionary 0.6.2 → 0.8.0

package/README.md

@@ -1,5 +1,10 @@
 # unplugin-style-dictionary
 
+[![npm version][npm-version-shield]][npm]
+[![npm downloads][npm-downloads-shield]][npm]
+[![License][license-shield]][license] [![Build][build-shield]][build-workflow]
+[![Test][test-shield]][test-workflow] [![Coverage][coverage-shield]][codecov]
+
 A lightweight, robust [unplugin](https://unplugin.unjs.io/)-based plugin to
 compile **Style Dictionary** design tokens ahead of your bundler, with automatic
 watching, rebuilding, and hot reloading (HMR) under Vite's dev server.
@@ -22,6 +27,9 @@ build on Rolldown/tsdown) that both need tokens compiled ahead of them.
 - **Config flexibility**: Supports file paths (JSON, JSON5, JSONC, JS, MJS, TS),
   configuration objects, or functions — including registering custom formats at
   config-resolution time.
+- **Error overlay**: A rebuild that fails under Vite's dev server is pushed to
+  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.
@@ -186,6 +194,38 @@ source and no config file does not reach it, so a dev server editing unrelated
 project files leaves it alone — treat it as the place to prepare a build, not as
 a general file-change hook.
 
+**It is handed what the host is doing**, so the configuration it returns can
+depend on it — build an expensive platform on `vite build` and skip it while the
+dev server runs:
+
+```typescript
+styleDictionaryPlugin({
+  config: ({ command, mode, watch }) => ({
+    source: ['tokens/**/*.json'],
+    platforms: {
+      css: {
+        transformGroup: 'css',
+        buildPath: 'dist/',
+        files: [{ destination: 'vars.css', format: 'css/variables' }],
+      },
+      // Shells out to a native toolchain, so it is worth a minute of a real
+      // build and not worth a second of every rebuild.
+      ...(command === 'build' && !watch ? { ios: iosPlatform(mode) } : {}),
+    },
+  }),
+})
+```
+
+`command` is `'serve'` only under Vite's dev server; every other target builds.
+`mode` is Vite's or webpack's own, and follows `command` on rollup and rolldown,
+which have no such concept. `watch` is read from the host rather than inferred
+from `command`, because `rollup --watch` both watches and builds. The full
+contract is [`StyleDictionaryConfigContext`](#options-reference).
+
+A function taking no arguments stays valid — TypeScript accepts one of fewer
+parameters and JavaScript ignores the extra argument — so the example below
+needs no change.
+
 ```typescript
 // Named `styleDictionaryPlugin` here to avoid colliding with the `StyleDictionary`
 // class imported from the `style-dictionary` package itself, below.
@@ -350,6 +390,41 @@ 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
 configuration turns a warning into a thrown build, that stays your decision.
 
+### Where the messages go
+
+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            | 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
+annotations and anything else reading the build's own output.
+
+**A failure is reported as a warning, never on the host's error channel.**
+Rollup's `this.error` aborts the bundle, so reporting a failure through it would
+stop every build that reported one — taking the decision `failOnError` exists to
+make. The same reasoning puts webpack's report in `compilation.warnings` rather
+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.
+
+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
+`TERM=dumb`; escapes when `FORCE_COLOR` is set to anything but `0`, including on
+a non-terminal, which is what that variable is for. `NO_COLOR` wins over
+`FORCE_COLOR`. stdout and stderr are decided separately, because they are
+redirected separately.
+
 ## Failing the Build
 
 A token compile that fails stops the build. `vite build`, `rollup` and `webpack`
@@ -368,12 +443,196 @@ StyleDictionary({
 })
 ```
 
-A failure is always reported, whatever `failOnError` and `silent` are set to.
+A failure is always reported by the plugin, whatever `failOnError` and `silent`
+are set to — see [Where the messages go](#where-the-messages-go) for which
+channel it arrives on, and for the one thing that can still suppress it.
+
+Under Vite's dev server it is reported to the browser as well. A failed rebuild
+is pushed to Vite's error overlay, naming this plugin and carrying Style
+Dictionary's message, and the overlay is dismissed by the next rebuild that
+succeeds — so a page left rendering the last good token file says so instead of
+looking current. Set `errorOverlay: false` to keep the failure in the terminal
+only.
+
+`failOnError` and `errorOverlay` answer different questions and do not interact:
+the first decides whether the host stops, the second whether the browser is
+told. The dev server's default is not to stop, which is exactly when the overlay
+is the only thing that can report the failure.
+
+## Build Hooks
+
+Three optional callbacks, for work that has to happen around a compile rather
+than inside one — formatting the generated files, type-checking them, telling
+something else they have landed.
+
+```typescript
+StyleDictionary({
+  config: 'sd.config.json',
+  onBuildStart: () => console.log('compiling tokens'),
+  onBuildEnd: async (files, durationMs) => {
+    console.log(`wrote ${files.length} files in ${durationMs}ms`)
+    await formatGeneratedFiles(files)
+  },
+  onBuildError: (error) => notifySomething(error),
+})
+```
+
+`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.
+
+A rebuild is a build, so all three fire again on every watch-triggered one.
+
+**A hook cannot fail the build that called it.** The return value is not
+awaited, so nothing waits for post-processing; a hook that throws is reported
+and the build stands, and a promise that rejects is caught and reported rather
+than reaching the host as an unhandled rejection — which would otherwise take a
+dev server down from inside a step meant to reformat a file.
+
+`onBuildError` fires whatever `failOnError` is set to, and before that option
+decides whether to rethrow. The two answer different questions: one is whether
+the host stops, the other is that a build went wrong.
+
+## Public API
+
+Small on purpose. Four bundler entry points, one root entry, and two types.
+
+| Import                                          | What it is                                                                                                             |
+| ----------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `…/vite`, `…/rolldown`, `…/rollup`, `…/webpack` | Default export: the plugin for that bundler. Call it with the options below.                                           |
+| `…` (the root)                                  | Default export, also named `unplugin`: the unplugin instance, carrying `.vite`, `.rolldown`, `.rollup` and `.webpack`. |
+| `UnpluginStyleDictionaryOptions`                | The options type, exported from every entry above.                                                                     |
+| `StyleDictionaryConfigContext`                  | What the function form of `config` is handed, exported from every entry above.                                         |
+
+Anything not in that table is internal, whatever a build output happens to
+contain. In particular the watch filter and the raw unplugin factory are not
+exported: the filter answers a question only this plugin asks, and the factory
+takes a second `meta` argument — the bundler-identifying `UnpluginContextMeta` —
+that a consumer would have to construct by hand, so calling it the obvious way
+is a type error rather than a plugin.
+
+Reach for the root entry when you need a target that has no subpath of its own,
+or when one configuration object feeds more than one bundler:
+
+```typescript
+import styleDictionary from '@kanso-labs/unplugin-style-dictionary'
+
+const plugin = styleDictionary.rollup({ config: 'sd.config.json' })
+```
 
 ## Options Reference
 
 ```typescript
+/**
+ * Options for the Style Dictionary unplugin factory, shared across all bundler
+ * targets (Vite, Rolldown, Rollup, Webpack).
+ *
+ * Every target compiles tokens before the build that consumes them. Live
+ * rebuild-on-change is driven by the host bundler's watch mode, because token
+ * source files sit outside the module graph: Vite's dev server, `rollup
+ * --watch` and `webpack --watch` all rebuild on a token change, and a one-shot
+ * 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.
+ *
+ * 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
+ * `async`: a promise it returns is left to run on its own, and a rejection is
+ * caught and reported rather than reaching the host as an unhandled one. A
+ * hook that throws is reported and does not fail the build that called it.
+ *
+ * They return `Promise<void> | void` rather than `void` for that reason. Both
+ * accept an `async` hook as far as the compiler is concerned, but `void` alone
+ * makes one a `no-misused-promises` error under the type-aware lint rules a
+ * consumer is likely to be running — for a hook this documents as supported.
+ *
+ * Rolldown's watch mode is the exception, and it is not about glob patterns.
+ * `addWatchFile` is accepted either way, but what happens next differs by
+ * platform — on macOS a file registered through it is watched by nothing, while
+ * on a Linux runner the same edit reaches a rebuild. Do not rely on a token
+ * edit triggering a rebuild there.
+ */
+/**
+ * What the host is doing, handed to the function form of `config` so it can
+ * decide what to build.
+ *
+ * Only Vite reports all three. Where a host does not say, the value is
+ * derived rather than guessed at, and each field below says how.
+ */
+export interface StyleDictionaryConfigContext {
+  /**
+   * Whether the host is serving or building.
+   *
+   * `'serve'` comes from Vite's own `config.command` and is the dev server.
+   * Every other target builds, so it is `'build'` there — rollup, rolldown and
+   * webpack have no serving mode of their own to report.
+   */
+  command: 'build' | 'serve'
+
+  /**
+   * The host's mode, as it names it.
+   *
+   * Vite reports its `config.mode` — `'development'` serving,
+   * `'production'` building, or whatever `--mode` named. webpack reports its
+   * `mode` option. rollup and rolldown have no such concept, so the value
+   * follows `command`: `'development'` when serving, `'production'` when
+   * building.
+   */
+  mode: string
+
+  /**
+   * 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
+   * 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.
+   */
+  watch: boolean
+}
+
 export interface UnpluginStyleDictionaryOptions {
+  /**
+   * Whether a configuration whose output is already up to date may skip its
+   * compile.
+   *
+   * A build's expensive half is `buildAllPlatforms` — around 80% of it on a
+   * 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.
+   *
+   * Two things are never skipped, because neither can be told from the
+   * filesystem:
+   *
+   * - **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 that was last
+   *   built; across processes there is nothing to compare, so it builds.
+   * - **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, and is what this
+   * option exists to turn off.
+   *
+   * @default true
+   */
+  cache?: boolean
+
   /**
    * Style Dictionary configuration(s).
    * Can be:
@@ -384,75 +643,205 @@ export interface UnpluginStyleDictionaryOptions {
    * - A function that returns a config or array of configs (or resolves to them).
    *   Useful for calling `StyleDictionary.registerFormat()` (or other `register*`
    *   methods) before returning a config that references the custom format by name.
+   *   It is handed a `StyleDictionaryConfigContext` describing what the host is
+   *   doing, so an expensive platform can be built only when it is wanted —
+   *   skipped under the dev server, built by `vite build`. A function taking no
+   *   arguments stays valid: TypeScript accepts one of fewer parameters, and
+   *   JavaScript ignores the extra argument.
    *
-   * If not provided, it will look for 'sd.config.json' or 'config.json' in the root directory.
+   * If not provided, the root directory is searched for 'sd.config.json',
+   * 'config.json', 'sd.config.js' and 'sd.config.mjs', in that order. The
+   * first one that exists wins, and the rest are not looked at.
    */
   config?:
-    | string
-    | string[]
+    | ((
+        context: StyleDictionaryConfigContext,
+      ) => Config | Config[] | Promise<Config | Config[]>)
     | Config
     | Config[]
-    | (() => Config | Config[] | Promise<Config | Config[]>)
+    | string
+    | string[]
 
   /**
-   * Additional files or glob patterns to watch.
-   * If config files are paths, those paths are watched automatically.
-   * By default, the plugin also parses 'source' and 'include' properties in configurations and watches them.
+   * Whether a failed rebuild is pushed to Vite's error overlay.
+   *
+   * A rebuild that fails under the dev server used to reach the browser
+   * nowhere: the page went on rendering the last good generated file, and the
+   * only trace was one red terminal line the developer may not have been
+   * looking at. With this on, the failure is sent to the page as an error
+   * frame naming this plugin, and the overlay is dismissed on the next
+   * rebuild that succeeds.
+   *
+   * This is Vite's overlay, so it does nothing on the other three targets,
+   * and nothing under `vite build` — there is no page to draw on.
+   *
+   * It is not `failOnError`'s job, and the two are independent. `failOnError`
+   * decides whether the host stops; this decides whether the browser is told.
+   * A dev server deliberately keeps serving through a failed rebuild, which is
+   * precisely the case where the overlay is the only thing that can say so.
+   *
+   * A failure Style Dictionary raises before this plugin can catch it — a
+   * token file that is not valid JSON, which rejects out of band — reaches
+   * neither the overlay nor this option.
+   *
+   * @default true
    */
-  watch?: string | string[]
+  errorOverlay?: boolean
 
   /**
    * Whether a compile that fails should throw rather than only be reported.
    *
-   * - 'build' (the default) throws on the one-shot compile in buildStart, and
-   *   only reports a failed watch rebuild.
-   * - 'serve' is the reverse: a failed rebuild is thrown to whatever awaited
-   *   it. Vite's dev server has no build to fail, so there it is reported.
-   * - true throws on both, false on neither.
+   * A failed compile used to be logged and swallowed, so `vite build`,
+   * `rollup` and `webpack` all exited 0 and shipped whatever the previous
+   * run had written — the stale values, presented as current.
+   *
+   * - `'build'` (the default) throws on the one-shot compile that runs in
+   *   `buildStart`, and only reports a failed watch rebuild, so a dev server
+   *   survives a half-typed token file.
+   * - `'serve'` is the reverse: a failed rebuild is thrown to whatever awaited
+   *   it, which is the host under `rollup --watch`. Vite's dev server has no
+   *   build to fail, so there it is reported and the server keeps serving.
+   * - `true` throws on both, `false` on neither.
    *
-   * Reporting happens either way, and is not suppressed by 'silent'.
+   * Reporting happens either way, and is not suppressed by `silent`.
    *
    * @default 'build'
    */
   failOnError?: 'build' | 'serve' | boolean
 
   /**
-   * The directory a relative config path is looked up in.
+   * How much this plugin and Style Dictionary say while building.
    *
-   * 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. A
-   * relative value here is resolved against the working directory, and it
-   * takes precedence over whatever the host reports.
+   * Style Dictionary's own warnings — a name collision, a reference that
+   * cannot be resolved, `No tokens for vars.css. File not created.` — used to
+   * be suppressed unconditionally, because the plugin overwrote
+   * `log.verbosity` on the way past. Leave this unset and whatever the
+   * configuration asked for stands.
+   *
+   * - `'silent'` — nothing from either.
+   * - `'warn'` — Style Dictionary's warnings, and nothing from the plugin.
+   * - `'info'` — the above, plus the plugin's progress lines and size table.
+   * - `'verbose'` — the above, with Style Dictionary naming what it warned
+   *   about rather than pointing at its own `--verbose` flag.
+   *
+   * A compile that fails is reported at every level, so there is no
+   * `'error'`: `'silent'` is the quietest and still reports a failure.
+   *
+   * This option governs what the plugin says, not where it goes. The messages
+   * are handed to the host — Vite's `config.logger`, the rollup and rolldown
+   * plugin context, webpack's `compilation` — so a host silenced by its own
+   * log level suppresses them after this option has let them through. A
+   * failure still stops the build whenever `failOnError` says it should,
+   * printed or not.
    *
-   * It does not move the paths inside a configuration. See "Where paths are
-   * resolved from" below.
+   * @default undefined, which prints the plugin's own lines and leaves the
+   * configuration's `log.verbosity` alone
    */
-  root?: string
+  logLevel?: 'info' | 'silent' | 'verbose' | 'warn'
 
   /**
-   * How much this plugin and Style Dictionary say while building.
+   * Called once a build has finished, with every file it declares and how long
+   * it took in milliseconds.
    *
-   * - 'silent' — nothing from either.
-   * - 'warn' — Style Dictionary's warnings, and nothing from the plugin.
-   * - 'info' — the above, plus the plugin's progress lines and size table.
-   * - 'verbose' — the above, with Style Dictionary naming what it warned about.
+   * 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.
    *
-   * Leave it unset and the configuration's own log.verbosity stands.
-   * A compile that fails is reported at every level.
+   * This is where formatting the generated files, type-checking them, or
+   * telling something else they have landed belongs.
    *
    * @default undefined
    */
-  logLevel?: 'info' | 'silent' | 'verbose' | 'warn'
+  onBuildEnd?: (files: string[], durationMs: number) => Promise<void> | void
+
+  /**
+   * Called when a build fails, with whatever was thrown.
+   *
+   * It fires whatever `failOnError` is set to, and before that option decides
+   * whether to rethrow — the two answer different questions, and under a dev
+   * server the default is not to throw at all.
+   *
+   * The failure is reported to the console either way, so this is for reacting
+   * to one rather than for noticing it.
+   *
+   * @default undefined
+   */
+  onBuildError?: (error: unknown) => Promise<void> | void
+
+  /**
+   * Called before a build begins, once per build.
+   *
+   * A watch-triggered rebuild is a build, so this fires again for each one.
+   *
+   * @default undefined
+   */
+  onBuildStart?: () => Promise<void> | void
+
+  /**
+   * Whether the table of generated files and their sizes is produced.
+   *
+   * Every generated file is read in full and gzipped at level 6 to fill the
+   * `gzip:` column — 4.5ms for 515kB of output, and 21ms at 6MB. That is
+   * small beside the compile it follows, and it is pure cost to a project
+   * large enough to care.
+   *
+   * This is not `logLevel`'s job, and the two differ in what they leave
+   * standing. `logLevel: 'warn'` silences the plugin's progress lines along
+   * with the table; `report: false` keeps them and drops only the table,
+   * along with the read and the compression behind it.
+   *
+   * Dropping to gzip level 1 instead was measured and rejected: it reported a
+   * figure up to 8.7% off — 21.4kB against 19.7kB on the same JSON — and that
+   * number is one a consumer compares against their own bundler's report.
+   *
+   * @default true
+   */
+  report?: boolean
+
+  /**
+   * The directory a relative `config` path is looked up in.
+   *
+   * 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.
+   * A relative value here is resolved against the working directory, and it
+   * takes precedence over whatever the host reports.
+   *
+   * It does not move the paths **inside** a configuration. Style Dictionary
+   * resolves every relative `source`, `include` and `buildPath` against the
+   * working directory, and this plugin reads them the same way, so a
+   * configuration behaves identically here and under Style Dictionary's own
+   * CLI. A configuration kept in a subdirectory therefore names its tokens
+   * relative to where the build runs, not relative to itself.
+   */
+  root?: string
 
   /**
    * Disable console logging.
    *
-   * An alias for logLevel: 'silent', which wins if both are set. A compile
+   * An alias for `logLevel: 'silent'`, which wins if both are set. A compile
    * that fails is always reported.
    *
    * @default false
    */
   silent?: boolean
+
+  /**
+   * Additional files or glob patterns to watch, on top of what is watched
+   * already: a `config` given as a path, and every file matched by the
+   * `source` and `include` patterns inside each configuration.
+   *
+   * Patterns are expanded to the paths they match before being registered,
+   * because the watchers in play take filenames rather than patterns. A
+   * pattern's own directory is registered alongside them, so a token file
+   * created later is noticed too.
+   *
+   * What a change to a watched file then triggers is the host's to decide —
+   * see the interface documentation above.
+   */
+  watch?: string | string[]
 }
 ```
 
@@ -478,3 +867,23 @@ plugin. As of this unplugin-based rewrite:
 ## License
 
 MIT
+
+[build-shield]:
+  https://img.shields.io/github/actions/workflow/status/kanso-labs/unplugin-style-dictionary/build.yaml?branch=main&label=Build
+[build-workflow]:
+  https://github.com/kanso-labs/unplugin-style-dictionary/actions/workflows/build.yaml
+[codecov]: https://codecov.io/gh/kanso-labs/unplugin-style-dictionary
+[coverage-shield]:
+  https://img.shields.io/codecov/c/github/kanso-labs/unplugin-style-dictionary?label=Coverage
+[license]: ./LICENSE
+[license-shield]:
+  https://img.shields.io/github/license/kanso-labs/unplugin-style-dictionary
+[npm]: https://www.npmjs.com/package/@kanso-labs/unplugin-style-dictionary
+[npm-downloads-shield]:
+  https://img.shields.io/npm/dm/@kanso-labs/unplugin-style-dictionary
+[npm-version-shield]:
+  https://img.shields.io/npm/v/@kanso-labs/unplugin-style-dictionary
+[test-shield]:
+  https://img.shields.io/github/actions/workflow/status/kanso-labs/unplugin-style-dictionary/test.yaml?branch=main&label=Test
+[test-workflow]:
+  https://github.com/kanso-labs/unplugin-style-dictionary/actions/workflows/test.yaml

package/dist/index.d.ts

@@ -1,9 +1,6 @@
-import { UnpluginStyleDictionaryOptions } from "./types.js";
-import { UnpluginFactory } from "unplugin";
+import { StyleDictionaryConfigContext, UnpluginStyleDictionaryOptions } from "./types.js";
 //#region src/index.d.ts
-export declare function matchesWatchedFile(file: string, patterns: string[]): boolean;
-export declare const unpluginFactory: UnpluginFactory<undefined | UnpluginStyleDictionaryOptions, false>;
 export declare const unplugin: import("unplugin").UnpluginInstance<UnpluginStyleDictionaryOptions | undefined, false>;
 //#endregion
-export { type UnpluginStyleDictionaryOptions, unplugin as default };
+export { type StyleDictionaryConfigContext, type UnpluginStyleDictionaryOptions, unplugin as default };
 //# sourceMappingURL=index.d.ts.map