@vendure/dashboard 3.4.0-minor-202506250934 → 3.4.0

package/dist/vite/constants.js

@@ -0,0 +1,277 @@
+import { LanguageCode } from '@vendure/core';
+export const defaultLanguage = LanguageCode.en;
+export const defaultLocale = undefined;
+export const defaultAvailableLanguages = [
+    LanguageCode.he,
+    LanguageCode.ar,
+    LanguageCode.de,
+    LanguageCode.en,
+    LanguageCode.es,
+    LanguageCode.pl,
+    LanguageCode.zh_Hans,
+    LanguageCode.zh_Hant,
+    LanguageCode.pt_BR,
+    LanguageCode.pt_PT,
+    LanguageCode.cs,
+    LanguageCode.fr,
+    LanguageCode.ru,
+    LanguageCode.uk,
+    LanguageCode.it,
+    LanguageCode.fa,
+    LanguageCode.ne,
+    LanguageCode.hr,
+    LanguageCode.sv,
+    LanguageCode.nb,
+    LanguageCode.tr,
+];
+export const defaultAvailableLocales = [
+    'AF',
+    'AL',
+    'DZ',
+    'AS',
+    'AD',
+    'AO',
+    'AI',
+    'AQ',
+    'AG',
+    'AR',
+    'AM',
+    'AW',
+    'AU',
+    'AT',
+    'AZ',
+    'BS',
+    'BH',
+    'BD',
+    'BB',
+    'BY',
+    'BE',
+    'BZ',
+    'BJ',
+    'BM',
+    'BT',
+    'BO',
+    'BQ',
+    'BA',
+    'BW',
+    'BV',
+    'BR',
+    'IO',
+    'BN',
+    'BG',
+    'BF',
+    'BI',
+    'CV',
+    'KH',
+    'CM',
+    'CA',
+    'KY',
+    'CF',
+    'TD',
+    'CL',
+    'CN',
+    'CX',
+    'CC',
+    'CO',
+    'KM',
+    'CD',
+    'CG',
+    'CK',
+    'CR',
+    'HR',
+    'CU',
+    'CW',
+    'CY',
+    'CZ',
+    'CI',
+    'DK',
+    'DJ',
+    'DM',
+    'DO',
+    'EC',
+    'EG',
+    'SV',
+    'GQ',
+    'ER',
+    'EE',
+    'SZ',
+    'ET',
+    'FK',
+    'FO',
+    'FJ',
+    'FI',
+    'FR',
+    'GF',
+    'PF',
+    'TF',
+    'GA',
+    'GM',
+    'GE',
+    'DE',
+    'GH',
+    'GI',
+    'GR',
+    'GL',
+    'GD',
+    'GP',
+    'GU',
+    'GT',
+    'GG',
+    'GN',
+    'GW',
+    'GY',
+    'HT',
+    'HM',
+    'VA',
+    'HN',
+    'HK',
+    'HU',
+    'IS',
+    'IN',
+    'ID',
+    'IR',
+    'IQ',
+    'IE',
+    'IM',
+    'IL',
+    'IT',
+    'JM',
+    'JP',
+    'JE',
+    'JO',
+    'KZ',
+    'KE',
+    'KI',
+    'KP',
+    'KR',
+    'KW',
+    'KG',
+    'LA',
+    'LV',
+    'LB',
+    'LS',
+    'LR',
+    'LY',
+    'LI',
+    'LT',
+    'LU',
+    'MO',
+    'MG',
+    'MW',
+    'MY',
+    'MV',
+    'ML',
+    'MT',
+    'MH',
+    'MQ',
+    'MR',
+    'MU',
+    'YT',
+    'MX',
+    'FM',
+    'MD',
+    'MC',
+    'MN',
+    'ME',
+    'MS',
+    'MA',
+    'MZ',
+    'MM',
+    'NA',
+    'NR',
+    'NP',
+    'NL',
+    'NC',
+    'NZ',
+    'NI',
+    'NE',
+    'NG',
+    'NU',
+    'NF',
+    'MK',
+    'MP',
+    'NO',
+    'OM',
+    'PK',
+    'PW',
+    'PS',
+    'PA',
+    'PG',
+    'PY',
+    'PE',
+    'PH',
+    'PN',
+    'PL',
+    'PT',
+    'PR',
+    'QA',
+    'RO',
+    'RU',
+    'RW',
+    'RE',
+    'BL',
+    'SH',
+    'KN',
+    'LC',
+    'MF',
+    'PM',
+    'VC',
+    'WS',
+    'SM',
+    'ST',
+    'SA',
+    'SN',
+    'RS',
+    'SC',
+    'SL',
+    'SG',
+    'SX',
+    'SK',
+    'SI',
+    'SB',
+    'SO',
+    'ZA',
+    'GS',
+    'SS',
+    'ES',
+    'LK',
+    'SD',
+    'SR',
+    'SJ',
+    'SE',
+    'CH',
+    'SY',
+    'TW',
+    'TJ',
+    'TZ',
+    'TH',
+    'TL',
+    'TG',
+    'TK',
+    'TO',
+    'TT',
+    'TN',
+    'TR',
+    'TM',
+    'TC',
+    'TV',
+    'UG',
+    'UA',
+    'AE',
+    'GB',
+    'UM',
+    'US',
+    'UY',
+    'UZ',
+    'VU',
+    'VE',
+    'VN',
+    'VG',
+    'VI',
+    'WF',
+    'EH',
+    'YE',
+    'ZM',
+    'ZW',
+    'AX',
+];

package/dist/vite/index.d.ts

@@ -0,0 +1 @@
+export { vendureDashboardPlugin } from './vite-plugin-vendure-dashboard.js';

