@motiadev/workbench 0.13.0-beta.162-846200 → 0.13.0-beta.162-813224

package/dist/motia-plugin/__tests__/generator.test.d.ts

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

package/dist/motia-plugin/__tests__/generator.test.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generator_1 = require("../generator");
+describe('Generator', () => {
+    describe('generateImports', () => {
+        it('should generate import statements', () => {
+            const packages = ['@test/plugin-1', '@test/plugin-2'];
+            const imports = (0, generator_1.generateImports)(packages);
+            expect(imports).toContain("import * as plugin_0 from '@test/plugin-1'");
+            expect(imports).toContain("import * as plugin_1 from '@test/plugin-2'");
+        });
+        it('should handle empty package array', () => {
+            const imports = (0, generator_1.generateImports)([]);
+            expect(imports).toBe('');
+        });
+    });
+    describe('generatePackageMap', () => {
+        it('should generate package map', () => {
+            const packages = ['@test/plugin-1', '@test/plugin-2'];
+            const map = (0, generator_1.generatePackageMap)(packages);
+            expect(map).toContain('const packageMap');
+            expect(map).toContain("'@test/plugin-1': plugin_0");
+            expect(map).toContain("'@test/plugin-2': plugin_1");
+        });
+    });
+    describe('generatePluginLogic', () => {
+        it('should generate plugin processing logic', () => {
+            const plugins = [{ packageName: '@test/plugin', label: 'Test' }];
+            const logic = (0, generator_1.generatePluginLogic)(plugins);
+            expect(logic).toContain('const motiaPlugins');
+            expect(logic).toContain('export const plugins');
+            expect(logic).toContain('packageMap[plugin.packageName]');
+        });
+    });
+    describe('generatePluginCode', () => {
+        it('should generate complete module code', () => {
+            const plugins = [{ packageName: '@test/plugin', label: 'Test' }];
+            const code = (0, generator_1.generatePluginCode)(plugins);
+            expect(code).toContain('import * as plugin_0');
+            expect(code).toContain('const packageMap');
+            expect(code).toContain('export const plugins');
+        });
+        it('should handle empty plugins array', () => {
+            const code = (0, generator_1.generatePluginCode)([]);
+            expect(code).toBe('export const plugins = []');
+        });
+        it('should handle multiple plugins', () => {
+            const plugins = [{ packageName: '@test/plugin-1' }, { packageName: '@test/plugin-2' }];
+            const code = (0, generator_1.generatePluginCode)(plugins);
+            expect(code).toContain("'@test/plugin-1'");
+            expect(code).toContain("'@test/plugin-2'");
+        });
+    });
+    describe('generateCssImports', () => {
+        it('should generate CSS import statements', () => {
+            const plugins = [{ packageName: '@test/plugin', cssImports: ['styles.css', 'theme.css'] }];
+            const css = (0, generator_1.generateCssImports)(plugins);
+            expect(css).toContain("@import 'styles.css';");
+            expect(css).toContain("@import 'theme.css';");
+        });
+        it('should filter empty CSS imports', () => {
+            const plugins = [{ packageName: '@test/plugin', cssImports: ['styles.css', '', '  '] }];
+            const css = (0, generator_1.generateCssImports)(plugins);
+            expect(css).toContain("@import 'styles.css';");
+            expect(css).not.toContain("@import '';");
+        });
+        it('should return empty string for plugins without CSS imports', () => {
+            const plugins = [{ packageName: '@test/plugin' }];
+            const css = (0, generator_1.generateCssImports)(plugins);
+            expect(css).toBe('');
+        });
+        it('should flatten CSS imports from multiple plugins', () => {
+            const plugins = [
+                { packageName: '@test/plugin-1', cssImports: ['a.css'] },
+                { packageName: '@test/plugin-2', cssImports: ['b.css'] },
+            ];
+            const css = (0, generator_1.generateCssImports)(plugins);
+            expect(css).toContain("@import 'a.css';");
+            expect(css).toContain("@import 'b.css';");
+        });
+    });
+    describe('isValidCode', () => {
+        it('should return true for valid code', () => {
+            expect((0, generator_1.isValidCode)('export const plugins = []')).toBe(true);
+        });
+        it('should return false for empty string', () => {
+            expect((0, generator_1.isValidCode)('')).toBe(false);
+        });
+        it('should return false for whitespace only', () => {
+            expect((0, generator_1.isValidCode)('   \n\t  ')).toBe(false);
+        });
+        it('should return false for non-string', () => {
+            expect((0, generator_1.isValidCode)(null)).toBe(false);
+            expect((0, generator_1.isValidCode)(undefined)).toBe(false);
+        });
+    });
+});

