nudge-ui 0.2.0

package/dist/hosts/vite/react.js

@@ -0,0 +1,231 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { injectIdentity } from "../../compiler/reactIdentity.js";
+import { extractComponentContracts } from "../../compiler/componentContracts.js";
+import { collectPackageComponentModules, extractPackageComponentContractCatalog, } from "../../compiler/packageComponentContracts.js";
+import { defaultReactComponentProtocols, formatComponentPolicyWarning, groupComponentPolicyDiagnostics, mergeComponentModuleProtocols, resolveHostComponentPolicy, } from "../../compiler/index.js";
+/**
+ * What React means to a host, with no knowledge of which host is asking. The
+ * Vite host owns the build tool; this module owns React semantics. `FrameworkHost`
+ * is everything React needs back, and the Vite host accepts `null` in its place,
+ * which is what proves it does not secretly depend on any of this.
+ */
+const COMPONENT_EXTENSION = /\.(?:tsx|jsx)(?:$|[?#])/;
+const COMPONENT_RUNTIME_MODULE = "nudge-ui/internal/component-runtime";
+const packageRequire = createRequire(import.meta.url);
+export function createReactSupport(options, host) {
+    const contractsByFile = new Map();
+    const packageModulesByFile = new Map();
+    const reportedPolicyDiagnostics = new Set();
+    const manualComponentIds = new Set(options.componentMetadata?.map((contract) => contract.componentId) ?? []);
+    let packageFingerprint = "";
+    // Aliased so the injected specifier resolves in a packed install, where the
+    // application's dependency graph has never heard of it.
+    const componentRuntimePath = resolveComponentRuntime();
+    if (options.componentMetadata?.length) {
+        contractsByFile.set("package-manifests", options.componentMetadata.map((contract) => ({
+            ...contract,
+            provenance: "package-manifest",
+        })));
+    }
+    /**
+     * Fingerprinted on the module-to-importer mapping so an unchanged import
+     * graph costs nothing; every component edit reaches this path.
+     */
+    function refreshPackageContracts() {
+        const hostByModule = new Map();
+        for (const [hostFile, modules] of [...packageModulesByFile].sort(([left], [right]) => left.localeCompare(right))) {
+            for (const moduleSpecifier of modules) {
+                if (!hostByModule.has(moduleSpecifier))
+                    hostByModule.set(moduleSpecifier, hostFile);
+            }
+        }
+        const fingerprint = [...hostByModule]
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([moduleSpecifier, hostFile]) => `${moduleSpecifier}\0${hostFile}`)
+            .join("\n");
+        if (fingerprint === packageFingerprint)
+            return;
+        for (const key of [...contractsByFile.keys()]) {
+            if (key.startsWith("package-types:"))
+                contractsByFile.delete(key);
+        }
+        const root = host.root();
+        const catalog = root
+            ? extractPackageComponentContractCatalog({
+                hostFile: join(root, "__nudge_ui_package_contracts__.tsx"),
+                moduleSpecifiers: [...hostByModule.keys()],
+            })
+            : [];
+        for (const moduleSpecifier of hostByModule.keys()) {
+            contractsByFile.set(`package-types:${moduleSpecifier}`, catalog.filter((contract) => contract.file === moduleSpecifier && !manualComponentIds.has(contract.componentId)));
+        }
+        packageFingerprint = fingerprint;
+    }
+    return {
+        /** Manifest labels for a host composing React. */
+        hostLabel: "vite-react",
+        framework: "React",
+        virtualModuleId: "virtual:nudge-ui-components",
+        owns(id) {
+            return COMPONENT_EXTENSION.test(id);
+        },
+        /**
+         * Dedupe is the load-bearing part: instrumented callsites must use the
+         * application's own React, and a linked or nested copy would create a
+         * second runtime.
+         */
+        viteConfig(context) {
+            const demoAliases = context.demo && options.skipReactAliases !== true
+                ? resolveReactAliases(context.projectRoot)
+                : [];
+            const runtimeAliases = componentRuntimePath
+                ? [{ find: COMPONENT_RUNTIME_MODULE, replacement: componentRuntimePath }]
+                : [];
+            return {
+                ...(componentRuntimePath
+                    ? {
+                        // Vite merges this with the application's own settings, so listing its entries here would duplicate them.
+                        optimizeDeps: { include: [COMPONENT_RUNTIME_MODULE] },
+                    }
+                    : {}),
+                resolve: {
+                    ...(demoAliases.length > 0 || runtimeAliases.length > 0
+                        ? { alias: [...demoAliases, ...runtimeAliases] }
+                        : {}),
+                    dedupe: [...new Set([...context.existingDedupe, "react", "react-dom"])],
+                },
+            };
+        },
+        /** Not fatal, but a packed install that cannot resolve it fails later at the importing module. */
+        unresolvedRuntimeWarning() {
+            if (componentRuntimePath)
+                return null;
+            return `[nudge-ui] Could not resolve ${COMPONENT_RUNTIME_MODULE} from the Vite adapter. `
+                + "Semantic component callsites will fall back to application resolution of that specifier.";
+        },
+        /** Cold-start scan, so the first manifest is not missing every contract. */
+        warmUp() {
+            const root = host.root();
+            if (!root)
+                return;
+            for (const file of scanComponentFiles(root)) {
+                try {
+                    this.observe(file, readFileSync(file, "utf8"), false);
+                }
+                catch {
+                    // skip unreadable component sources
+                }
+            }
+            refreshPackageContracts();
+        },
+        observe(id, code, refreshPackages = true) {
+            if (!COMPONENT_EXTENSION.test(id) || !host.isHostSource(id))
+                return;
+            const fileId = id.split(/[?#]/, 1)[0] ?? id;
+            contractsByFile.set(fileId, extractComponentContracts(code, host.catalogPath(fileId)));
+            packageModulesByFile.set(fileId, collectPackageComponentModules(code, fileId));
+            if (refreshPackages)
+                refreshPackageContracts();
+        },
+        /** Drops a module whose source could not be read after a change. */
+        forget(id) {
+            contractsByFile.set(id, []);
+            packageModulesByFile.delete(id);
+            refreshPackageContracts();
+        },
+        async transform(context, code, id) {
+            const instrumentComponents = host.isHostSource(id);
+            const isComponent = COMPONENT_EXTENSION.test(id) && instrumentComponents;
+            if (isComponent)
+                this.observe(id, code);
+            const hostPolicy = isComponent
+                ? await resolveHostComponentPolicy(code, id, {
+                    resolve: context.resolve,
+                    read: async (resolvedId) => {
+                        try {
+                            return readFileSync(resolvedId, "utf8");
+                        }
+                        catch {
+                            return null;
+                        }
+                    },
+                    isProjectSource: host.isHostSource,
+                    sourcePath: host.catalogPath,
+                }, {
+                    moduleProtocols: mergeComponentModuleProtocols(defaultReactComponentProtocols, options.componentProtocols),
+                    compatibleComponentImports: options.compatibleComponentImports,
+                })
+                : undefined;
+            for (const grouped of groupComponentPolicyDiagnostics(hostPolicy?.diagnostics ?? [])) {
+                if (reportedPolicyDiagnostics.has(grouped.key))
+                    continue;
+                reportedPolicyDiagnostics.add(grouped.key);
+                context.warn(formatComponentPolicyWarning(grouped, host.catalogPath(id)));
+            }
+            return injectIdentity(code, id, host.root(), {
+                instrumentComponents,
+                // Already folds compatibleComponentImports in, so identity reads one policy.
+                hostPolicy,
+            });
+        },
+        contracts() {
+            return [...contractsByFile.values()].flat();
+        },
+        serializeVirtualModule(contracts) {
+            return `export const componentContracts = ${JSON.stringify(contracts)};\n`
+                + "export default componentContracts;\n";
+        },
+    };
+}
+function scanComponentFiles(rootDir, files = [], dir = rootDir) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
+        if (entry === "node_modules" || entry === ".git" || entry.startsWith("dist"))
+            continue;
+        const full = join(dir, entry);
+        try {
+            if (statSync(full).isDirectory())
+                scanComponentFiles(rootDir, files, full);
+            else if (COMPONENT_EXTENSION.test(entry))
+                files.push(full);
+        }
+        catch {
+            // ignore unreadable entries
+        }
+    }
+    return files;
+}
+function resolveComponentRuntime() {
+    try {
+        return packageRequire.resolve(COMPONENT_RUNTIME_MODULE);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveReactAliases(projectRoot) {
+    const require = createRequire(`${projectRoot}/package.json`);
+    const aliases = [];
+    const add = (pattern, specifier) => {
+        try {
+            aliases.push({ find: pattern, replacement: require.resolve(specifier) });
+        }
+        catch {
+            // an unresolvable specifier simply contributes no alias
+        }
+    };
+    add(/^react$/, "react");
+    add(/^react-dom$/, "react-dom");
+    add(/^react\/jsx-runtime$/, "react/jsx-runtime");
+    add(/^react\/jsx-dev-runtime$/, "react/jsx-dev-runtime");
+    add(/^react-dom\/client$/, "react-dom/client");
+    return aliases;
+}

package/dist/hosts/vite/tokens/activeStylesheets.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The token catalog must follow only stylesheets the application imports. This
+ * small graph walker deliberately has no filesystem traversal: callers supply
+ * the host CSS entry files, a Vite-backed resolver, and a reader.
+ */
+export interface CssImportGraph {
+    files: Map<string, string>;
+    /** CSS cascade order: imported sheets precede the sheet that imports them. */
+    order: string[];
+    unresolved: Array<{
+        importer: string;
+        specifier: string;
+    }>;
+    unreadable: string[];
+}
+export interface CssImportGraphDependencies {
+    read(id: string): string;
+    resolve(specifier: string, importer: string): Promise<string | null>;
+}
+export declare function stripCssQuery(id: string): string;
+export declare function isCssStylesheet(id: string): boolean;
+/** Extract quoted and url(...) @import targets while ignoring CSS comments. */
+export declare function cssImportSpecifiers(css: string): string[];
+/**
+ * Resolve every CSS file reached from the supplied host stylesheets. Missing
+ * and unreadable imports are reported but never make the catalog unavailable.
+ */
+export declare function discoverCssImportGraph(entryFiles: readonly string[], dependencies: CssImportGraphDependencies): Promise<CssImportGraph>;

package/dist/hosts/vite/tokens/activeStylesheets.js

@@ -0,0 +1,70 @@
+export function stripCssQuery(id) {
+    return id.split(/[?#]/, 1)[0] ?? id;
+}
+export function isCssStylesheet(id) {
+    return /\.css(?:$|[?#])/i.test(id);
+}
+/** Extract quoted and url(...) @import targets while ignoring CSS comments. */
+export function cssImportSpecifiers(css) {
+    const withoutComments = css.replace(/\/\*[\s\S]*?\*\//g, "");
+    const imports = [];
+    const expression = /@import\s+(?:url\(\s*)?(?:"([^"]+)"|'([^']+)'|([^\s)'";]+))\s*\)?/gi;
+    let match;
+    while ((match = expression.exec(withoutComments))) {
+        const specifier = match[1] ?? match[2] ?? match[3];
+        if (specifier)
+            imports.push(specifier);
+    }
+    return imports;
+}
+/**
+ * Resolve every CSS file reached from the supplied host stylesheets. Missing
+ * and unreadable imports are reported but never make the catalog unavailable.
+ */
+export async function discoverCssImportGraph(entryFiles, dependencies) {
+    const files = new Map();
+    const order = [];
+    const visiting = new Set();
+    const unresolved = [];
+    const unreadable = [];
+    async function visit(id) {
+        const fileId = stripCssQuery(id);
+        if (files.has(fileId) || visiting.has(fileId) || unreadable.includes(fileId))
+            return;
+        visiting.add(fileId);
+        let css;
+        try {
+            css = dependencies.read(fileId);
+        }
+        catch {
+            unreadable.push(fileId);
+            visiting.delete(fileId);
+            return;
+        }
+        files.set(fileId, css);
+        for (const specifier of cssImportSpecifiers(css)) {
+            let resolved = null;
+            try {
+                resolved = await dependencies.resolve(specifier, fileId);
+            }
+            catch {
+                // An unresolved package must not prevent the host token catalog loading.
+            }
+            if (!resolved) {
+                unresolved.push({ importer: fileId, specifier });
+                continue;
+            }
+            // A processor-owned import such as Tailwind's package entry may resolve
+            // to JavaScript and later emit CSS during transform. It is outside this
+            // ordinary-CSS graph, but it is not an unresolved stylesheet failure.
+            if (!isCssStylesheet(resolved))
+                continue;
+            await visit(resolved);
+        }
+        visiting.delete(fileId);
+        order.push(fileId);
+    }
+    for (const entry of entryFiles)
+        await visit(entry);
+    return { files, order, unresolved, unreadable };
+}

package/dist/hosts/vite/tokens/fileMap.d.ts

@@ -0,0 +1,2 @@
+/** A string-keyed file map used in CSS import graph tests. */
+export type FileMap = Record<string, string>;

package/dist/hosts/vite/tokens/fileMap.js

@@ -0,0 +1 @@
+export {};

package/dist/hosts/vite/tokens/viteStylesheetArtifacts.d.ts

@@ -0,0 +1,46 @@
+import type { ArtifactStage, StylesheetArtifact } from "../../../css/token-inventory/index.js";
+import type { CssImportGraph } from "./activeStylesheets.js";
+/**
+ * Source directories that a Vite host explicitly owns.
+ *
+ * Vite's resolved root is always included by the adapter. `sourceRoots` lets a
+ * monorepo host add authored workspace packages without treating every file
+ * reachable through Vite's module graph as application code. Generated roots
+ * are excluded even when a caller accidentally includes them in a source
+ * root.
+ */
+export interface ViteSourceScopeOptions {
+    readonly sourceRoots?: readonly string[];
+    readonly generatedRoots?: readonly string[];
+}
+export declare function isHostApplicationSource(id: string, projectRoot: string | undefined, options?: ViteSourceScopeOptions): boolean;
+export declare function isPackageStylesheet(id: string, projectRoot: string | undefined, options?: ViteSourceScopeOptions): boolean;
+/** Keep package sources useful to people without serialising machine paths. */
+export declare function catalogSourcePath(id: string, projectRoot: string | undefined, options?: ViteSourceScopeOptions): string;
+export interface ViteStylesheetArtifactInput {
+    readonly id: string;
+    readonly projectRoot: string | undefined;
+    readonly sourceRoots?: readonly string[];
+    readonly generatedRoots?: readonly string[];
+    readonly stage: ArtifactStage;
+    readonly content?: string;
+    readonly failed?: boolean;
+    readonly order?: number;
+    readonly discoveryOrder?: number;
+    /** Explicit graph-level v4 detection avoids mistaking Tailwind v3 --tw helpers for v4. */
+    readonly tailwindV4?: boolean;
+}
+/** Map Vite-specific identity and evidence into the neutral artifact contract. */
+export declare function createViteStylesheetArtifact(input: ViteStylesheetArtifactInput): StylesheetArtifact;
+export interface OrderedViteStylesheet {
+    readonly id: string;
+    readonly code: string;
+    readonly order?: number;
+    readonly discoveryOrder?: number;
+}
+/**
+ * A single active root proves nested CSS import order. Multiple independent
+ * roots have no proven cross-root cascade order, so their traversal rank stays
+ * discovery evidence.
+ */
+export declare function orderViteStylesheetGraph(graph: CssImportGraph, activeRootCount: number): OrderedViteStylesheet[];

package/dist/hosts/vite/tokens/viteStylesheetArtifacts.js

@@ -0,0 +1,104 @@
+import { isAbsolute, relative, resolve, sep, } from "node:path";
+import { relativePath } from "../../../compiler/index.js";
+import { detectTailwindV4 } from "../../../css/dialects/index.js";
+import { stripCssQuery } from "./activeStylesheets.js";
+const GENERATED_DIRECTORY_NAMES = new Set([
+    ".astro",
+    ".next",
+    ".svelte-kit",
+    "build",
+    "coverage",
+    "dist",
+    "out",
+    "storybook-static",
+]);
+export function isHostApplicationSource(id, projectRoot, options = {}) {
+    if (!projectRoot || id.startsWith("\0"))
+        return false;
+    const fileId = stripCssQuery(id).replace(/\\/g, "/");
+    if (fileId.split("/").includes("node_modules")) {
+        return false;
+    }
+    const absoluteFile = isAbsolute(fileId)
+        ? resolve(fileId)
+        : resolve(projectRoot, fileId);
+    const primaryRoot = resolve(projectRoot);
+    const roots = [primaryRoot, ...(options.sourceRoots ?? [])
+            .map((sourceRoot) => resolve(projectRoot, sourceRoot))];
+    const generatedRoots = (options.generatedRoots ?? [])
+        .map((generatedRoot) => resolve(projectRoot, generatedRoot));
+    if (isInsideAnyRoot(absoluteFile, generatedRoots))
+        return false;
+    const sourceRoot = roots.find((candidate) => isInsideRoot(absoluteFile, candidate));
+    if (!sourceRoot)
+        return false;
+    // A generated directory can be nested in an authored workspace package, so a
+    // declared source root keeps a conservative name-based guard. The primary
+    // root does not: there, a directory named `build` may be ordinary authored
+    // source, and the resolved output directory is already excluded above.
+    if (sourceRoot !== primaryRoot) {
+        const pathSegments = relative(sourceRoot, absoluteFile).split(sep).filter(Boolean);
+        if (pathSegments.some((segment) => GENERATED_DIRECTORY_NAMES.has(segment))) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isPackageStylesheet(id, projectRoot, options = {}) {
+    return !isHostApplicationSource(id, projectRoot, options);
+}
+/** Keep package sources useful to people without serialising machine paths. */
+export function catalogSourcePath(id, projectRoot, options = {}) {
+    const fileId = stripCssQuery(id).replace(/\\/g, "/");
+    if (!isPackageStylesheet(fileId, projectRoot, options)) {
+        return relativePath(fileId, projectRoot);
+    }
+    const nodeModules = fileId.lastIndexOf("/node_modules/");
+    if (nodeModules >= 0)
+        return fileId.slice(nodeModules + "/node_modules/".length);
+    if (projectRoot)
+        return relative(projectRoot, fileId).replace(/\\/g, "/");
+    return fileId.replace(/^\//, "");
+}
+/** Map Vite-specific identity and evidence into the neutral artifact contract. */
+export function createViteStylesheetArtifact(input) {
+    const fileId = stripCssQuery(input.id);
+    // The artifact input already carries the scope fields, so it is the scope.
+    const sourceScope = input;
+    return {
+        buildTool: "vite",
+        id: catalogSourcePath(fileId, input.projectRoot, sourceScope),
+        stage: input.stage,
+        provenance: isHostApplicationSource(fileId, input.projectRoot, sourceScope) ? "project" : "package",
+        ...(input.order !== undefined ? { order: input.order } : {}),
+        ...(input.discoveryOrder !== undefined ? { discoveryOrder: input.discoveryOrder } : {}),
+        ...(input.content !== undefined ? {
+            content: input.content,
+            adapter: (input.tailwindV4 ?? detectTailwindV4(input.content)) ? "tailwind-v4" : undefined,
+        } : {}),
+        ...(input.failed ? { failed: true } : {}),
+    };
+}
+function isInsideAnyRoot(file, roots) {
+    return roots.some((root) => isInsideRoot(file, root));
+}
+function isInsideRoot(file, root) {
+    const relativeFile = relative(resolve(root), resolve(file));
+    return relativeFile !== ""
+        && relativeFile !== ".."
+        && !relativeFile.startsWith(`..${sep}`)
+        && !isAbsolute(relativeFile);
+}
+/**
+ * A single active root proves nested CSS import order. Multiple independent
+ * roots have no proven cross-root cascade order, so their traversal rank stays
+ * discovery evidence.
+ */
+export function orderViteStylesheetGraph(graph, activeRootCount) {
+    const authoritative = activeRootCount === 1;
+    return graph.order.map((id, index) => ({
+        id,
+        code: graph.files.get(id),
+        ...(authoritative ? { order: index } : { discoveryOrder: index }),
+    }));
+}

package/dist/hosts/vite/virtual/design-tokens.d.ts

@@ -0,0 +1,9 @@
+import type { TokenCatalogDiagnostic, TokenDefinition, TokenEntry } from "../../../css/model/index.js";
+export type { TokenCatalogDiagnostic, TokenContext, TokenContextWrapper, TokenContextWrapperKind, TokenDeclaration, TokenDefinition, TokenEntry, } from "../../../css/model/index.js";
+export declare const tokenTable: Record<string, TokenEntry>;
+/** Authoritative contextual inventory. Runtime values still come from CSS. */
+export declare const tokenCatalog: TokenDefinition[];
+export declare const tokenDiagnostics: TokenCatalogDiagnostic[];
+/** Inventory snapshot fingerprint; browser inspection refreshes on change. */
+export declare const tokenGeneration: string;
+export default tokenTable;

package/dist/hosts/vite/virtual/design-tokens.js

@@ -0,0 +1,7 @@
+export const tokenTable = {};
+/** Authoritative contextual inventory. Runtime values still come from CSS. */
+export const tokenCatalog = [];
+export const tokenDiagnostics = [];
+/** Inventory snapshot fingerprint; browser inspection refreshes on change. */
+export const tokenGeneration = "";
+export default tokenTable;

package/dist/hosts/vite/virtual-design-tokens.d.ts

@@ -0,0 +1 @@
+/// <reference path="../../css/virtual-design-tokens.d.ts" />

package/dist/hosts/vite/vite.d.ts

@@ -0,0 +1,62 @@
+import type { Plugin } from "vite";
+import type { TailwindV3Config, ThemeContract } from "../../css/dialects/index.js";
+import type { FrameworkHost, FrameworkSupport, ReactOptions } from "./react.js";
+/**
+ * How to find the project's vanilla-extract theme contract. Loading a module
+ * is a host capability, so the specifier lives here; what the contract means
+ * is interpreted in `nudge-ui/css/dialects`.
+ */
+export interface VanillaExtractOptions {
+    themeContract?: ThemeContract;
+    /** A Vite-resolvable module exporting a published compiled contract. */
+    themeContractModule?: string;
+    /** Defaults to `vars`. */
+    themeContractExport?: string;
+    themeContractPrefix?: string;
+    /** Known compiled values by custom-property name. */
+    cssValues?: Readonly<Record<string, string>>;
+    source?: string;
+}
+export interface NudgeUiOptions extends ReactOptions {
+    enabled?: boolean;
+    /** Enables experimental DOM parent/child navigation in the Inspector. */
+    debug?: boolean;
+    /** The landing app's demo runtime: mounted at root in dev and `nudge-demo` builds, or via `?nudgeDemo=1`. */
+    demo?: boolean;
+    /** Explicit project ID for browser-storage keys (defaults to root directory basename). */
+    projectId?: string;
+    /** Optional static v3 config for fixture/app integrations; dynamic configs are not executed. */
+    tailwindV3?: {
+        config: TailwindV3Config;
+        source?: string;
+    };
+    vanillaExtract?: VanillaExtractOptions;
+    /**
+     * Authored workspace directories outside Vite's resolved root. Dependencies
+     * and generated output stay excluded even when a broad directory is given.
+     */
+    sourceRoots?: readonly string[];
+}
+/**
+ * Extracts the stylesheet string Vite embeds in dev CSS-module JS wrappers
+ * (`const __vite__css = "…"`). Returns null for anything that is not such a
+ * wrapper, so callers can feed the original code unchanged.
+ */
+export declare function extractViteModuleCss(code: string): string | null;
+export interface TransformIndexHtmlOptions {
+    /** Inject the debug mount div instead of the standard one. */
+    debug?: boolean;
+    /** Keep the injection in a `build` command (explicit demo builds only). */
+    demoBuild?: boolean;
+    /** Keep the route-sensitive landing demo on its build-time virtual module. */
+    demo?: boolean;
+}
+export declare function transformIndexHtmlHtml(html: string, command: "serve" | "build", { debug, demoBuild, demo }?: TransformIndexHtmlOptions): string | null;
+/**
+ * Owns the build tool and nothing else: module graph, CSS observation, token
+ * inventory, transport middleware, bootstrap injection, HMR. Framework
+ * semantics arrive through `createFramework`; passing `null` is a supported
+ * composition, and `vite.noFramework.test.ts` exercises it to prove nothing
+ * here has grown a React assumption.
+ */
+export declare function createVitePlugins(options?: NudgeUiOptions, createFramework?: ((options: NudgeUiOptions, host: FrameworkHost) => FrameworkSupport) | null): Plugin[];