@leandrosk/dashboard 3.5.5-fork.2

package/dist/vite/vite-plugin-config-loader.d.ts

@@ -0,0 +1,16 @@
+import { Plugin } from 'vite';
+import { CompileResult, CompilerOptions } from './utils/compiler.js';
+export interface ConfigLoaderApi {
+    getVendureConfig(): Promise<CompileResult>;
+}
+export declare const configLoaderName = "vendure:config-loader";
+/**
+ * This Vite plugin loads the VendureConfig from the specified file path, and
+ * makes it available to other plugins via the `ConfigLoaderApi`.
+ */
+export declare function configLoaderPlugin(options: CompilerOptions): Plugin;
+/**
+ * Inter-plugin dependencies implemented following the pattern given here:
+ * https://rollupjs.org/plugin-development/#direct-plugin-communication
+ */
+export declare function getConfigLoaderApi(plugins: readonly Plugin[]): ConfigLoaderApi;

package/dist/vite/vite-plugin-config-loader.js

@@ -0,0 +1,70 @@
+import { compile } from './utils/compiler.js';
+import { debugLogger } from './utils/logger.js';
+export const configLoaderName = 'vendure:config-loader';
+/**
+ * This Vite plugin loads the VendureConfig from the specified file path, and
+ * makes it available to other plugins via the `ConfigLoaderApi`.
+ */
+export function configLoaderPlugin(options) {
+    let result;
+    const onConfigLoaded = [];
+    return {
+        name: configLoaderName,
+        async buildStart() {
+            this.info(`Loading Vendure config. This can take a short while depending on the size of your project...`);
+            try {
+                const startTime = Date.now();
+                result = await compile(Object.assign(Object.assign({}, options), { logger: process.env.LOG
+                        ? debugLogger
+                        : {
+                            info: (message) => this.info(message),
+                            warn: (message) => this.warn(message),
+                            debug: (message) => this.debug(message),
+                            error: (message) => this.error(message),
+                        } }));
+                const endTime = Date.now();
+                const duration = endTime - startTime;
+                const pluginNames = result.pluginInfo
+                    .map(p => `${p.name} ${p.sourcePluginPath ? '(local)' : '(npm)'}`)
+                    .join(', ');
+                this.info(`Found ${result.pluginInfo.length} plugins: ${pluginNames}`);
+                this.info(`Vendure config loaded (using export "${result.exportedSymbolName}") in ${duration}ms`);
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    const message = [
+                        e.message,
+                        `If you are using a monorepo, you may need to provide a custom pathAdapter to resolve the paths correctly.`,
+                    ].join('\n');
+                    this.error(`Error loading Vendure config: ${message}`);
+                }
+            }
+            onConfigLoaded.forEach(fn => fn());
+        },
+        api: {
+            getVendureConfig() {
+                if (result) {
+                    return Promise.resolve(result);
+                }
+                else {
+                    return new Promise(resolve => {
+                        onConfigLoaded.push(() => {
+                            resolve(result);
+                        });
+                    });
+                }
+            },
+        },
+    };
+}
+/**
+ * Inter-plugin dependencies implemented following the pattern given here:
+ * https://rollupjs.org/plugin-development/#direct-plugin-communication
+ */
+export function getConfigLoaderApi(plugins) {
+    const parentPlugin = plugins.find(plugin => plugin.name === configLoaderName);
+    if (!parentPlugin) {
+        throw new Error(`This plugin depends on the "${configLoaderName}" plugin.`);
+    }
+    return parentPlugin.api;
+}

package/dist/vite/vite-plugin-config.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from 'vite';
+export declare function viteConfigPlugin({ packageRoot }: {
+    packageRoot: string;
+}): Plugin;

package/dist/vite/vite-plugin-config.js