package/dist/motia-plugin/__tests__/resolver.test.d.ts

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

package/dist/motia-plugin/__tests__/resolver.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resolver_1 = require("../resolver");
+describe('Resolver', () => {
+    describe('resolvePluginPackage', () => {
+        it('should resolve local plugin', () => {
+            const plugin = { packageName: '~/plugins/local' };
+            const resolved = (0, resolver_1.resolvePluginPackage)(plugin);
+            expect(resolved.packageName).toBe('~/plugins/local');
+            expect(resolved.isLocal).toBe(true);
+            expect(resolved.resolvedPath).toContain('plugins/local');
+            expect(resolved.alias).toBe('~/plugins/local');
+        });
+        it('should resolve npm package', () => {
+            const plugin = { packageName: '@test/plugin' };
+            const resolved = (0, resolver_1.resolvePluginPackage)(plugin);
+            expect(resolved.packageName).toBe('@test/plugin');
+            expect(resolved.isLocal).toBe(false);
+            expect(resolved.resolvedPath).toContain('node_modules');
+            expect(resolved.resolvedPath).toContain('@test/plugin');
+            expect(resolved.alias).toBe('@test/plugin');
+        });
+        it('should normalize paths', () => {
+            const plugin = { packageName: 'simple-plugin' };
+            const resolved = (0, resolver_1.resolvePluginPackage)(plugin);
+            expect(resolved.resolvedPath).not.toContain('\\');
+        });
+    });
+    describe('createAliasConfig', () => {
+        it('should create aliases for all plugins', () => {
+            const plugins = [{ packageName: '~/plugins/local' }, { packageName: '@test/npm' }];
+            const aliases = (0, resolver_1.createAliasConfig)(plugins);
+            expect(aliases['~/plugins/local']).toBeDefined();
+            expect(aliases['@test/npm']).toBeDefined();
+        });
+        it('should handle duplicate package names', () => {
+            const plugins = [{ packageName: '@test/plugin' }, { packageName: '@test/plugin' }];
+            const aliases = (0, resolver_1.createAliasConfig)(plugins);
+            expect(Object.keys(aliases)).toHaveLength(1);
+            expect(aliases['@test/plugin']).toBeDefined();
+        });
+        it('should return empty object for empty plugins array', () => {
+            const aliases = (0, resolver_1.createAliasConfig)([]);
+            expect(aliases).toEqual({});
+        });
+    });
+    describe('getUniquePackageNames', () => {
+        it('should return unique package names', () => {
+            const plugins = [
+                { packageName: '@test/a' },
+                { packageName: '@test/b' },
+                { packageName: '@test/a' },
+            ];
+            const unique = (0, resolver_1.getUniquePackageNames)(plugins);
+            expect(unique).toHaveLength(2);
+            expect(unique).toContain('@test/a');
+            expect(unique).toContain('@test/b');
+        });
+        it('should return empty array for no plugins', () => {
+            const unique = (0, resolver_1.getUniquePackageNames)([]);
+            expect(unique).toEqual([]);
+        });
+    });
+});

package/dist/motia-plugin/__tests__/validator.test.d.ts

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

