@wilshop/dashboard 3.5.2

package/dist/vite/utils/compiler.js

@@ -0,0 +1,165 @@
+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 } from './ast-utils.js';
+import { noopLogger } from './logger.js';
+import { discoverPlugins } from './plugin-discovery.js';
+import { findTsConfigPaths } from './tsconfig-utils.js';
+const defaultPathAdapter = {
+    getCompiledConfigPath: ({ outputPath, configFileName }) => path.join(outputPath, configFileName),
+    transformTsConfigPathMappings: ({ patterns }) => patterns,
+};
+/**
+ * Compiles TypeScript files and discovers Vendure plugins in both the compiled output
+ * and in node_modules.
+ */
+export async function compile(options) {
+    var _a, _b, _c;
+    const { vendureConfigPath, outputPath, pathAdapter, logger = noopLogger, pluginPackageScanner } = options;
+    const getCompiledConfigPath = (_a = pathAdapter === null || pathAdapter === void 0 ? void 0 : pathAdapter.getCompiledConfigPath) !== null && _a !== void 0 ? _a : defaultPathAdapter.getCompiledConfigPath;
+    const transformTsConfigPathMappings = (_b = pathAdapter === null || pathAdapter === void 0 ? void 0 : pathAdapter.transformTsConfigPathMappings) !== null && _b !== void 0 ? _b : defaultPathAdapter.transformTsConfigPathMappings;
+    // 0. Clear the outputPath
+    fs.removeSync(outputPath);
+    // 1. Compile TypeScript files
+    const compileStart = Date.now();
+    await compileTypeScript({
+        inputPath: vendureConfigPath,
+        outputPath,
+        logger,
+        transformTsConfigPathMappings,
+        module: (_c = options.module) !== null && _c !== void 0 ? _c : 'commonjs',
+    });
+    logger.info(`TypeScript compilation completed in ${Date.now() - compileStart}ms`);
+    // 2. Discover plugins
+    const analyzePluginsStart = Date.now();
+    const plugins = await discoverPlugins({
+        vendureConfigPath,
+        transformTsConfigPathMappings,
+        logger,
+        outputPath,
+        pluginPackageScanner,
+    });
+    logger.info(`Analyzed plugins and found ${plugins.length} dashboard extensions in ${Date.now() - analyzePluginsStart}ms`);
+    // 3. Load the compiled config
+    const configFileName = path.basename(vendureConfigPath);
+    const compiledConfigFilePath = pathToFileURL(getCompiledConfigPath({
+        inputRootDir: path.dirname(vendureConfigPath),
+        outputPath,
+        configFileName,
+    })).href.replace(/.ts$/, '.js');
+    // Create package.json with type commonjs
+    await fs.writeFile(path.join(outputPath, 'package.json'), JSON.stringify({ type: options.module === 'esm' ? 'module' : 'commonjs', private: true }, null, 2));
+    // Find the exported config symbol
+    const sourceFile = ts.createSourceFile(vendureConfigPath, await fs.readFile(vendureConfigPath, 'utf-8'), ts.ScriptTarget.Latest, true);
+    const exportedSymbolName = findConfigExport(sourceFile);
+    if (!exportedSymbolName) {
+        throw new Error(`Could not find a variable exported as VendureConfig. Please specify the name of the exported variable.`);
+    }
+    const loadConfigStart = Date.now();
+    await registerTsConfigPaths({
+        outputPath,
+        configPath: vendureConfigPath,
+        logger,
+        phase: 'loading',
+        transformTsConfigPathMappings,
+    });
+    let config;
+    try {
+        config = await import(compiledConfigFilePath).then(m => m[exportedSymbolName]);
+    }
+    catch (e) {
+        logger.error(`Error loading config: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (!config) {
+        throw new Error(`Could not find a variable exported as VendureConfig with the name "${exportedSymbolName}".`);
+    }
+    logger.debug(`Loaded config in ${Date.now() - loadConfigStart}ms`);
+    return { vendureConfig: config, exportedSymbolName, pluginInfo: plugins };
+}
+/**
+ * Compiles TypeScript files to JavaScript
+ */
+async function compileTypeScript({ inputPath, outputPath, logger, transformTsConfigPathMappings, module, }) {
+    var _a;
+    await fs.ensureDir(outputPath);
+    // Find tsconfig paths first
+    const tsConfigInfo = await findTsConfigPaths(inputPath, logger, 'compiling', transformTsConfigPathMappings);
+    const compilerOptions = {
+        target: ts.ScriptTarget.ES2020,
+        module: module === 'esm' ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS,
+        moduleResolution: ts.ModuleResolutionKind.Node10, // More explicit CJS resolution
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        noEmit: false,
+        // Speed optimizations
+        noEmitOnError: false, // Emit output even if there are errors
+        noImplicitAny: false, // Don't require implicit any
+        noUnusedLocals: false, // Don't check for unused locals
+        noUnusedParameters: false, // Don't check for unused parameters
+        allowJs: true,
+        checkJs: false, // Don't type check JS files
+        skipDefaultLibCheck: true, // Skip checking .d.ts files
+        isolatedModules: false, // Need to check cross-file references to compile dependencies
+        incremental: false, // Don't use incremental compilation (faster for one-off builds)
+        resolveJsonModule: true,
+        preserveSymlinks: false,
+        outDir: outputPath,
+    };
+    logger.debug(`Compiling ${inputPath} to ${outputPath} using TypeScript...`);
+    // Add path mappings if found
+    if (tsConfigInfo) {
+        // We need to set baseUrl and paths for TypeScript to resolve the imports
+        compilerOptions.baseUrl = tsConfigInfo.baseUrl;
+        compilerOptions.paths = tsConfigInfo.paths;
+        // This is critical - it tells TypeScript to preserve the paths in the output
+        // compilerOptions.rootDir = tsConfigInfo.baseUrl;
+    }
+    logger.debug(`tsConfig paths: ${JSON.stringify(tsConfigInfo === null || tsConfigInfo === void 0 ? void 0 : tsConfigInfo.paths, null, 2)}`);
+    logger.debug(`tsConfig baseUrl: ${(_a = tsConfigInfo === null || tsConfigInfo === void 0 ? void 0 : tsConfigInfo.baseUrl) !== null && _a !== void 0 ? _a : 'UNKNOWN'}`);
+    // Create a custom transformer to rewrite the output paths
+    const customTransformers = {
+        after: [
+            context => {
+                return sourceFile => {
+                    // Only transform files that are not the entry point
+                    if (sourceFile.fileName === inputPath) {
+                        return sourceFile;
+                    }
+                    sourceFile.fileName = path.join(outputPath, path.basename(sourceFile.fileName));
+                    return sourceFile;
+                };
+            },
+        ],
+    };
+    const program = ts.createProgram([inputPath], compilerOptions);
+    const emitResult = program.emit(undefined, undefined, undefined, undefined, customTransformers);
+    // Only log actual emit errors, not type errors
+    if (emitResult.emitSkipped) {
+        for (const diagnostic of emitResult.diagnostics) {
+            if (diagnostic.file && diagnostic.start !== undefined) {
+                const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+                const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+                logger.warn(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+            }
+            else {
+                logger.warn(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'));
+            }
+        }
+    }
+}
+async function registerTsConfigPaths(options) {
+    const { outputPath, configPath, logger, phase, transformTsConfigPathMappings } = options;
+    const tsConfigInfo = await findTsConfigPaths(configPath, logger, phase, transformTsConfigPathMappings);
+    if (tsConfigInfo) {
+        const params = {
+            baseUrl: outputPath,
+            paths: tsConfigInfo.paths,
+        };
+        logger.debug(`Registering tsconfig paths: ${JSON.stringify(params, null, 2)}`);
+        tsConfigPaths.register(params);
+    }
+}

package/dist/vite/utils/get-dashboard-paths.d.ts

@@ -0,0 +1,5 @@
+import { PluginInfo } from '../types.js';
+/**
+ * Returns an array of the paths to plugins, based on the info provided by the ConfigLoaderApi.
+ */
+export declare function getDashboardPaths(pluginInfo: PluginInfo[]): string[];

package/dist/vite/utils/get-dashboard-paths.js

@@ -0,0 +1,20 @@
+import path from 'path';
+/**
+ * Returns an array of the paths to plugins, based on the info provided by the ConfigLoaderApi.
+ */
+export function getDashboardPaths(pluginInfo) {
+    var _a;
+    return ((_a = pluginInfo === null || pluginInfo === void 0 ? void 0 : pluginInfo.flatMap(({ dashboardEntryPath, sourcePluginPath, pluginPath }) => {
+        if (!dashboardEntryPath) {
+            return [];
+        }
+        const sourcePaths = [];
+        if (sourcePluginPath) {
+            sourcePaths.push(path.join(path.dirname(sourcePluginPath), path.dirname(dashboardEntryPath)));
+        }
+        if (pluginPath) {
+            sourcePaths.push(path.join(path.dirname(pluginPath), path.dirname(dashboardEntryPath)));
+        }
+        return sourcePaths;
+    }).filter(x => x != null)) !== null && _a !== void 0 ? _a : []);
+}

package/dist/vite/utils/logger.d.ts

@@ -0,0 +1,3 @@
+import { Logger } from '../types.js';
+export declare const debugLogger: Logger;
+export declare const noopLogger: Logger;

package/dist/vite/utils/logger.js

@@ -0,0 +1,39 @@
+// ANSI color codes
+const colors = {
+    grey: '\x1b[90m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    reset: '\x1b[0m',
+};
+export const debugLogger = {
+    info: (message) => {
+        // eslint-disable-next-line no-console
+        console.log(`[INFO] ${message}`);
+    },
+    warn: (message) => {
+        // eslint-disable-next-line no-console
+        console.warn(`${colors.yellow}[WARN] ${message}${colors.reset}`);
+    },
+    debug: (message) => {
+        // eslint-disable-next-line no-console
+        console.debug(`${colors.grey}[DEBUG] ${message}${colors.reset}`);
+    },
+    error: (message) => {
+        // eslint-disable-next-line no-console
+        console.error(`${colors.red}[ERROR] ${message}${colors.reset}`);
+    },
+};
+export const noopLogger = {
+    info: () => {
+        /* noop */
+    },
+    warn: () => {
+        /* noop */
+    },
+    debug: () => {
+        /* noop */
+    },
+    error: () => {
+        /* noop */
+    },
+};

package/dist/vite/utils/plugin-discovery.d.ts

@@ -0,0 +1,27 @@
+import { Logger, PluginInfo, TransformTsConfigPathMappingsFn } from '../types.js';
+import { PackageScannerConfig } from './compiler.js';
+export declare function discoverPlugins({ vendureConfigPath, transformTsConfigPathMappings, logger, outputPath, pluginPackageScanner, }: {
+    vendureConfigPath: string;
+    transformTsConfigPathMappings: TransformTsConfigPathMappingsFn;
+    logger: Logger;
+    outputPath: string;
+    pluginPackageScanner?: PackageScannerConfig;
+}): Promise<PluginInfo[]>;
+/**
+ * Analyzes TypeScript source files starting from the config file to discover:
+ * 1. Local Vendure plugins
+ * 2. All non-local package imports that could contain plugins
+ */
+export declare function analyzeSourceFiles(vendureConfigPath: string, nodeModulesRoot: string, logger: Logger, transformTsConfigPathMappings: TransformTsConfigPathMappingsFn): Promise<{
+    localPluginLocations: Map<string, string>;
+    packageImports: string[];
+}>;
+interface FindPluginFilesOptions {
+    outputPath: string;
+    vendureConfigPath: string;
+    logger: Logger;
+    packageGlobs: string[];
+    nodeModulesRoot?: string;
+}
+export declare function findVendurePluginFiles({ outputPath, vendureConfigPath, logger, nodeModulesRoot: providedNodeModulesRoot, packageGlobs, }: FindPluginFilesOptions): Promise<string[]>;
+export {};

package/dist/vite/utils/plugin-discovery.js

@@ -0,0 +1,398 @@
+import { parse } from 'acorn';
+import { simple as walkSimple } from 'acorn-walk';
+import glob from 'fast-glob';
+import fs from 'fs-extra';
+import { open } from 'fs/promises';
+import path from 'path';
+import * as ts from 'typescript';
+import { fileURLToPath } from 'url';
+import { findTsConfigPaths } from './tsconfig-utils.js';
+export async function discoverPlugins({ vendureConfigPath, transformTsConfigPathMappings, logger, outputPath, pluginPackageScanner, }) {
+    var _a;
+    const plugins = [];
+    // Analyze source files to find local plugins and package imports
+    const { localPluginLocations, packageImports } = await analyzeSourceFiles(vendureConfigPath, (_a = pluginPackageScanner === null || pluginPackageScanner === void 0 ? void 0 : pluginPackageScanner.nodeModulesRoot) !== null && _a !== void 0 ? _a : guessNodeModulesRoot(vendureConfigPath, logger), logger, transformTsConfigPathMappings);
+    logger.debug(`[discoverPlugins] Found ${localPluginLocations.size} local plugins: ${JSON.stringify([...localPluginLocations.entries()], null, 2)}`);
+    logger.debug(`[discoverPlugins] Found ${packageImports.length} package imports: ${JSON.stringify(packageImports, null, 2)}`);
+    const filePaths = await findVendurePluginFiles({
+        logger,
+        nodeModulesRoot: pluginPackageScanner === null || pluginPackageScanner === void 0 ? void 0 : pluginPackageScanner.nodeModulesRoot,
+        packageGlobs: packageImports.map(pkg => pkg + '/**/*.js'),
+        outputPath,
+        vendureConfigPath,
+    });
+    for (const filePath of filePaths) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        logger.debug(`[discoverPlugins] Checking file ${filePath}`);
+        // First check if this file imports from @vendure/core
+        if (!content.includes('@vendure/core')) {
+            continue;
+        }
+        try {
+            const ast = parse(content, {
+                ecmaVersion: 'latest',
+                sourceType: 'module',
+            });
+            let hasVendurePlugin = false;
+            let pluginName;
+            let dashboardPath;
+            // Walk the AST to find the plugin class and its decorator
+            walkSimple(ast, {
+                CallExpression(node) {
+                    var _a;
+                    // Look for __decorate calls
+                    const calleeName = node.callee.name;
+                    const nodeArgs = node.arguments;
+                    const isDecoratorWithArgs = calleeName === '__decorate' && nodeArgs.length >= 2;
+                    if (isDecoratorWithArgs) {
+                        // Check the decorators array (first argument)
+                        const decorators = nodeArgs[0];
+                        if (decorators.type === 'ArrayExpression') {
+                            for (const decorator of decorators.elements) {
+                                const props = getDecoratorObjectProps(decorator);
+                                for (const prop of props) {
+                                    if (prop.key.name === 'dashboard') {
+                                        if (prop.value.type === 'Literal') {
+                                            // Handle string format: dashboard: './path/to/dashboard'
+                                            dashboardPath = prop.value.value;
+                                            hasVendurePlugin = true;
+                                        }
+                                        else if (prop.value.type === 'ObjectExpression') {
+                                            // Handle object format: dashboard: { location: './path/to/dashboard' }
+                                            const locationProp = (_a = prop.value.properties) === null || _a === void 0 ? void 0 : _a.find((p) => { var _a; return ((_a = p.key) === null || _a === void 0 ? void 0 : _a.name) === 'location'; });
+                                            if (locationProp && locationProp.value.type === 'Literal') {
+                                                dashboardPath = locationProp.value.value;
+                                                hasVendurePlugin = true;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        // Get the plugin class name (second argument)
+                        const targetClass = nodeArgs[1];
+                        if (targetClass.type === 'Identifier') {
+                            pluginName = targetClass.name;
+                        }
+                    }
+                },
+            });
+            if (hasVendurePlugin && pluginName && dashboardPath) {
+                logger.debug(`[discoverPlugins] Found plugin "${pluginName}" in file: ${filePath}`);
+                // Keep the dashboard path relative to the plugin file
+                const resolvedDashboardPath = dashboardPath.startsWith('.')
+                    ? dashboardPath // Keep the relative path as-is
+                    : './' + path.relative(path.dirname(filePath), dashboardPath); // Make absolute path relative
+                // Check if this is a local plugin we found earlier
+                const sourcePluginPath = localPluginLocations.get(pluginName);
+                plugins.push(Object.assign({ name: pluginName, pluginPath: filePath, dashboardEntryPath: resolvedDashboardPath }, (sourcePluginPath && { sourcePluginPath })));
+            }
+        }
+        catch (e) {
+            logger.error(`Failed to parse ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return plugins;
+}
+function getDecoratorObjectProps(decorator) {
+    var _a;
+    if (decorator.type === 'CallExpression' &&
+        decorator.arguments.length === 1 &&
+        decorator.arguments[0].type === 'ObjectExpression') {
+        // Look for the dashboard property in the decorator config
+        return (_a = decorator.arguments[0].properties) !== null && _a !== void 0 ? _a : [];
+    }
+    return [];
+}
+async function isSymlinkedLocalPackage(packageName, nodeModulesRoot) {
+    try {
+        const packagePath = path.join(nodeModulesRoot, packageName);
+        const stats = await fs.lstat(packagePath);
+        if (stats.isSymbolicLink()) {
+            // Get the real path that the symlink points to
+            const realPath = await fs.realpath(packagePath);
+            // If the real path is within the project directory (i.e. not in some other node_modules),
+            // then it's a local package
+            if (!realPath.includes('node_modules')) {
+                return realPath;
+            }
+        }
+    }
+    catch (e) {
+        // Package doesn't exist or other error - not a local package
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Analyzes TypeScript source files starting from the config file to discover:
+ * 1. Local Vendure plugins
+ * 2. All non-local package imports that could contain plugins
+ */
+export async function analyzeSourceFiles(vendureConfigPath, nodeModulesRoot, logger, transformTsConfigPathMappings) {
+    const localPluginLocations = new Map();
+    const visitedFiles = new Set();
+    const packageImportsSet = new Set();
+    // Get tsconfig paths for resolving aliases
+    const tsConfigInfo = await findTsConfigPaths(vendureConfigPath, logger, 'compiling', transformTsConfigPathMappings);
+    async function processFile(filePath) {
+        if (visitedFiles.has(filePath)) {
+            return;
+        }
+        visitedFiles.add(filePath);
+        try {
+            // First check if this is a directory
+            const stat = await fs.stat(filePath);
+            if (stat.isDirectory()) {
+                // If it's a directory, try to find the plugin file
+                const indexFilePath = path.join(filePath, 'index.ts');
+                if (await fs.pathExists(indexFilePath)) {
+                    await processFile(indexFilePath);
+                }
+                return;
+            }
+            const content = await fs.readFile(filePath, 'utf-8');
+            const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+            // Track imports to follow
+            const importsToFollow = [];
+            async function visit(node) {
+                // Look for VendurePlugin decorator
+                const vendurePluginClassName = getVendurePluginClassName(node);
+                if (vendurePluginClassName) {
+                    localPluginLocations.set(vendurePluginClassName, filePath);
+                    logger.debug(`Found plugin "${vendurePluginClassName}" at ${filePath}`);
+                }
+                // Handle both imports and exports
+                const isImportOrExport = ts.isImportDeclaration(node) || ts.isExportDeclaration(node);
+                if (isImportOrExport) {
+                    const moduleSpecifier = node.moduleSpecifier;
+                    if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+                        const importPath = moduleSpecifier.text;
+                        // Track non-local imports (packages)
+                        const npmPackageName = getNpmPackageNameFromImport(importPath);
+                        if (npmPackageName) {
+                            // Check if this is actually a symlinked local package
+                            const localPackagePath = await isSymlinkedLocalPackage(npmPackageName, nodeModulesRoot);
+                            if (localPackagePath) {
+                                // If it is local, follow it like a local import
+                                importsToFollow.push(localPackagePath);
+                                logger.debug(`Found symlinked local package "${npmPackageName}" at ${localPackagePath}`);
+                            }
+                            else {
+                                packageImportsSet.add(npmPackageName);
+                            }
+                        }
+                        // Handle path aliases and local imports
+                        const pathAliasImports = getPotentialPathAliasImportPaths(importPath, tsConfigInfo);
+                        if (pathAliasImports.length) {
+                            importsToFollow.push(...pathAliasImports);
+                        }
+                        // Also handle local imports
+                        if (importPath.startsWith('.')) {
+                            const resolvedPath = path.resolve(path.dirname(filePath), importPath);
+                            importsToFollow.push(resolvedPath);
+                        }
+                    }
+                }
+                // Visit children
+                const promises = [];
+                ts.forEachChild(node, child => {
+                    promises.push(visit(child));
+                });
+                await Promise.all(promises);
+            }
+            await visit(sourceFile);
+            // Follow imports
+            for (const importPath of importsToFollow) {
+                // Try all possible file paths
+                const possiblePaths = [
+                    importPath + '.ts',
+                    importPath + '.js',
+                    path.join(importPath, 'index.ts'),
+                    path.join(importPath, 'index.js'),
+                    importPath,
+                ];
+                if (importPath.endsWith('.js')) {
+                    possiblePaths.push(importPath.replace(/.js$/, '.ts'));
+                }
+                // Try each possible path
+                let found = false;
+                for (const possiblePath of possiblePaths) {
+                    const possiblePathExists = await fs.pathExists(possiblePath);
+                    if (possiblePathExists) {
+                        await processFile(possiblePath);
+                        found = true;
+                        break;
+                    }
+                }
+                // If none of the file paths worked, try the raw import path
+                // (it might be a directory)
+                const tryRawPath = !found && (await fs.pathExists(importPath));
+                if (tryRawPath) {
+                    await processFile(importPath);
+                }
+            }
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            logger.error(`Failed to process ${filePath}: ${message}`);
+        }
+    }
+    await processFile(vendureConfigPath);
+    return {
+        localPluginLocations,
+        packageImports: Array.from(packageImportsSet),
+    };
+}
+/**
+ * If this is a class declaration that is decorated with the `VendurePlugin` decorator,
+ * we want to return that class name, as we have found a local Vendure plugin.
+ */
+function getVendurePluginClassName(node) {
+    var _a;
+    if (ts.isClassDeclaration(node)) {
+        const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined;
+        if (decorators === null || decorators === void 0 ? void 0 : decorators.length) {
+            for (const decorator of decorators) {
+                const decoratorName = getDecoratorName(decorator);
+                if (decoratorName === 'VendurePlugin') {
+                    const className = (_a = node.name) === null || _a === void 0 ? void 0 : _a.text;
+                    if (className) {
+                        return className;
+                    }
+                }
+            }
+        }
+    }
+}
+function getNpmPackageNameFromImport(importPath) {
+    if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
+        // Get the root package name (e.g. '@scope/package/subpath' -> '@scope/package')
+        const packageName = importPath.startsWith('@')
+            ? importPath.split('/').slice(0, 2).join('/')
+            : importPath.split('/')[0];
+        return packageName;
+    }
+}
+function getPotentialPathAliasImportPaths(importPath, tsConfigInfo) {
+    const importsToFollow = [];
+    if (!tsConfigInfo) {
+        return importsToFollow;
+    }
+    for (const [alias, patterns] of Object.entries(tsConfigInfo.paths)) {
+        const aliasPattern = alias.replace(/\*$/, '');
+        if (importPath.startsWith(aliasPattern)) {
+            const relativePart = importPath.slice(aliasPattern.length);
+            // Try each pattern
+            for (const pattern of patterns) {
+                const resolvedPattern = pattern.replace(/\*$/, '');
+                const resolvedPath = path.resolve(tsConfigInfo.baseUrl, resolvedPattern, relativePart);
+                importsToFollow.push(resolvedPath);
+            }
+        }
+    }
+    return importsToFollow;
+}
+function getDecoratorName(decorator) {
+    if (ts.isCallExpression(decorator.expression)) {
+        const expression = decorator.expression.expression;
+        // Handle both direct usage and imported usage
+        if (ts.isIdentifier(expression)) {
+            return expression.text;
+        }
+        // Handle property access like `Decorators.VendurePlugin`
+        if (ts.isPropertyAccessExpression(expression)) {
+            return expression.name.text;
+        }
+    }
+    return undefined;
+}
+export async function findVendurePluginFiles({ outputPath, vendureConfigPath, logger, nodeModulesRoot: providedNodeModulesRoot, packageGlobs, }) {
+    let nodeModulesRoot = providedNodeModulesRoot;
+    const readStart = Date.now();
+    if (!nodeModulesRoot) {
+        nodeModulesRoot = guessNodeModulesRoot(vendureConfigPath, logger);
+    }
+    const patterns = [
+        // Local compiled plugins in temp dir
+        path.join(outputPath, '**/*.js'),
+        // Node modules patterns
+        ...packageGlobs.map(pattern => path.join(nodeModulesRoot, pattern)),
+    ].map(p => p.replace(/\\/g, '/'));
+    logger.debug(`Finding Vendure plugins using patterns: ${patterns.join('\n')}`);
+    const globStart = Date.now();
+    const files = await glob(patterns, {
+        ignore: [
+            // Standard test & doc files
+            '**/node_modules/**/node_modules/**',
+            '**/*.spec.js',
+            '**/*.test.js',
+        ],
+        onlyFiles: true,
+        absolute: true,
+        followSymbolicLinks: false,
+        stats: false,
+    });
+    logger.debug(`Glob found ${files.length} files in ${Date.now() - globStart}ms`);
+    // Read files in larger parallel batches
+    const batchSize = 100; // Increased batch size
+    const potentialPluginFiles = [];
+    for (let i = 0; i < files.length; i += batchSize) {
+        const batch = files.slice(i, i + batchSize);
+        const results = await Promise.all(batch.map(async (file) => {
+            try {
+                // Try reading just first 3000 bytes first - most imports are at the top
+                const fileHandle = await open(file, 'r');
+                try {
+                    const buffer = Buffer.alloc(3000);
+                    const { bytesRead } = await fileHandle.read(buffer, 0, 3000, 0);
+                    let content = buffer.toString('utf8', 0, bytesRead);
+                    // Quick check for common indicators
+                    if (content.includes('@vendure/core')) {
+                        return file;
+                    }
+                    // If we find a promising indicator but no definitive match,
+                    // read more of the file
+                    if (content.includes('@vendure') || content.includes('VendurePlugin')) {
+                        const largerBuffer = Buffer.alloc(5000);
+                        const { bytesRead: moreBytes } = await fileHandle.read(largerBuffer, 0, 5000, 0);
+                        content = largerBuffer.toString('utf8', 0, moreBytes);
+                        if (content.includes('@vendure/core')) {
+                            return file;
+                        }
+                    }
+                }
+                finally {
+                    await fileHandle.close();
+                }
+            }
+            catch (e) {
+                logger.warn(`Failed to read file ${file}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            return null;
+        }));
+        const validResults = results.filter((f) => f !== null);
+        potentialPluginFiles.push(...validResults);
+    }
+    logger.info(`Found ${potentialPluginFiles.length} potential plugin files in ${Date.now() - readStart}ms ` +
+        `(scanned ${files.length} files)`);
+    return potentialPluginFiles;
+}
+function guessNodeModulesRoot(vendureConfigPath, logger) {
+    let nodeModulesRoot;
+    // If the node_modules root path has not been explicitly
+    // specified, we will try to guess it by resolving the
+    // `@vendure/core` package.
+    try {
+        const coreUrl = import.meta.resolve('@vendure/core');
+        logger.debug(`Found core URL: ${coreUrl}`);
+        const corePath = fileURLToPath(coreUrl);
+        logger.debug(`Found core path: ${corePath}`);
+        nodeModulesRoot = path.join(path.dirname(corePath), '..', '..', '..');
+    }
+    catch (e) {
+        logger.warn(`Failed to resolve @vendure/core: ${e instanceof Error ? e.message : String(e)}`);
+        nodeModulesRoot = path.dirname(vendureConfigPath);
+    }
+    return nodeModulesRoot;
+}

package/dist/vite/utils/schema-generator.d.ts

@@ -0,0 +1,10 @@
+import { VendureConfig } from '@vendure/core';
+import { GraphQLSchema } from 'graphql';
+/**
+ * @description
+ * This function generates a GraphQL schema from the Vendure config.
+ * It is used to generate the schema for the dashboard.
+ */
+export declare function generateSchema({ vendureConfig, }: {
+    vendureConfig: VendureConfig;
+}): Promise<GraphQLSchema>;