@@ -0,0 +1,60 @@
+import path from 'path';
+export function viteConfigPlugin({ packageRoot }) {
+    return {
+        name: 'vendure:vite-config-plugin',
+        config: (config, env) => {
+            var _a, _b, _c, _d, _e, _f;
+            // Only set the vite `root` to the dashboard package when running the dev server.
+            // During a production build we still need to reference the dashboard source which
+            // lives in `node_modules`, but we don't want the build output to be emitted in there.
+            // Therefore, we set `root` only for `serve` and, for `build`, we instead make sure that
+            // an `outDir` **outside** of `node_modules` is used (defaulting to the current working
+            // directory if the user did not provide one already).
+            config.root = packageRoot;
+            config.publicDir = (_a = config.publicDir) !== null && _a !== void 0 ? _a : path.join(packageRoot, 'public');
+            // If we are building and no explicit outDir has been provided (or it is a relative path),
+            // set it to an **absolute** path relative to the cwd so that the output never ends up in
+            // `node_modules`.
+            if (env.command === 'build') {
+                const buildConfig = (_b = config.build) !== null && _b !== void 0 ? _b : {};
+                const outDir = buildConfig.outDir;
+                const hasOutDir = typeof outDir === 'string' && outDir.length > 0;
+                const outDirIsAbsolute = hasOutDir && path.isAbsolute(outDir);
+                const normalizedOutDir = hasOutDir
+                    ? outDirIsAbsolute
+                        ? outDir
+                        : path.resolve(process.cwd(), outDir)
+                    : path.resolve(process.cwd(), 'dist');
+                config.build = Object.assign(Object.assign({}, buildConfig), { outDir: normalizedOutDir });
+            }
+            config.resolve = {
+                alias: Object.assign(Object.assign({}, ((_d = (_c = config.resolve) === null || _c === void 0 ? void 0 : _c.alias) !== null && _d !== void 0 ? _d : {})), { 
+                    // See the readme for an explanation of this alias.
+                    '@/vdb': path.resolve(packageRoot, './src/lib'), '@/graphql': path.resolve(packageRoot, './src/lib/graphql') }),
+            };
+            // This is required to prevent Vite from pre-bundling the
+            // dashboard source when it resides in node_modules.
+            config.optimizeDeps = Object.assign(Object.assign({}, config.optimizeDeps), { exclude: [
+                    ...(((_e = config.optimizeDeps) === null || _e === void 0 ? void 0 : _e.exclude) || []),
+                    '@vendure/dashboard',
+                    '@/vdb',
+                    'virtual:vendure-ui-config',
+                    'virtual:admin-api-schema',
+                    'virtual:dashboard-extensions',
+                ], 
+                // We however do want to pre-bundle recharts, as it depends
+                // on lodash which is a CJS packages and _does_ require
+                // pre-bundling.
+                include: [
+                    ...(((_f = config.optimizeDeps) === null || _f === void 0 ? void 0 : _f.include) || []),
+                    '@/components > recharts',
+                    '@/components > react-dropzone',
+                    '@/components > @tiptap/react', // https://github.com/fawmi/vue-google-maps/issues/148#issuecomment-1235143844
+                    '@vendure/common/lib/generated-types',
+                    '@radix-ui/react-portal > react-dom',
+                    '@messageformat/parser',
+                ] });
+            return config;
+        },
+    };
+}

package/dist/vite/vite-plugin-dashboard-metadata.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from 'vite';
+/**
+ * This Vite plugin scans the configured plugins for any dashboard extensions and dynamically
+ * generates an import statement for each one, wrapped up in a `runDashboardExtensions()`
+ * function which can then be imported and executed in the Dashboard app.
+ */
+export declare function dashboardMetadataPlugin(): Plugin;

package/dist/vite/vite-plugin-dashboard-metadata.js