package/dist/motia-plugin/__tests__/validator.test.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validator_1 = require("../validator");
+describe('Validator', () => {
+    describe('validatePlugins', () => {
+        it('should validate array of valid plugins', () => {
+            const plugins = [
+                { packageName: '@test/plugin-1', label: 'Plugin 1' },
+                { packageName: '@test/plugin-2', label: 'Plugin 2' },
+            ];
+            const result = (0, validator_1.validatePlugins)(plugins);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should reject non-array input', () => {
+            const result = (0, validator_1.validatePlugins)('not-an-array');
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((err) => err.includes('array'))).toBe(true);
+        });
+        it('should handle empty array', () => {
+            const result = (0, validator_1.validatePlugins)([]);
+            expect(result.valid).toBe(true);
+            expect(result.warnings.some((w) => w.includes('No plugins'))).toBe(true);
+        });
+        it('should collect all errors from multiple plugins', () => {
+            const plugins = [{ packageName: '' }, { packageName: '' }, { packageName: 'valid' }];
+            const result = (0, validator_1.validatePlugins)(plugins);
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBeGreaterThanOrEqual(2);
+        });
+        it('should warn about duplicate package names', () => {
+            const plugins = [
+                { packageName: '@test/plugin', label: 'Plugin 1' },
+                { packageName: '@test/plugin', label: 'Plugin 2' },
+            ];
+            const result = (0, validator_1.validatePlugins)(plugins);
+            expect(result.valid).toBe(true);
+            expect(result.warnings.some((w) => w.includes('Duplicate'))).toBe(true);
+        });
+        it('should support failFast option', () => {
+            const plugins = [{ packageName: '' }, { packageName: '' }];
+            const result = (0, validator_1.validatePlugins)(plugins, { failFast: true });
+            expect(result.valid).toBe(false);
+            // With failFast, should stop after first plugin validation fails
+            // Each plugin with empty packageName generates 2 errors (min length + invalid format)
+            // So failFast should result in only the first plugin's errors
+            expect(result.errors.length).toBeLessThanOrEqual(2);
+            // Verify it didn't process second plugin by checking error messages don't mention index 1
+            const hasIndex1Error = result.errors.some((err) => err.includes('index 1'));
+            expect(hasIndex1Error).toBe(false);
+        });
+        it('should handle mixed valid and invalid plugins', () => {
+            const plugins = [{ packageName: '@test/valid' }, { packageName: '' }, { packageName: '@test/another-valid' }];
+            const result = (0, validator_1.validatePlugins)(plugins);
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBeGreaterThan(0);
+        });
+    });
+});

package/dist/motia-plugin/generator.d.ts

@@ -0,0 +1,78 @@
+import type { WorkbenchPlugin } from './types';
+/**
+ * Generates import statements for all unique plugin packages.
+ *
+ * @param packages - Array of unique package names
+ * @returns JavaScript code string with import statements
+ *
+ * @example
+ * ```ts
+ * generateImports(['@org/plugin-1', '~/plugins/local'])
+ * // Returns:
+ * // import * as plugin_0 from '@org/plugin-1'
+ * // import * as plugin_1 from '~/plugins/local'
+ * ```
+ */
+export declare function generateImports(packages: string[]): string;
+/**
+ * Generates the package map that links package names to their imported modules.
+ *
+ * @param packages - Array of unique package names
+ * @returns JavaScript code string defining the package map
+ *
+ * @example
+ * ```ts
+ * generatePackageMap(['@org/plugin-1', '~/plugins/local'])
+ * // Returns: const packageMap = {'@org/plugin-1': plugin_0,'~/plugins/local': plugin_1}
+ * ```
+ */
+export declare function generatePackageMap(packages: string[]): string;
+/**
+ * Generates the plugin transformation logic that processes plugin configurations.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns JavaScript code string with plugin processing logic
+ */
+export declare function generatePluginLogic(plugins: WorkbenchPlugin[]): string;
+/**
+ * Generates the complete virtual module code for all plugins.
+ * This is the main code generation function that combines all parts.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns Complete JavaScript code string for the virtual module
+ *
+ * @example
+ * ```ts
+ * const plugins = [
+ *   { packageName: '@test/plugin', label: 'Test' }
+ * ]
+ * const code = generatePluginCode(plugins)
+ * // Returns complete module code with imports, map, and logic
+ * ```
+ */
+export declare function generatePluginCode(plugins: WorkbenchPlugin[]): string;
+/**
+ * Generates CSS imports for plugins that specify cssImports.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns CSS import statements as a string
+ *
+ * @example
+ * ```ts
+ * const plugins = [
+ *   { packageName: '@test/plugin', cssImports: ['styles.css', 'theme.css'] }
+ * ]
+ * generateCssImports(plugins)
+ * // Returns:
+ * // @import 'styles.css';
+ * // @import 'theme.css';
+ * ```
+ */
+export declare function generateCssImports(plugins: WorkbenchPlugin[]): string;
+/**
+ * Checks if the generated code is valid (non-empty and has content).
+ *
+ * @param code - The generated code to check
+ * @returns True if code is valid
+ */
+export declare function isValidCode(code: string): boolean;

