@wilshop/dashboard 3.5.2

package/dist/vite/utils/schema-generator.js

@@ -0,0 +1,35 @@
+import { GraphQLTypesLoader } from '@nestjs/graphql';
+import { getConfig, getFinalVendureSchema, resetConfig, runPluginConfigurations, setConfig, VENDURE_ADMIN_API_TYPE_PATHS, } from '@vendure/core';
+import { buildSchema } from 'graphql';
+let schemaPromise;
+/**
+ * @description
+ * This function generates a GraphQL schema from the Vendure config.
+ * It is used to generate the schema for the dashboard.
+ */
+export async function generateSchema({ vendureConfig, }) {
+    if (!schemaPromise) {
+        /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
+        schemaPromise = new Promise(async (resolve, reject) => {
+            resetConfig();
+            try {
+                await setConfig(vendureConfig !== null && vendureConfig !== void 0 ? vendureConfig : {});
+                const runtimeConfig = await runPluginConfigurations(getConfig());
+                const typesLoader = new GraphQLTypesLoader();
+                const finalSchema = await getFinalVendureSchema({
+                    config: runtimeConfig,
+                    typePaths: VENDURE_ADMIN_API_TYPE_PATHS,
+                    typesLoader,
+                    apiType: 'admin',
+                    output: 'sdl',
+                });
+                const safeSchema = buildSchema(finalSchema);
+                resolve(safeSchema);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    return schemaPromise;
+}

package/dist/vite/utils/tsconfig-utils.d.ts

@@ -0,0 +1,9 @@
+import { Logger, TransformTsConfigPathMappingsFn } from '../types.js';
+export interface TsConfigPathsConfig {
+    baseUrl: string;
+    paths: Record<string, string[]>;
+}
+/**
+ * Finds and parses tsconfig files in the given directory and its parent directories.
+ */
+export declare function findTsConfigPaths(configPath: string, logger: Logger, phase: 'compiling' | 'loading', transformTsConfigPathMappings: TransformTsConfigPathMappingsFn): Promise<TsConfigPathsConfig | undefined>;

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

@@ -0,0 +1,51 @@
+import fs from 'fs-extra';
+import path from 'path';
+import stripJsonComments from 'strip-json-comments';
+/**
+ * Finds and parses tsconfig files in the given directory and its parent directories.
+ */
+export async function findTsConfigPaths(configPath, logger, phase, transformTsConfigPathMappings) {
+    let currentDir = path.dirname(configPath);
+    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 tsConfigFilePath = path.join(currentDir, fileName);
+                try {
+                    const { paths, baseUrl } = await getCompilerOptionsFromFile(tsConfigFilePath);
+                    if (paths) {
+                        const tsConfigBaseUrl = path.resolve(currentDir, baseUrl || '.');
+                        const pathMappings = getTransformedPathMappings(paths, phase, transformTsConfigPathMappings);
+                        return { baseUrl: tsConfigBaseUrl, paths: pathMappings };
+                    }
+                }
+                catch (e) {
+                    logger.warn(`Could not read or parse tsconfig file ${tsConfigFilePath}: ${e instanceof Error ? e.message : String(e)}`);
+                }
+            }
+        }
+        catch (e) {
+            logger.warn(`Could not read directory ${currentDir}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return undefined;
+}
+async function getCompilerOptionsFromFile(tsConfigFilePath) {
+    const tsConfigContent = await fs.readFile(tsConfigFilePath, 'utf-8');
+    const tsConfig = JSON.parse(stripJsonComments(tsConfigContent));
+    return tsConfig.compilerOptions || {};
+}
+function getTransformedPathMappings(paths, phase, transformTsConfigPathMappings) {
+    const pathMappings = {};
+    for (const [alias, patterns] of Object.entries(paths)) {
+        const normalizedPatterns = patterns.map(pattern => pattern.replace(/\\/g, '/'));
+        pathMappings[alias] = transformTsConfigPathMappings({
+            phase,
+            alias,
+            patterns: normalizedPatterns,
+        });
+    }
+    return pathMappings;
+}

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

@@ -0,0 +1,3 @@
+import { VendureConfig } from '@vendure/core';
+import { ResolvedUiConfig, UiConfigPluginOptions } from '../vite-plugin-ui-config.js';
+export declare function getUiConfig(config: VendureConfig, pluginOptions: UiConfigPluginOptions): ResolvedUiConfig;

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

@@ -0,0 +1,30 @@
+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 getUiConfig(config, pluginOptions) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+    const { authOptions, apiOptions } = config;
+    // Merge API configuration with defaults
+    const api = {
+        adminApiPath: (_c = (_b = (_a = pluginOptions.api) === null || _a === void 0 ? void 0 : _a.adminApiPath) !== null && _b !== void 0 ? _b : apiOptions.adminApiPath) !== null && _c !== void 0 ? _c : ADMIN_API_PATH,
+        host: (_e = (_d = pluginOptions.api) === null || _d === void 0 ? void 0 : _d.host) !== null && _e !== void 0 ? _e : 'auto',
+        port: (_g = (_f = pluginOptions.api) === null || _f === void 0 ? void 0 : _f.port) !== null && _g !== void 0 ? _g : 'auto',
+        tokenMethod: (_j = (_h = pluginOptions.api) === null || _h === void 0 ? void 0 : _h.tokenMethod) !== null && _j !== void 0 ? _j : (authOptions.tokenMethod === 'bearer' ? 'bearer' : 'cookie'),
+        authTokenHeaderKey: (_m = (_l = (_k = pluginOptions.api) === null || _k === void 0 ? void 0 : _k.authTokenHeaderKey) !== null && _l !== void 0 ? _l : authOptions.authTokenHeaderKey) !== null && _m !== void 0 ? _m : DEFAULT_AUTH_TOKEN_HEADER_KEY,
+        channelTokenKey: (_q = (_p = (_o = pluginOptions.api) === null || _o === void 0 ? void 0 : _o.channelTokenKey) !== null && _p !== void 0 ? _p : apiOptions.channelTokenKey) !== null && _q !== void 0 ? _q : DEFAULT_CHANNEL_TOKEN_KEY,
+    };
+    // Merge i18n configuration with defaults
+    const i18n = {
+        defaultLanguage: (_s = (_r = pluginOptions.i18n) === null || _r === void 0 ? void 0 : _r.defaultLanguage) !== null && _s !== void 0 ? _s : defaultLanguage,
+        defaultLocale: (_u = (_t = pluginOptions.i18n) === null || _t === void 0 ? void 0 : _t.defaultLocale) !== null && _u !== void 0 ? _u : defaultLocale,
+        availableLanguages: ((_v = pluginOptions.i18n) === null || _v === void 0 ? void 0 : _v.availableLanguages) && pluginOptions.i18n.availableLanguages.length > 0
+            ? pluginOptions.i18n.availableLanguages
+            : defaultAvailableLanguages,
+        availableLocales: ((_w = pluginOptions.i18n) === null || _w === void 0 ? void 0 : _w.availableLocales) && pluginOptions.i18n.availableLocales.length > 0
+            ? pluginOptions.i18n.availableLocales
+            : defaultAvailableLocales,
+    };
+    return {
+        api,
+        i18n,
+    };
+}

package/dist/vite/vite-plugin-admin-api-schema.d.ts

@@ -0,0 +1,24 @@
+import { Plugin } from 'vite';
+export type FieldInfoTuple = readonly [
+    type: string,
+    nullable: boolean,
+    list: boolean,
+    isPaginatedList: boolean
+];
+export interface SchemaInfo {
+    types: {
+        [typename: string]: {
+            [fieldname: string]: FieldInfoTuple;
+        };
+    };
+    inputs: {
+        [typename: string]: {
+            [fieldname: string]: FieldInfoTuple;
+        };
+    };
+    scalars: string[];
+    enums: {
+        [typename: string]: string[];
+    };
+}
+export declare function adminApiSchemaPlugin(): Plugin;

package/dist/vite/vite-plugin-admin-api-schema.js

@@ -0,0 +1,82 @@
+import { GraphQLList, GraphQLNonNull, GraphQLObjectType, isEnumType, isInputObjectType, isObjectType, isScalarType, } from 'graphql';
+import { generateSchema } from './utils/schema-generator.js';
+import { getConfigLoaderApi } from './vite-plugin-config-loader.js';
+const virtualModuleId = 'virtual:admin-api-schema';
+const resolvedVirtualModuleId = `\0${virtualModuleId}`;
+export function adminApiSchemaPlugin() {
+    let configLoaderApi;
+    let schemaInfo;
+    return {
+        name: 'vendure:admin-api-schema',
+        configResolved({ plugins }) {
+            configLoaderApi = getConfigLoaderApi(plugins);
+        },
+        async buildStart() {
+            const { vendureConfig } = await configLoaderApi.getVendureConfig();
+            if (!schemaInfo) {
+                const safeSchema = await generateSchema({ vendureConfig });
+                schemaInfo = generateSchemaInfo(safeSchema);
+            }
+        },
+        resolveId(id) {
+            if (id === virtualModuleId) {
+                return resolvedVirtualModuleId;
+            }
+        },
+        load(id) {
+            if (id === resolvedVirtualModuleId) {
+                return `
+                    export const schemaInfo = ${JSON.stringify(schemaInfo)};
+                `;
+            }
+        },
+    };
+}
+function getTypeInfo(type) {
+    let nullable = true;
+    let list = false;
+    let isPaginatedList = false;
+    // Unwrap NonNull
+    if (type instanceof GraphQLNonNull) {
+        nullable = false;
+        type = type.ofType;
+    }
+    // Unwrap List
+    if (type instanceof GraphQLList) {
+        list = true;
+        type = type.ofType;
+    }
+    if (type instanceof GraphQLObjectType) {
+        if (type.getInterfaces().some(i => i.name === 'PaginatedList')) {
+            isPaginatedList = true;
+        }
+    }
+    return [type.toString().replace(/!$/, ''), nullable, list, isPaginatedList];
+}
+function generateSchemaInfo(schema) {
+    const types = schema.getTypeMap();
+    const result = { types: {}, inputs: {}, scalars: [], enums: {} };
+    Object.values(types).forEach(type => {
+        if (isObjectType(type)) {
+            const fields = type.getFields();
+            result.types[type.name] = {};
+            Object.entries(fields).forEach(([fieldName, field]) => {
+                result.types[type.name][fieldName] = getTypeInfo(field.type);
+            });
+        }
+        if (isInputObjectType(type)) {
+            const fields = type.getFields();
+            result.inputs[type.name] = {};
+            Object.entries(fields).forEach(([fieldName, field]) => {
+                result.inputs[type.name][fieldName] = getTypeInfo(field.type);
+            });
+        }
+        if (isScalarType(type)) {
+            result.scalars.push(type.name);
+        }
+        if (isEnumType(type)) {
+            result.enums[type.name] = type.getValues().map(v => v.value);
+        }
+    });
+    return result;
+}

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) || []),
+                    '@wilshop/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,27 @@
+import type { Plugin } from 'vite';
+/**
+ * @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)
+ *
+ * Files NOT processed:
+ * - Other node_modules packages (they shouldn't contain Lingui macros)
+ *
+ * @see https://github.com/vendurehq/vendure/issues/3929
+ * @see https://github.com/lingui/swc-plugin/issues/179
+ */
+export declare function linguiBabelPlugin(): Plugin;