@@ -0,0 +1,61 @@
+import path from 'path';
+import { pathToFileURL } from 'node:url';
+import { getConfigLoaderApi } from './vite-plugin-config-loader.js';
+const virtualModuleId = 'virtual:dashboard-extensions';
+const resolvedVirtualModuleId = `\0${virtualModuleId}`;
+/**
+ * This Vite plugin scans the configured plugins for any dashboard extensions and dynamically
+ * generates an import statement for each one, wrapped up in a `runDashboardExtensions()`
+ * function which can then be imported and executed in the Dashboard app.
+ */
+export function dashboardMetadataPlugin() {
+    let configLoaderApi;
+    let loadVendureConfigResult;
+    return {
+        name: 'vendure:dashboard-extensions-metadata',
+        configResolved({ plugins }) {
+            configLoaderApi = getConfigLoaderApi(plugins);
+        },
+        resolveId(id) {
+            if (id === virtualModuleId) {
+                return resolvedVirtualModuleId;
+            }
+        },
+        async load(id) {
+            var _a;
+            if (id === resolvedVirtualModuleId) {
+                const startTime = Date.now();
+                this.debug('Loading dashboard extensions...');
+                if (!loadVendureConfigResult) {
+                    const configStart = Date.now();
+                    loadVendureConfigResult = await configLoaderApi.getVendureConfig();
+                    this.debug(`Loaded Vendure config in ${Date.now() - configStart}ms`);
+                }
+                const { pluginInfo } = loadVendureConfigResult;
+                const resolveStart = Date.now();
+                const pluginsWithExtensions = (_a = pluginInfo === null || pluginInfo === void 0 ? void 0 : pluginInfo.map(({ dashboardEntryPath, pluginPath, sourcePluginPath }) => {
+                    if (!dashboardEntryPath) {
+                        return null;
+                    }
+                    // For local plugins, use the sourcePluginPath to resolve the dashboard extension
+                    const basePath = sourcePluginPath
+                        ? path.dirname(sourcePluginPath)
+                        : path.dirname(pluginPath);
+                    const resolved = path.resolve(basePath, dashboardEntryPath);
+                    this.debug(`Resolved extension path: ${resolved}`);
+                    return resolved;
+                }).filter(x => x != null)) !== null && _a !== void 0 ? _a : [];
+                this.info(`Found ${pluginsWithExtensions.length} Dashboard extensions in ${Date.now() - resolveStart}ms`);
+                this.debug(`Total dashboard extension loading completed in ${Date.now() - startTime}ms`);
+                return `
+                    export async function runDashboardExtensions() {
+                        ${pluginsWithExtensions
+                    .map(extension => {
+                    return `await import(\`${pathToFileURL(extension)}\`);`;
+                })
+                    .join('\n')}
+                }`;
+            }
+        },
+    };
+}

package/dist/vite/vite-plugin-gql-tada.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+export declare function gqlTadaPlugin(options: {
+    gqlTadaOutputPath: string;
+    tempDir: string;
+    packageRoot: string;
+}): Plugin;

package/dist/vite/vite-plugin-gql-tada.js

@@ -0,0 +1,51 @@
+import { generateOutput } from '@gql.tada/cli-utils';
+import * as fs from 'fs/promises';
+import { printSchema } from 'graphql';
+import * as path from 'path';
+import { generateSchema } from './utils/schema-generator.js';
+import { getConfigLoaderApi } from './vite-plugin-config-loader.js';
+export function gqlTadaPlugin(options) {
+    let configLoaderApi;
+    return {
+        name: 'vendure:gql-tada',
+        configResolved({ plugins }) {
+            configLoaderApi = getConfigLoaderApi(plugins);
+        },
+        async buildStart() {
+            const { vendureConfig } = await configLoaderApi.getVendureConfig();
+            const safeSchema = await generateSchema({ vendureConfig });
+            const tsConfigContent = {
+                compilerOptions: {
+                    plugins: [
+                        {
+                            name: 'gql.tada/ts-plugin',
+                            schema: './schema.graphql',
+                        },
+                    ],
+                },
+            };
+            const tsConfigPath = path.join(options.tempDir, 'tsconfig.json');
+            await fs.writeFile(tsConfigPath, JSON.stringify(tsConfigContent, null, 2));
+            const schemaPath = path.join(options.tempDir, 'schema.graphql');
+            await fs.writeFile(schemaPath, printSchema(safeSchema));
+            await generateOutput({
+                output: path.join(options.gqlTadaOutputPath, 'graphql-env.d.ts'),
+                tsconfig: tsConfigPath,
+            });
+            // Copy the graphql.ts file to the output path
+            const graphqlTsPath = path.join(options.packageRoot, 'src/lib/graphql/graphql.ts');
+            try {
+                await fs.copyFile(graphqlTsPath, path.join(options.gqlTadaOutputPath, 'graphql.ts'));
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    this.error(error.message);
+                }
+                else {
+                    this.error('Failed to copy graphql.ts file');
+                }
+            }
+            this.info('graphql introspection files output to ' + options.gqlTadaOutputPath);
+        },
+    };
+}

package/dist/vite/vite-plugin-hmr.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from 'vite';
+/**
+ * @description
+ * This plugin enables kind-of HMR for when dashboard extension files change.
+ * It is not true HMR because it triggers a page reload. Making real HMR work is very
+ * tricky in this case due to the way we load extension files via virtual modules.
+ */
+export declare function hmrPlugin(): Plugin;

package/dist/vite/vite-plugin-hmr.js

@@ -0,0 +1,34 @@
+/**
+ * @description
+ * This plugin enables kind-of HMR for when dashboard extension files change.
+ * It is not true HMR because it triggers a page reload. Making real HMR work is very
+ * tricky in this case due to the way we load extension files via virtual modules.
+ */
+export function hmrPlugin() {
+    let viteRoot;
+    return {
+        name: 'vendure:hmr',
+        configResolved(config) {
+            viteRoot = config.root;
+        },
+        handleHotUpdate({ server, modules, timestamp, file }) {
+            const invalidatedModules = new Set();
+            for (const mod of modules) {
+                server.moduleGraph.invalidateModule(mod, invalidatedModules, timestamp, true);
+                // Check if this is a file outside the Vite root (e.g., dashboard extensions)
+                const isOutsideRoot = mod.file && !mod.file.startsWith(viteRoot);
+                if (isOutsideRoot) {
+                    // For files outside root, trigger a full page reload
+                    // This ensures all extension code is fresh
+                    server.ws.send({
+                        type: 'full-reload',
+                        path: '*',
+                    });
+                    return [];
+                }
+            }
+            // Let Vite handle normal HMR for files inside root
+            return undefined;
+        },
+    };
+}

package/dist/vite/vite-plugin-lingui-babel.d.ts

@@ -0,0 +1,40 @@
+import type { Plugin } from 'vite';
+/**
+ * Options for the linguiBabelPlugin.
+ */
+export interface LinguiBabelPluginOptions {
+    /**
+     * For testing: manually specify package paths that should have Lingui macros transformed.
+     * In production, these are automatically discovered from the VendureConfig plugins.
+     */
+    additionalPackagePaths?: string[];
+}
+/**
+ * @description
+ * A custom Vite plugin that transforms Lingui macros in files using Babel instead of SWC.
+ *
+ * This plugin solves a critical compatibility issue with SWC plugins:
+ * - SWC plugins are compiled Wasm binaries that require exact version matching with `@swc/core`
+ * - When users have different SWC versions in their projects (e.g., from Next.js, Nx, etc.),
+ *   the Lingui SWC plugin fails with "failed to invoke plugin" errors
+ * - Babel has no such binary compatibility issues, making it much more reliable for library code
+ *
+ * The plugin runs BEFORE `@vitejs/plugin-react` and transforms files containing Lingui macros
+ * (imports from `@lingui/core/macro` or `@lingui/react/macro`) using the Babel-based
+ * `@lingui/babel-plugin-lingui-macro`.
+ *
+ * Files processed:
+ * - `@vendure/dashboard/src` files (in node_modules for external projects)
+ * - `packages/dashboard/src` files (in monorepo development)
+ * - User's dashboard extension files (e.g., custom plugins using Lingui)
+ * - Third-party npm packages that provide dashboard extensions (discovered automatically)
+ *
+ * Files NOT processed:
+ * - Files that don't contain Lingui macro imports (fast check via string matching)
+ * - Non-JS/TS files
+ * - node_modules packages that are not discovered as Vendure plugins
+ *
+ * @see https://github.com/vendurehq/vendure/issues/3929
+ * @see https://github.com/lingui/swc-plugin/issues/179
+ */
+export declare function linguiBabelPlugin(options?: LinguiBabelPluginOptions): Plugin;

package/dist/vite/vite-plugin-lingui-babel.js

@@ -0,0 +1,168 @@
+import * as babel from '@babel/core';
+import { getConfigLoaderApi } from './vite-plugin-config-loader.js';
+/**
+ * @description
+ * A custom Vite plugin that transforms Lingui macros in files using Babel instead of SWC.
+ *
+ * This plugin solves a critical compatibility issue with SWC plugins:
+ * - SWC plugins are compiled Wasm binaries that require exact version matching with `@swc/core`
+ * - When users have different SWC versions in their projects (e.g., from Next.js, Nx, etc.),
+ *   the Lingui SWC plugin fails with "failed to invoke plugin" errors
+ * - Babel has no such binary compatibility issues, making it much more reliable for library code
+ *
+ * The plugin runs BEFORE `@vitejs/plugin-react` and transforms files containing Lingui macros
+ * (imports from `@lingui/core/macro` or `@lingui/react/macro`) using the Babel-based
+ * `@lingui/babel-plugin-lingui-macro`.
+ *
+ * Files processed:
+ * - `@vendure/dashboard/src` files (in node_modules for external projects)
+ * - `packages/dashboard/src` files (in monorepo development)
+ * - User's dashboard extension files (e.g., custom plugins using Lingui)
+ * - Third-party npm packages that provide dashboard extensions (discovered automatically)
+ *
+ * Files NOT processed:
+ * - Files that don't contain Lingui macro imports (fast check via string matching)
+ * - Non-JS/TS files
+ * - node_modules packages that are not discovered as Vendure plugins
+ *
+ * @see https://github.com/vendurehq/vendure/issues/3929
+ * @see https://github.com/lingui/swc-plugin/issues/179
+ */
+export function linguiBabelPlugin(options) {
+    var _a;
+    // Paths of npm packages that should have Lingui macros transformed.
+    // This is populated from plugin discovery when transform is first called.
+    const allowedNodeModulesPackages = new Set((_a = options === null || options === void 0 ? void 0 : options.additionalPackagePaths) !== null && _a !== void 0 ? _a : []);
+    // API reference to the config loader plugin (set in configResolved)
+    let configLoaderApi;
+    // Cached result from config loader (set on first transform that needs it)
+    let configResult;
+    return {
+        name: 'vendure:lingui-babel',
+        // Run BEFORE @vitejs/plugin-react so the macros are already transformed
+        // when the react plugin processes the file
+        enforce: 'pre',
+        configResolved({ plugins }) {
+            // Get reference to the config loader API.
+            // This doesn't load the config yet - that happens lazily in transform.
+            try {
+                configLoaderApi = getConfigLoaderApi(plugins);
+            }
+            catch (_a) {
+                // configLoaderPlugin not available (e.g., plugin used standalone for testing)
+            }
+        },
+        async transform(code, id) {
+            // Strip query params for path matching (Vite adds ?v=xxx for cache busting)
+            const cleanId = id.split('?')[0];
+            // Only process TypeScript/JavaScript files
+            if (!/\.[tj]sx?$/.test(cleanId)) {
+                return null;
+            }
+            // Only process files that actually contain Lingui macro imports
+            // This is a fast check to avoid running Babel on files that don't need it
+            if (!code.includes('@lingui/') || !code.includes('/macro')) {
+                return null;
+            }
+            // Check if this file should be transformed
+            if (cleanId.includes('node_modules')) {
+                // Always allow @vendure/dashboard source files
+                const isVendureDashboard = cleanId.includes('@vendure/dashboard/src') || cleanId.includes('packages/dashboard/src');
+                if (!isVendureDashboard) {
+                    // Load discovered plugins on first need (lazy loading with caching)
+                    if (configLoaderApi && !configResult) {
+                        try {
+                            configResult = await configLoaderApi.getVendureConfig();
+                            // Extract package paths from discovered npm plugins
+                            for (const plugin of configResult.pluginInfo) {
+                                if (!plugin.sourcePluginPath && plugin.pluginPath.includes('node_modules')) {
+                                    const packagePath = extractPackagePath(plugin.pluginPath);
+                                    if (packagePath) {
+                                        allowedNodeModulesPackages.add(packagePath);
+                                    }
+                                }
+                            }
+                        }
+                        catch (error) {
+                            // Log but continue - will use only manually specified paths
+                            // eslint-disable-next-line no-console
+                            console.warn('[vendure:lingui-babel] Failed to load plugin config:', error);
+                        }
+                    }
+                    // Check if this is from a discovered Vendure plugin package
+                    let isDiscoveredPlugin = false;
+                    for (const pkgPath of allowedNodeModulesPackages) {
+                        if (cleanId.includes(pkgPath)) {
+                            isDiscoveredPlugin = true;
+                            break;
+                        }
+                    }
+                    if (!isDiscoveredPlugin) {
+                        return null;
+                    }
+                }
+            }
+            try {
+                const result = await babel.transformAsync(code, {
+                    filename: id,
+                    presets: [
+                        ['@babel/preset-typescript', { isTSX: true, allExtensions: true }],
+                        ['@babel/preset-react', { runtime: 'automatic' }],
+                    ],
+                    plugins: ['@lingui/babel-plugin-lingui-macro'],
+                    sourceMaps: true,
+                    // Don't look for babel config files - we want to control the config completely
+                    configFile: false,
+                    babelrc: false,
+                });
+                if (!(result === null || result === void 0 ? void 0 : result.code)) {
+                    return null;
+                }
+                return {
+                    code: result.code,
+                    map: result.map,
+                };
+            }
+            catch (error) {
+                // Log the error but don't crash - let the build continue
+                // The lingui vite plugin will catch untransformed macros later
+                // eslint-disable-next-line no-console
+                console.error(`[vendure:lingui-babel] Failed to transform ${id}:`, error);
+                return null;
+            }
+        },
+    };
+}
+/**
+ * Extracts the npm package name from a full file path.
+ *
+ * Examples:
+ * - /path/to/node_modules/@vendure-ee/plugin/dist/index.js -> @vendure-ee/plugin
+ * - /path/to/node_modules/some-plugin/lib/index.js -> some-plugin
+ * - /path/to/node_modules/.pnpm/@vendure-ee+plugin@1.0.0/node_modules/@vendure-ee/plugin/dist/index.js -> @vendure-ee/plugin
+ */
+function extractPackagePath(filePath) {
+    // Normalize path separators
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    // Find the last occurrence of node_modules (handles pnpm structure)
+    const lastNodeModulesIndex = normalizedPath.lastIndexOf('node_modules/');
+    if (lastNodeModulesIndex === -1) {
+        return undefined;
+    }
+    const afterNodeModules = normalizedPath.slice(lastNodeModulesIndex + 'node_modules/'.length);
+    // Handle scoped packages (@scope/package)
+    if (afterNodeModules.startsWith('@')) {
+        const parts = afterNodeModules.split('/');
+        if (parts.length >= 2) {
+            return `${parts[0]}/${parts[1]}`;
+        }
+    }
+    else {
+        // Unscoped package
+        const parts = afterNodeModules.split('/');
+        if (parts.length >= 1) {
+            return parts[0];
+        }
+    }
+    return undefined;
+}

package/dist/vite/vite-plugin-tailwind-source.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from 'vite';
+/**
+ * This Vite plugin transforms the `app/styles.css` file to include a `@source` directive
+ * for each dashboard extension's source directory. This allows Tailwind CSS to
+ * include styles from these extensions when processing the CSS.
+ */
+export declare function dashboardTailwindSourcePlugin(): Plugin;

package/dist/vite/vite-plugin-tailwind-source.js

@@ -0,0 +1,48 @@
+import { getDashboardPaths } from './utils/get-dashboard-paths.js';
+import { getConfigLoaderApi } from './vite-plugin-config-loader.js';
+/**
+ * This Vite plugin transforms the `app/styles.css` file to include a `@source` directive
+ * for each dashboard extension's source directory. This allows Tailwind CSS to
+ * include styles from these extensions when processing the CSS.
+ */
+export function dashboardTailwindSourcePlugin() {
+    let configLoaderApi;
+    let loadVendureConfigResult;
+    return {
+        name: 'vendure:dashboard-tailwind-source',
+        // Ensure this plugin runs before Tailwind CSS processing
+        enforce: 'pre',
+        configResolved({ plugins }) {
+            configLoaderApi = getConfigLoaderApi(plugins);
+        },
+        async transform(src, id) {
+            if (/app\/styles.css$/.test(id)) {
+                if (!loadVendureConfigResult) {
+                    loadVendureConfigResult = await configLoaderApi.getVendureConfig();
+                }
+                const { pluginInfo } = loadVendureConfigResult;
+                const dashboardExtensionDirs = getDashboardPaths(pluginInfo);
+                const sources = dashboardExtensionDirs
+                    .map(extension => {
+                    return `@source '${extension}';`;
+                })
+                    .join('\n');
+                // Find the line with the specific comment and insert sources after it
+                const lines = src.split('\n');
+                const sourceCommentIndex = lines.findIndex(line => line.includes('/* @source rules from extensions will be added here by the dashboardTailwindSourcePlugin */'));
+                if (sourceCommentIndex !== -1) {
+                    // Insert the sources after the comment line
+                    lines.splice(sourceCommentIndex + 1, 0, sources);
+                    const modifiedSrc = lines.join('\n');
+                    return {
+                        code: modifiedSrc,
+                    };
+                }
+                // If the comment is not found, append sources at the end
+                return {
+                    code: src + '\n' + sources,
+                };
+            }
+        },
+    };
+}

package/dist/vite/vite-plugin-theme.d.ts

@@ -0,0 +1,55 @@
+import { Plugin } from 'vite';
+type ThemeColors = {
+    background?: string;
+    foreground?: string;
+    card?: string;
+    'card-foreground'?: string;
+    popover?: string;
+    'popover-foreground'?: string;
+    primary?: string;
+    'primary-foreground'?: string;
+    secondary?: string;
+    'secondary-foreground'?: string;
+    muted?: string;
+    'muted-foreground'?: string;
+    accent?: string;
+    'accent-foreground'?: string;
+    destructive?: string;
+    'destructive-foreground'?: string;
+    success?: string;
+    'success-foreground'?: string;
+    'dev-mode'?: string;
+    'dev-mode-foreground'?: string;
+    border?: string;
+    input?: string;
+    ring?: string;
+    'chart-1'?: string;
+    'chart-2'?: string;
+    'chart-3'?: string;
+    'chart-4'?: string;
+    'chart-5'?: string;
+    radius?: string;
+    sidebar?: string;
+    'sidebar-foreground'?: string;
+    'sidebar-primary'?: string;
+    'sidebar-primary-foreground'?: string;
+    'sidebar-accent'?: string;
+    'sidebar-accent-foreground'?: string;
+    'sidebar-border'?: string;
+    'sidebar-ring'?: string;
+    brand?: string;
+    'brand-lighter'?: string;
+    'brand-darker'?: string;
+    'font-sans'?: string;
+    'font-mono'?: string;
+    [key: string]: string | undefined;
+};
+export interface ThemeVariables {
+    light?: ThemeColors;
+    dark?: ThemeColors;
+}
+export type ThemeVariablesPluginOptions = {
+    theme?: ThemeVariables;
+};
+export declare function themeVariablesPlugin(options: ThemeVariablesPluginOptions): Plugin;
+export {};