package/dist/motia-plugin/{generator.ts → generator.js}

@@ -1,6 +1,12 @@
-import { getUniquePackageNames } from './resolver'
-import type { WorkbenchPlugin } from './types'
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImports = generateImports;
+exports.generatePackageMap = generatePackageMap;
+exports.generatePluginLogic = generatePluginLogic;
+exports.generatePluginCode = generatePluginCode;
+exports.generateCssImports = generateCssImports;
+exports.isValidCode = isValidCode;
+const resolver_1 = require("./resolver");
 /**
  * Generates import statements for all unique plugin packages.
  *
@@ -15,10 +21,9 @@ import type { WorkbenchPlugin } from './types'
  * // import * as plugin_1 from '~/plugins/local'
  * ```
  */
-export function generateImports(packages: string[]): string {
-  return packages.map((packageName, index) => `import * as plugin_${index} from '${packageName}'`).join('\n')
+function generateImports(packages) {
+    return packages.map((packageName, index) => `import * as plugin_${index} from '${packageName}'`).join('\n');
 }
-
 /**
  * Generates the package map that links package names to their imported modules.
  *
@@ -31,19 +36,18 @@ export function generateImports(packages: string[]): string {
  * // Returns: const packageMap = {'@org/plugin-1': plugin_0,'~/plugins/local': plugin_1}
  * ```
  */
-export function generatePackageMap(packages: string[]): string {
-  const entries = packages.map((packageName, index) => `'${packageName}': plugin_${index}`)
-  return `const packageMap = {${entries.join(',')}}`
+function generatePackageMap(packages) {
+    const entries = packages.map((packageName, index) => `'${packageName}': plugin_${index}`);
+    return `const packageMap = {${entries.join(',')}}`;
 }
-
 /**
  * Generates the plugin transformation logic that processes plugin configurations.
  *
  * @param plugins - Array of plugin configurations
  * @returns JavaScript code string with plugin processing logic
  */
-export function generatePluginLogic(plugins: WorkbenchPlugin[]): string {
-  return `
+function generatePluginLogic(plugins) {
+    return `
       const motiaPlugins = ${JSON.stringify(plugins)}
 
       export const plugins = motiaPlugins.map((plugin) => {
@@ -59,9 +63,8 @@ export function generatePluginLogic(plugins: WorkbenchPlugin[]): string {
           component: componentName ? component[componentName] : component.default,
         }
       })
-`
+`;
 }
-
 /**
  * Generates the complete virtual module code for all plugins.
  * This is the main code generation function that combines all parts.
@@ -78,21 +81,18 @@ export function generatePluginLogic(plugins: WorkbenchPlugin[]): string {
  * // Returns complete module code with imports, map, and logic
  * ```
  */
-export function generatePluginCode(plugins: WorkbenchPlugin[]): string {
-  if (!plugins || plugins.length === 0) {
-    return 'export const plugins = []'
-  }
-
-  const packages = getUniquePackageNames(plugins)
-  const imports = generateImports(packages)
-  const packageMap = generatePackageMap(packages)
-  const logic = generatePluginLogic(plugins)
-
-  return `${imports}
+function generatePluginCode(plugins) {
+    if (!plugins || plugins.length === 0) {
+        return 'export const plugins = []';
+    }
+    const packages = (0, resolver_1.getUniquePackageNames)(plugins);
+    const imports = generateImports(packages);
+    const packageMap = generatePackageMap(packages);
+    const logic = generatePluginLogic(plugins);
+    return `${imports}
 ${packageMap}
-${logic}`
+${logic}`;
 }
-
 /**
  * Generates CSS imports for plugins that specify cssImports.
  *
@@ -110,21 +110,19 @@ ${logic}`
  * // @import 'theme.css';
  * ```
  */
-export function generateCssImports(plugins: WorkbenchPlugin[]): string {
-  const cssImports = plugins
-    .flatMap((plugin) => plugin.cssImports || [])
-    .filter((cssImport) => cssImport && cssImport.trim() !== '')
-    .map((cssImport) => `@import '${cssImport}';`)
-
-  return cssImports.join('\n')
+function generateCssImports(plugins) {
+    const cssImports = plugins
+        .flatMap((plugin) => plugin.cssImports || [])
+        .filter((cssImport) => cssImport && cssImport.trim() !== '')
+        .map((cssImport) => `@import '${cssImport}';`);
+    return cssImports.join('\n');
 }
-
 /**
  * Checks if the generated code is valid (non-empty and has content).
  *
  * @param code - The generated code to check
  * @returns True if code is valid
  */
-export function isValidCode(code: string): boolean {
-  return typeof code === 'string' && code.trim().length > 0
+function isValidCode(code) {
+    return typeof code === 'string' && code.trim().length > 0;
 }

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

@@ -0,0 +1,22 @@
+import type { Printer } from '@motiadev/core';
+import type { HmrContext, ModuleNode } from 'vite';
+import type { WorkbenchPlugin } from './types';
+export declare function isConfigFile(file: string): boolean;
+/**
+ * Checks if a file change should trigger HMR for plugins.
+ *
+ * @param file - The file path that changed
+ * @param plugins - Current plugin configurations
+ * @returns True if the change affects plugins
+ */
+export declare function shouldInvalidatePlugins(file: string, plugins: WorkbenchPlugin[]): boolean;
+/**
+ * Handles hot updates for the plugin system.
+ * This function is called by Vite's handleHotUpdate hook.
+ *
+ * @param ctx - Vite's HMR context
+ * @param plugins - Current plugin configurations
+ * @param printer - Printer instance for logging
+ * @returns Array of modules to update, or undefined to continue with default behavior
+ */
+export declare function handlePluginHotUpdate(ctx: HmrContext, plugins: WorkbenchPlugin[], printer: Printer): ModuleNode[] | undefined;

package/dist/motia-plugin/hmr.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConfigFile = isConfigFile;
+exports.shouldInvalidatePlugins = shouldInvalidatePlugins;
+exports.handlePluginHotUpdate = handlePluginHotUpdate;
+const path_1 = __importDefault(require("path"));
+const resolver_1 = require("./resolver");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const WATCHED_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.css', '.scss', '.less'];
+function isConfigFile(file) {
+    const normalizedFile = (0, utils_1.normalizePath)(file);
+    return normalizedFile.endsWith('motia.config.ts') || normalizedFile.endsWith('motia.config.js');
+}
+/**
+ * Checks if a file change should trigger HMR for plugins.
+ *
+ * @param file - The file path that changed
+ * @param plugins - Current plugin configurations
+ * @returns True if the change affects plugins
+ */
+function shouldInvalidatePlugins(file, plugins) {
+    const normalizedFile = (0, utils_1.normalizePath)(file);
+    const absoluteFile = path_1.default.isAbsolute(normalizedFile) ? normalizedFile : path_1.default.resolve(process.cwd(), normalizedFile);
+    if (isConfigFile(file)) {
+        return true;
+    }
+    const hasWatchedExtension = WATCHED_EXTENSIONS.some((ext) => absoluteFile.endsWith(ext));
+    if (!hasWatchedExtension) {
+        return false;
+    }
+    for (const plugin of plugins) {
+        if ((0, utils_1.isLocalPlugin)(plugin.packageName)) {
+            const resolved = (0, resolver_1.resolvePluginPackage)(plugin);
+            const pluginAbsolutePath = path_1.default.isAbsolute(resolved.resolvedPath)
+                ? resolved.resolvedPath
+                : path_1.default.resolve(process.cwd(), resolved.resolvedPath);
+            const normalizedPluginPath = pluginAbsolutePath.endsWith(path_1.default.sep)
+                ? pluginAbsolutePath
+                : `${pluginAbsolutePath}${path_1.default.sep}`;
+            if (absoluteFile.startsWith(normalizedPluginPath) || absoluteFile === pluginAbsolutePath) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Handles hot updates for the plugin system.
+ * This function is called by Vite's handleHotUpdate hook.
+ *
+ * @param ctx - Vite's HMR context
+ * @param plugins - Current plugin configurations
+ * @param printer - Printer instance for logging
+ * @returns Array of modules to update, or undefined to continue with default behavior
+ */
+function handlePluginHotUpdate(ctx, plugins, printer) {
+    const { file, server, timestamp } = ctx;
+    printer.printPluginLog(`HMR: File changed: ${(0, utils_1.normalizePath)(file)}`);
+    if (isConfigFile(file)) {
+        printer.printPluginLog('HMR: Config file changed, triggering full page reload');
+        printer.printPluginWarn('Configuration changes require a server restart for full effect. Please restart the dev server to apply all changes.');
+        server.ws.send({
+            type: 'full-reload',
+            path: '*',
+        });
+        return;
+    }
+    if (!shouldInvalidatePlugins(file, plugins)) {
+        printer.printPluginLog('HMR: Change outside plugin scope, delegating to Vite default handling');
+        return;
+    }
+    printer.printPluginLog('HMR: Plugin change detected, invalidating virtual module');
+    const virtualModule = server.moduleGraph.getModuleById(types_1.CONSTANTS.RESOLVED_VIRTUAL_MODULE_ID);
+    if (!virtualModule) {
+        printer.printPluginWarn('HMR: Virtual module not found, triggering full reload as fallback');
+        server.ws.send({
+            type: 'full-reload',
+            path: '*',
+        });
+        return;
+    }
+    server.moduleGraph.invalidateModule(virtualModule, new Set(), timestamp);
+    printer.printPluginLog('HMR: Virtual module invalidated');
+    const modulesToUpdateSet = new Set([virtualModule]);
+    const processedModules = new Set([virtualModule]);
+    for (const importer of virtualModule.importers) {
+        if (!processedModules.has(importer)) {
+            processedModules.add(importer);
+            modulesToUpdateSet.add(importer);
+            server.moduleGraph.invalidateModule(importer, new Set(), timestamp);
+        }
+    }
+    const modulesToUpdate = Array.from(modulesToUpdateSet);
+    printer.printPluginLog(`HMR: Updated ${modulesToUpdate.length} module(s)`);
+    return modulesToUpdate;
+}

package/dist/motia-plugin/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import type { WorkbenchPlugin } from './types';
+export default function motiaPluginsPlugin(plugins: WorkbenchPlugin[]): Plugin;