@vendure/dashboard 3.4.0-minor-202506250934 → 3.4.0

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

@@ -1,343 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import tsConfigPaths from 'tsconfig-paths';
-import * as ts from 'typescript';
-import { pathToFileURL } from 'url';
-import { findConfigExport, getPluginInfo } from './ast-utils.js';
-const defaultLogger = {
-    info: (message) => {
-        /* noop */
-    },
-    warn: (message) => {
-        /* noop */
-    },
-    debug: (message) => {
-        /* noop */
-    },
-};
-/**
- * @description
- * This function compiles the given Vendure config file and any imported relative files (i.e.
- * project files, not npm packages) into a temporary directory, and returns the compiled config.
- *
- * The reason we need to do this is that Vendure code makes use of TypeScript experimental decorators
- * (e.g. for NestJS decorators and TypeORM column decorators) which are not supported by esbuild.
- *
- * In Vite, when we load some TypeScript into the top-level Vite config file (in the end-user project), Vite
- * internally uses esbuild to temporarily compile that TypeScript code. Unfortunately, esbuild does not support
- * these experimental decorators, errors will be thrown as soon as e.g. a TypeORM column decorator is encountered.
- *
- * To work around this, we compile the Vendure config file and all its imports using the TypeScript compiler,
- * which fully supports these experimental decorators. The compiled files are then loaded by Vite, which is able
- * to handle the compiled JavaScript output.
- */
-export async function loadVendureConfig(options) {
-    const { vendureConfigPath, vendureConfigExport, tempDir } = options;
-    const logger = options.logger || defaultLogger;
-    const outputPath = tempDir;
-    const configFileName = path.basename(vendureConfigPath);
-    const inputRootDir = path.dirname(vendureConfigPath);
-    await fs.remove(outputPath);
-    const pluginInfo = await compileFile({
-        inputRootDir,
-        inputPath: vendureConfigPath,
-        outputDir: outputPath,
-        logger,
-    });
-    const compiledConfigFilePath = pathToFileURL(path.join(outputPath, configFileName)).href.replace(/.ts$/, '.js');
-    // create package.json with type commonjs and save it to the output dir
-    await fs.writeFile(path.join(outputPath, 'package.json'), JSON.stringify({ type: 'commonjs' }, null, 2));
-    // We need to figure out the symbol exported by the config file by
-    // analyzing the AST and finding an export with the type "VendureConfig"
-    const sourceFile = ts.createSourceFile(vendureConfigPath, await fs.readFile(vendureConfigPath, 'utf-8'), ts.ScriptTarget.Latest, true);
-    const detectedExportedSymbolName = findConfigExport(sourceFile);
-    const configExportedSymbolName = detectedExportedSymbolName || vendureConfigExport;
-    if (!configExportedSymbolName) {
-        throw new Error(`Could not find a variable exported as VendureConfig. Please specify the name of the exported variable using the "vendureConfigExport" option.`);
-    }
-    // Register path aliases from tsconfig before importing
-    const tsConfigInfo = await findTsConfigPaths(vendureConfigPath, logger);
-    if (tsConfigInfo) {
-        tsConfigPaths.register({
-            baseUrl: outputPath,
-            paths: tsConfigInfo.paths,
-        });
-    }
-    const config = await import(compiledConfigFilePath).then(m => m[configExportedSymbolName]);
-    if (!config) {
-        throw new Error(`Could not find a variable exported as VendureConfig with the name "${configExportedSymbolName}".`);
-    }
-    return { vendureConfig: config, exportedSymbolName: configExportedSymbolName, pluginInfo };
-}
-/**
- * Finds and parses tsconfig files in the given directory and its parent directories.
- * Returns the paths configuration if found.
- */
-async function findTsConfigPaths(configPath, logger) {
-    const configDir = path.dirname(configPath);
-    let currentDir = configDir;
-    while (currentDir !== path.parse(currentDir).root) {
-        try {
-            const files = await fs.readdir(currentDir);
-            const tsConfigFiles = files.filter(file => /^tsconfig(\..*)?\.json$/.test(file));
-            for (const fileName of tsConfigFiles) {
-                const tsConfigPath = path.join(currentDir, fileName);
-                try {
-                    const tsConfigContent = await fs.readFile(tsConfigPath, 'utf-8');
-                    // Use JSON5 or similar parser if comments are expected in tsconfig.json
-                    // For simplicity, assuming standard JSON here. Handle parse errors.
-                    const tsConfig = JSON.parse(tsConfigContent);
-                    const compilerOptions = tsConfig.compilerOptions || {};
-                    if (compilerOptions.paths) {
-                        // Determine the effective baseUrl: explicitly set or the directory of tsconfig.json
-                        const tsConfigBaseUrl = path.resolve(currentDir, compilerOptions.baseUrl || '.');
-                        const paths = {};
-                        for (const [alias, patterns] of Object.entries(compilerOptions.paths)) {
-                            // Store paths as defined in tsconfig, they will be relative to baseUrl
-                            paths[alias] = patterns.map(pattern => 
-                            // Normalize slashes for consistency, keep relative
-                            pattern.replace(/\\/g, '/'));
-                        }
-                        logger.debug(`Found tsconfig paths in ${tsConfigPath}: ${JSON.stringify({
-                            baseUrl: tsConfigBaseUrl,
-                            paths,
-                        }, null, 2)}`);
-                        return { baseUrl: tsConfigBaseUrl, paths };
-                    }
-                }
-                catch (e) {
-                    logger.warn(`Could not read or parse tsconfig file ${tsConfigPath}: ${e.message}`);
-                }
-            }
-        }
-        catch (e) {
-            // If we can't read the directory, just continue to the parent
-            logger.warn(`Could not read directory ${currentDir}: ${e.message}`);
-        }
-        currentDir = path.dirname(currentDir);
-    }
-    logger.debug(`No tsconfig paths found traversing up from ${configDir}`);
-    return undefined;
-}
-export async function compileFile({ inputRootDir, inputPath, outputDir, logger = defaultLogger, compiledFiles = new Set(), isRoot = true, pluginInfo = [], reportCompilationErrors = false, }) {
-    const absoluteInputPath = path.resolve(inputPath);
-    if (compiledFiles.has(absoluteInputPath)) {
-        return pluginInfo;
-    }
-    compiledFiles.add(absoluteInputPath);
-    // Ensure output directory exists
-    await fs.ensureDir(outputDir);
-    // Read the source file
-    const source = await fs.readFile(inputPath, 'utf-8');
-    // Parse the source to find relative imports
-    const sourceFile = ts.createSourceFile(absoluteInputPath, source, ts.ScriptTarget.Latest, true);
-    const importPaths = new Set();
-    let tsConfigInfo;
-    if (isRoot) {
-        tsConfigInfo = await findTsConfigPaths(absoluteInputPath, logger);
-        if (tsConfigInfo) {
-            logger === null || logger === void 0 ? void 0 : logger.debug(`Using TypeScript configuration: ${JSON.stringify(tsConfigInfo, null, 2)}`);
-        }
-    }
-    async function collectImports(node) {
-        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
-            const importPath = node.moduleSpecifier.text;
-            // Handle relative imports
-            if (importPath.startsWith('.')) {
-                const resolvedPath = path.resolve(path.dirname(absoluteInputPath), importPath);
-                let resolvedTsPath = resolvedPath + '.ts';
-                // Also check for .tsx if .ts doesn't exist
-                if (!(await fs.pathExists(resolvedTsPath))) {
-                    const resolvedTsxPath = resolvedPath + '.tsx';
-                    if (await fs.pathExists(resolvedTsxPath)) {
-                        resolvedTsPath = resolvedTsxPath;
-                    }
-                    else {
-                        // If neither exists, maybe it's an index file?
-                        const resolvedIndexPath = path.join(resolvedPath, 'index.ts');
-                        if (await fs.pathExists(resolvedIndexPath)) {
-                            resolvedTsPath = resolvedIndexPath;
-                        }
-                        else {
-                            const resolvedIndexTsxPath = path.join(resolvedPath, 'index.tsx');
-                            if (await fs.pathExists(resolvedIndexTsxPath)) {
-                                resolvedTsPath = resolvedIndexTsxPath;
-                            }
-                            else {
-                                // If still not found, log a warning or let TS handle it later
-                                logger === null || logger === void 0 ? void 0 : logger.warn(`Could not resolve relative import "${importPath}" from "${absoluteInputPath}" to an existing .ts/.tsx file.`);
-                                // Do not add to importPaths if we can't verify existence
-                                return;
-                            }
-                        }
-                    }
-                }
-                importPaths.add(resolvedTsPath);
-            }
-            // Handle path aliases if tsConfigInfo exists
-            else if (tsConfigInfo) {
-                // Attempt to resolve using path aliases
-                let resolved = false;
-                for (const [alias, patterns] of Object.entries(tsConfigInfo.paths)) {
-                    const aliasPrefix = alias.replace('*', '');
-                    const aliasSuffix = alias.endsWith('*') ? '*' : '';
-                    if (importPath.startsWith(aliasPrefix) &&
-                        (aliasSuffix === '*' || importPath === aliasPrefix)) {
-                        const remainingImportPath = importPath.slice(aliasPrefix.length);
-                        for (const pattern of patterns) {
-                            const patternPrefix = pattern.replace('*', '');
-                            const patternSuffix = pattern.endsWith('*') ? '*' : '';
-                            // Ensure suffix match consistency (* vs exact)
-                            if (aliasSuffix !== patternSuffix)
-                                continue;
-                            const potentialPathBase = path.resolve(tsConfigInfo.baseUrl, patternPrefix);
-                            const resolvedPath = path.join(potentialPathBase, remainingImportPath);
-                            let resolvedTsPath = resolvedPath + '.ts';
-                            // Similar existence checks as relative paths
-                            if (!(await fs.pathExists(resolvedTsPath))) {
-                                const resolvedTsxPath = resolvedPath + '.tsx';
-                                if (await fs.pathExists(resolvedTsxPath)) {
-                                    resolvedTsPath = resolvedTsxPath;
-                                }
-                                else {
-                                    const resolvedIndexPath = path.join(resolvedPath, 'index.ts');
-                                    if (await fs.pathExists(resolvedIndexPath)) {
-                                        resolvedTsPath = resolvedIndexPath;
-                                    }
-                                    else {
-                                        const resolvedIndexTsxPath = path.join(resolvedPath, 'index.tsx');
-                                        if (await fs.pathExists(resolvedIndexTsxPath)) {
-                                            resolvedTsPath = resolvedIndexTsxPath;
-                                        }
-                                        else {
-                                            // Path doesn't resolve to a file for this pattern
-                                            continue;
-                                        }
-                                    }
-                                }
-                            }
-                            // Add the first successful resolution for this alias
-                            importPaths.add(resolvedTsPath);
-                            resolved = true;
-                            break; // Stop checking patterns for this alias
-                        }
-                    }
-                    if (resolved)
-                        break; // Stop checking other aliases if resolved
-                }
-            }
-            // For all other imports (node_modules, etc), we should still add them to be processed
-            // by the TypeScript compiler, even if we can't resolve them to a file
-            else {
-                // Add the import path as is - TypeScript will handle resolution
-                // importPaths.add(importPath);
-            }
-        }
-        else {
-            const children = node.getChildren();
-            for (const child of children) {
-                // Only process nodes that could contain import statements
-                if (ts.isSourceFile(child) ||
-                    ts.isModuleBlock(child) ||
-                    ts.isModuleDeclaration(child) ||
-                    ts.isImportDeclaration(child) ||
-                    child.kind === ts.SyntaxKind.SyntaxList) {
-                    await collectImports(child);
-                }
-            }
-        }
-    }
-    // Start collecting imports from the source file
-    await collectImports(sourceFile);
-    const extractedPluginInfo = getPluginInfo(sourceFile);
-    if (extractedPluginInfo) {
-        pluginInfo.push(extractedPluginInfo);
-    }
-    // Store the tsConfigInfo on the first call if found
-    const rootTsConfigInfo = isRoot ? tsConfigInfo : undefined;
-    // Recursively collect all files that need to be compiled
-    for (const importPath of importPaths) {
-        // Pass rootTsConfigInfo down, but set isRoot to false
-        await compileFile({
-            inputRootDir,
-            inputPath: importPath,
-            outputDir,
-            logger,
-            compiledFiles,
-            isRoot: false,
-            pluginInfo,
-        });
-    }
-    // If this is the root file (the one that started the compilation),
-    // use the TypeScript compiler API to compile all files together
-    if (isRoot) {
-        logger.info(`Starting compilation for ${compiledFiles.size} files...`);
-        const allFiles = Array.from(compiledFiles);
-        const compilerOptions = {
-            // Base options
-            target: ts.ScriptTarget.ES2020,
-            module: ts.ModuleKind.CommonJS, // Output CommonJS for Node compatibility
-            experimentalDecorators: true,
-            emitDecoratorMetadata: true,
-            esModuleInterop: true,
-            skipLibCheck: true, // Faster compilation
-            forceConsistentCasingInFileNames: true,
-            moduleResolution: ts.ModuleResolutionKind.NodeJs, // Use Node.js module resolution
-            incremental: false, // No need for incremental compilation
-            noEmitOnError: false, // Continue emitting even with errors
-            isolatedModules: true, // Treat files as separate modules
-            strict: false, // Disable strict type checking for speed
-            noUnusedLocals: false, // Skip unused locals check
-            noUnusedParameters: false, // Skip unused parameters check
-            // Output options
-            outDir: outputDir, // Output directory for all compiled files
-            sourceMap: false, // Generate source maps
-            declaration: false, // Don't generate .d.ts files
-            // Path resolution options - use info found from tsconfig
-            baseUrl: rootTsConfigInfo ? rootTsConfigInfo.baseUrl : undefined, // Let TS handle resolution if no baseUrl
-            paths: rootTsConfigInfo ? rootTsConfigInfo.paths : undefined,
-            // rootDir: inputRootDir, // Often inferred correctly, can cause issues if set explicitly sometimes
-            allowJs: true, // Allow JS files if needed, though we primarily collect TS
-            resolveJsonModule: true, // Allow importing JSON
-        };
-        logger.debug(`compilerOptions: ${JSON.stringify(compilerOptions, null, 2)}`);
-        // Create a Program to represent the compilation context
-        const program = ts.createProgram(allFiles, compilerOptions);
-        logger.info(`Emitting compiled files to ${outputDir}`);
-        const emitResult = program.emit();
-        if (reportCompilationErrors) {
-            const hasEmitErrors = reportDiagnostics(program, emitResult, logger);
-            if (hasEmitErrors) {
-                throw new Error('TypeScript compilation failed with errors.');
-            }
-        }
-        logger.info(`Successfully compiled ${allFiles.length} files to ${outputDir}`);
-    }
-    return pluginInfo;
-}
-function reportDiagnostics(program, emitResult, logger) {
-    const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-    let hasEmitErrors = emitResult.emitSkipped;
-    allDiagnostics.forEach(diagnostic => {
-        if (diagnostic.file && diagnostic.start) {
-            const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
-            const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-            const logFn = diagnostic.category === ts.DiagnosticCategory.Error ? logger.warn : logger.info;
-            // eslint-disable-next-line no-console
-            console.log(`TS${diagnostic.code} ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
-            if (diagnostic.category === ts.DiagnosticCategory.Error) {
-                hasEmitErrors = true;
-            }
-        }
-        else {
-            const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-            const logFn = diagnostic.category === ts.DiagnosticCategory.Error ? logger.warn : logger.info;
-            // eslint-disable-next-line no-console
-            console.log(`TS${diagnostic.code}: ${message}`);
-            if (diagnostic.category === ts.DiagnosticCategory.Error) {
-                hasEmitErrors = true;
-            }
-        }
-    });
-    return hasEmitErrors;
-}

package/dist/plugin/utils/ui-config.d.ts

@@ -1,3 +0,0 @@
-import { AdminUiConfig } from '@vendure/common/lib/shared-types';
-import { VendureConfig } from '@vendure/core';
-export declare function getAdminUiConfig(config: VendureConfig, adminUiConfig?: Partial<AdminUiConfig>): AdminUiConfig;

package/dist/plugin/utils/ui-config.js

@@ -1,34 +0,0 @@
-import { ADMIN_API_PATH, DEFAULT_AUTH_TOKEN_HEADER_KEY, DEFAULT_CHANNEL_TOKEN_KEY, } from '@vendure/common/lib/shared-constants';
-import { defaultAvailableLanguages, defaultAvailableLocales, defaultLanguage, defaultLocale, } from '../constants.js';
-export function getAdminUiConfig(config, adminUiConfig) {
-    const { authOptions, apiOptions } = config;
-    const propOrDefault = (prop, defaultVal, isArray = false) => {
-        var _a;
-        if (isArray) {
-            const isValidArray = !!adminUiConfig
-                ? !!((_a = adminUiConfig[prop]) === null || _a === void 0 ? void 0 : _a.length)
-                : false;
-            return !!adminUiConfig && isValidArray ? adminUiConfig[prop] : defaultVal;
-        }
-        else {
-            return adminUiConfig ? adminUiConfig[prop] || defaultVal : defaultVal;
-        }
-    };
-    return {
-        adminApiPath: propOrDefault('adminApiPath', apiOptions.adminApiPath || ADMIN_API_PATH),
-        apiHost: propOrDefault('apiHost', 'auto'),
-        apiPort: propOrDefault('apiPort', 'auto'),
-        tokenMethod: propOrDefault('tokenMethod', authOptions.tokenMethod === 'bearer' ? 'bearer' : 'cookie'),
-        authTokenHeaderKey: propOrDefault('authTokenHeaderKey', authOptions.authTokenHeaderKey || DEFAULT_AUTH_TOKEN_HEADER_KEY),
-        channelTokenKey: propOrDefault('channelTokenKey', apiOptions.channelTokenKey || DEFAULT_CHANNEL_TOKEN_KEY),
-        defaultLanguage: propOrDefault('defaultLanguage', defaultLanguage),
-        defaultLocale: propOrDefault('defaultLocale', defaultLocale),
-        availableLanguages: propOrDefault('availableLanguages', defaultAvailableLanguages, true),
-        availableLocales: propOrDefault('availableLocales', defaultAvailableLocales, true),
-        brand: adminUiConfig === null || adminUiConfig === void 0 ? void 0 : adminUiConfig.brand,
-        hideVendureBranding: propOrDefault('hideVendureBranding', (adminUiConfig === null || adminUiConfig === void 0 ? void 0 : adminUiConfig.hideVendureBranding) || false),
-        hideVersion: propOrDefault('hideVersion', (adminUiConfig === null || adminUiConfig === void 0 ? void 0 : adminUiConfig.hideVersion) || false),
-        loginImageUrl: adminUiConfig === null || adminUiConfig === void 0 ? void 0 : adminUiConfig.loginImageUrl,
-        cancellationReasons: propOrDefault('cancellationReasons', undefined),
-    };
-}

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

@@ -1,130 +0,0 @@
-const defaultVariables = {
-    light: {
-        background: 'hsl(0 0% 100%)',
-        foreground: 'hsl(0 0% 3.9%)',
-        card: 'hsl(0 0% 100%)',
-        'card-foreground': 'hsl(0 0% 3.9%)',
-        popover: 'hsl(0 0% 100%)',
-        'popover-foreground': 'hsl(0 0% 3.9%)',
-        primary: 'hsl(0 0% 9%)',
-        'primary-foreground': 'hsl(0 0% 98%)',
-        secondary: 'hsl(0 0% 96.1%)',
-        'secondary-foreground': 'hsl(0 0% 9%)',
-        muted: 'hsl(0 0% 96.1%)',
-        'muted-foreground': 'hsl(0 0% 45.1%)',
-        accent: 'hsl(0 0% 96.1%)',
-        'accent-foreground': 'hsl(0 0% 9%)',
-        destructive: 'hsl(0 84.2% 60.2%)',
-        'destructive-foreground': 'hsl(0 0% 98%)',
-        success: 'hsl(100, 81%, 35%)',
-        'success-foreground': 'hsl(0 0% 98%)',
-        'dev-mode': 'hsl(204, 76%, 62%)',
-        'dev-mode-foreground': 'hsl(0 0% 98%)',
-        border: 'hsl(0 0% 89.8%)',
-        input: 'hsl(0 0% 89.8%)',
-        ring: 'hsl(0 0% 3.9%)',
-        'chart-1': 'hsl(12 76% 61%)',
-        'chart-2': 'hsl(173 58% 39%)',
-        'chart-3': 'hsl(197 37% 24%)',
-        'chart-4': 'hsl(43 74% 66%)',
-        'chart-5': 'hsl(27 87% 67%)',
-        radius: '0.6rem',
-        sidebar: 'hsl(0 0% 98%)',
-        'sidebar-foreground': 'hsl(240 5.3% 26.1%)',
-        'sidebar-primary': 'hsl(240 5.9% 10%)',
-        'sidebar-primary-foreground': 'hsl(0 0% 98%)',
-        'sidebar-accent': 'hsl(0, 0%, 92%)',
-        'sidebar-accent-foreground': 'hsl(240 5.9% 10%)',
-        'sidebar-border': 'hsl(220 13% 91%)',
-        'sidebar-ring': 'hsl(217.2 91.2% 59.8%)',
-        brand: '#17c1ff',
-        'brand-lighter': '#e6f9ff',
-        'brand-darker': '#0099ff',
-        'font-sans': "'Geist', sans-serif",
-        'font-mono': "'Geist Mono', monospace",
-    },
-    dark: {
-        background: 'hsl(0 0% 3.9%)',
-        foreground: 'hsl(0 0% 98%)',
-        card: 'hsl(0 0% 3.9%)',
-        'card-foreground': 'hsl(0 0% 98%)',
-        popover: 'hsl(0 0% 3.9%)',
-        'popover-foreground': 'hsl(0 0% 98%)',
-        primary: 'hsl(0 0% 98%)',
-        'primary-foreground': 'hsl(0 0% 9%)',
-        secondary: 'hsl(0 0% 14.9%)',
-        'secondary-foreground': 'hsl(0 0% 98%)',
-        muted: 'hsl(0 0% 14.9%)',
-        'muted-foreground': 'hsl(0 0% 63.9%)',
-        accent: 'hsl(0 0% 14.9%)',
-        'accent-foreground': 'hsl(0 0% 98%)',
-        destructive: 'hsl(0 62.8% 30.6%)',
-        'destructive-foreground': 'hsl(0 0% 98%)',
-        success: 'hsl(100, 100%, 35%)',
-        'success-foreground': 'hsl(0 0% 98%)',
-        'dev-mode': 'hsl(204, 86%, 53%)',
-        'dev-mode-foreground': 'hsl(0 0% 98%)',
-        border: 'hsl(0 0% 14.9%)',
-        input: 'hsl(0 0% 14.9%)',
-        ring: 'hsl(0 0% 83.1%)',
-        'chart-1': 'hsl(220 70% 50%)',
-        'chart-2': 'hsl(160 60% 45%)',
-        'chart-3': 'hsl(30 80% 55%)',
-        'chart-4': 'hsl(280 65% 60%)',
-        'chart-5': 'hsl(340 75% 55%)',
-        sidebar: 'hsl(240 5.9% 10%)',
-        'sidebar-foreground': 'hsl(240 4.8% 95.9%)',
-        'sidebar-primary': 'hsl(224.3 76.3% 48%)',
-        'sidebar-primary-foreground': 'hsl(0 0% 100%)',
-        'sidebar-accent': 'hsl(240 3.7% 15.9%)',
-        'sidebar-accent-foreground': 'hsl(240 4.8% 95.9%)',
-        'sidebar-border': 'hsl(240 3.7% 15.9%)',
-        'sidebar-ring': 'hsl(217.2 91.2% 59.8%)',
-        brand: '#17c1ff',
-        'brand-lighter': '#e6f9ff',
-        'brand-darker': '#0099ff',
-        'font-sans': "'Geist', sans-serif",
-        'font-mono': "'Geist Mono', monospace",
-    },
-};
-export function themeVariablesPlugin(options) {
-    const virtualModuleId = 'virtual:admin-theme';
-    const resolvedVirtualModuleId = `\0${virtualModuleId}`;
-    return {
-        name: 'vendure:admin-theme',
-        enforce: 'pre', // This ensures our plugin runs before other CSS processors
-        transform(code, id) {
-            var _a, _b;
-            // Only transform CSS files
-            if (!id.endsWith('styles.css')) {
-                return null;
-            }
-            // Replace the @import 'virtual:admin-theme'; with our theme variables
-            if (code.includes('@import "virtual:admin-theme";') ||
-                code.includes("@import 'virtual:admin-theme';")) {
-                const lightTheme = ((_a = options.theme) === null || _a === void 0 ? void 0 : _a.light) || {};
-                const darkTheme = ((_b = options.theme) === null || _b === void 0 ? void 0 : _b.dark) || {};
-                // Merge default themes with custom themes
-                const mergedLightTheme = Object.assign(Object.assign({}, defaultVariables.light), lightTheme);
-                const mergedDarkTheme = Object.assign(Object.assign({}, defaultVariables.dark), darkTheme);
-                const themeCSS = `
-                    :root {
-                        ${Object.entries(mergedLightTheme)
-                    .filter(([key, value]) => value !== undefined)
-                    .map(([key, value]) => `--${key}: ${value};`)
-                    .join('\n')}
-                    }
-
-                    .dark {
-                        ${Object.entries(mergedDarkTheme)
-                    .filter(([key, value]) => value !== undefined)
-                    .map(([key, value]) => `--${key}: ${value};`)
-                    .join('\n')}
-                    }
-                `;
-                return code.replace(/@import ['"]virtual:admin-theme['"];?/, themeCSS);
-            }
-            return null;
-        },
-    };
-}

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

@@ -1,15 +0,0 @@
-import { AdminUiConfig } from '@vendure/core';
-import { Plugin } from 'vite';
-export type UiConfigPluginOptions = {
-    /**
-     * @description
-     * The admin UI config to be passed to the Vendure Dashboard.
-     */
-    adminUiConfig?: Partial<AdminUiConfig>;
-};
-/**
- * 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 uiConfigPlugin({ adminUiConfig }: UiConfigPluginOptions): Plugin;

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

@@ -1,44 +0,0 @@
-import { PluginOption } from 'vite';
-import { ThemeVariablesPluginOptions } from './vite-plugin-theme.js';
-import { UiConfigPluginOptions } from './vite-plugin-ui-config.js';
-/**
- * @description
- * Options for the {@link vendureDashboardPlugin} Vite plugin.
- */
-export type VitePluginVendureDashboardOptions = {
-    /**
-     * @description
-     * The path to the Vendure server configuration file.
-     */
-    vendureConfigPath: string | URL;
-    /**
-     * @description
-     * The name of the exported variable from the Vendure server configuration file.
-     * This is only required if the plugin is unable to auto-detect the name of the exported variable.
-     */
-    vendureConfigExport?: string;
-    /**
-     * @description
-     * The path to the directory where the generated GraphQL Tada files will be output.
-     */
-    gqlTadaOutputPath?: string;
-    tempCompilationDir?: string;
-    disableTansStackRouterPlugin?: boolean;
-    /**
-     * @description
-     * If set to `true`, compilation errors during the build process will be reported and
-     * the build will fail.
-     *
-     * @default false
-     */
-    reportCompilationErrors?: boolean;
-} & UiConfigPluginOptions & ThemeVariablesPluginOptions;
-/**
- * @description
- * This is a Vite plugin which configures a set of plugins required to build the Vendure Dashboard.
- */
-export declare function vendureDashboardPlugin(options: VitePluginVendureDashboardOptions): PluginOption[];
-/**
- * Get the normalized path to the Vendure config file given either a string or URL.
- */
-export declare function getNormalizedVendureConfigPath(vendureConfigPath: string | URL): string;

package/src/lib/framework/alert/types.ts

@@ -1,13 +0,0 @@
-export interface DashboardAlertDefinition<TResponse = any> {
-    id: string;
-    title: string | ((data: TResponse) => string);
-    description?: string | ((data: TResponse) => string);
-    severity: 'info' | 'warning' | 'error';
-    check: () => Promise<TResponse> | TResponse;
-    recheckInterval?: number;
-    shouldShow?: (data: TResponse) => boolean;
-    actions?: Array<{
-        label: string;
-        onClick: (data: TResponse) => void;
-    }>;
-}

package/src/lib/framework/dashboard-widget/types.ts

@@ -1,22 +0,0 @@
-import { DashboardBaseWidgetProps } from './base-widget.js';
-
-export type DashboardWidgetInstance = {
-    id: string;
-    widgetId: string;
-    layout: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    };
-    config?: Record<string, unknown>;
-};
-
-export type DashboardWidgetDefinition = {
-    id: string;
-    name: string;
-    component: React.ComponentType<DashboardBaseWidgetProps>;
-    defaultSize: { w: number; h: number; x?: number; y?: number };
-    minSize?: { w: number; h: number };
-    maxSize?: { w: number; h: number };
-};