package/dist/vite/index.js

@@ -0,0 +1 @@
+export { vendureDashboardPlugin } from './vite-plugin-vendure-dashboard.js';

package/dist/vite/types.d.ts

@@ -0,0 +1,40 @@
+export type Logger = {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    debug: (message: string) => void;
+    error: (message: string) => void;
+};
+export type PluginInfo = {
+    name: string;
+    pluginPath: string;
+    dashboardEntryPath: string | undefined;
+    /** The original source path of the plugin, only set for local plugins that are compiled */
+    sourcePluginPath?: string;
+};
+export type GetCompiledConfigPathFn = (params: {
+    inputRootDir: string;
+    outputPath: string;
+    configFileName: string;
+}) => string;
+export type TransformTsConfigPathMappingsFn = (params: {
+    phase: 'compiling' | 'loading';
+    alias: string;
+    patterns: string[];
+}) => string[];
+/**
+ * @description
+ * The PathAdapter interface allows customization of how paths are handled
+ * when compiling the Vendure config and its imports.
+ */
+export interface PathAdapter {
+    /**
+     * @description
+     * A function to determine the path to the compiled Vendure config file.
+     */
+    getCompiledConfigPath?: GetCompiledConfigPathFn;
+    /**
+     * If your project makes use of the TypeScript `paths` configuration, the compiler will
+     * attempt to use these paths when compiling the Vendure config and its imports.
+     */
+    transformTsConfigPathMappings?: TransformTsConfigPathMappingsFn;
+}

package/dist/{plugin → vite}/utils/ast-utils.d.ts

@@ -1,9 +1,4 @@
 import ts from 'typescript';
-import { PluginInfo } from './config-loader.js';
-/**
- * Get the plugin info from the source file.
- */
-export declare function getPluginInfo(sourceFile: ts.SourceFile): PluginInfo | undefined;
 /**
  * Given the AST of a TypeScript file, finds the name of the variable exported as VendureConfig.
  */

package/dist/vite/utils/ast-utils.js

@@ -0,0 +1,29 @@
+import ts from 'typescript';
+/**
+ * Given the AST of a TypeScript file, finds the name of the variable exported as VendureConfig.
+ */
+export function findConfigExport(sourceFile) {
+    let exportedSymbolName;
+    function visit(node) {
+        var _a;
+        if (ts.isVariableStatement(node) &&
+            ((_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.ExportKeyword))) {
+            node.declarationList.declarations.forEach(declaration => {
+                if (ts.isVariableDeclaration(declaration)) {
+                    const typeNode = declaration.type;
+                    if (typeNode && ts.isTypeReferenceNode(typeNode)) {
+                        const typeName = typeNode.typeName;
+                        if (ts.isIdentifier(typeName) && typeName.text === 'VendureConfig') {
+                            if (ts.isIdentifier(declaration.name)) {
+                                exportedSymbolName = declaration.name.text;
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return exportedSymbolName;
+}

package/dist/vite/utils/ast-utils.spec.d.ts

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

package/dist/vite/utils/ast-utils.spec.js

@@ -0,0 +1,45 @@
+import ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+import { findConfigExport } from './ast-utils.js';
+describe('findConfigExport', () => {
+    it('should return undefined when no VendureConfig export is found', () => {
+        const sourceText = `
+            export const notConfig = {
+                some: 'value'
+            };
+        `;
+        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
+        const result = findConfigExport(sourceFile);
+        expect(result).toBeUndefined();
+    });
+    it('should find exported variable with VendureConfig type', () => {
+        const sourceText = `
+            import { VendureConfig } from '@vendure/core';
+
+            export const config: VendureConfig = {
+                authOptions: {
+                    tokenMethod: 'bearer'
+                }
+            };
+        `;
+        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
+        const result = findConfigExport(sourceFile);
+        expect(result).toBe('config');
+    });
+    it('should find exported variable with VendureConfig type among other exports', () => {
+        const sourceText = `
+            import { VendureConfig } from '@vendure/core';
+
+            export const otherExport = 'value';
+            export const config: VendureConfig = {
+                authOptions: {
+                    tokenMethod: 'bearer'
+                }
+            };
+            export const anotherExport = 123;
+        `;
+        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
+        const result = findConfigExport(sourceFile);
+        expect(result).toBe('config');
+    });
+});

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

@@ -0,0 +1,22 @@
+import { VendureConfig } from '@vendure/core';
+import { Logger, PathAdapter, PluginInfo } from '../types.js';
+export interface PackageScannerConfig {
+    nodeModulesRoot?: string;
+}
+export interface CompilerOptions {
+    vendureConfigPath: string;
+    outputPath: string;
+    pathAdapter?: PathAdapter;
+    logger?: Logger;
+    pluginPackageScanner?: PackageScannerConfig;
+}
+export interface CompileResult {
+    vendureConfig: VendureConfig;
+    exportedSymbolName: string;
+    pluginInfo: PluginInfo[];
+}
+/**
+ * Compiles TypeScript files and discovers Vendure plugins in both the compiled output
+ * and in node_modules.
+ */
+export declare function compile(options: CompilerOptions): Promise<CompileResult>;

package/dist/vite/utils/compiler.js

@@ -0,0 +1,162 @@
+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;
+    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;
+    // 1. Compile TypeScript files
+    const compileStart = Date.now();
+    await compileTypeScript({
+        inputPath: vendureConfigPath,
+        outputPath,
+        logger,
+        transformTsConfigPathMappings,
+    });
+    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: '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, }) {
+    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: 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/config-loader.d.ts

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

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

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

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 {};