@openwebf/webf 0.22.11 → 0.23.0

package/dist/commands.js

@@ -233,10 +233,16 @@ function createCommand(target, options) {
             fs_1.default.mkdirSync(srcDir, { recursive: true });
         }
         const indexFilePath = path_1.default.join(srcDir, 'index.ts');
-        const indexContent = lodash_1.default.template(reactIndexTpl)({
-            components: [],
-        });
-        writeFileIfChanged(indexFilePath, indexContent);
+        if (!fs_1.default.existsSync(indexFilePath)) {
+            const indexContent = lodash_1.default.template(reactIndexTpl)({
+                components: [],
+            });
+            writeFileIfChanged(indexFilePath, indexContent);
+        }
+        else {
+            // Do not overwrite existing index.ts created by the user
+            // Leave merge to the codegen step which appends exports safely
+        }
         (0, child_process_1.spawnSync)(NPM, ['install', '--omit=peer'], {
             cwd: target,
             stdio: 'inherit'
@@ -260,7 +266,7 @@ function createCommand(target, options) {
             cwd: target,
             stdio: 'inherit'
         });
-        (0, child_process_1.spawnSync)(NPM, ['install', '@types/vue', '-D'], {
+        (0, child_process_1.spawnSync)(NPM, ['install', 'vue', '-D'], {
             cwd: target,
             stdio: 'inherit'
         });

package/dist/dart.js

@@ -80,6 +80,12 @@ ${enumValues};
 }`;
 }
 function generateReturnType(type, enumName) {
+    // Handle union types first (e.g., 'left' | 'center' | 'right')
+    // so we don't incorrectly treat string literal unions as pointer types.
+    if (Array.isArray(type.value)) {
+        // If we have an enum name, use it; otherwise fall back to String
+        return enumName || 'String';
+    }
     if ((0, utils_1.isPointerType)(type)) {
         const pointerType = (0, utils_1.getPointerType)(type);
         return pointerType;
@@ -87,11 +93,6 @@ function generateReturnType(type, enumName) {
     if (type.isArray && typeof type.value === 'object' && !Array.isArray(type.value)) {
         return `${(0, utils_1.getPointerType)(type.value)}[]`;
     }
-    // Handle union types (e.g., 'left' | 'center' | 'right')
-    if (Array.isArray(type.value)) {
-        // If we have an enum name, use it; otherwise fall back to String
-        return enumName || 'String';
-    }
     // Handle when type.value is a ParameterType object (nested type)
     if (typeof type.value === 'object' && !Array.isArray(type.value) && type.value !== null) {
         // This might be a nested ParameterType, recurse
@@ -250,7 +251,7 @@ interface ${object.name} {
     }
     // Generate enums for union types
     const enums = [];
-    const enumMap = new Map(); // prop name -> enum name
+    const enumMap = new Map(); // camelCase prop name -> enum name
     if (componentProperties) {
         for (const prop of componentProperties.props) {
             if (isStringUnionType(prop.type)) {
@@ -261,7 +262,8 @@ interface ${object.name} {
                         name: enumName,
                         definition: generateDartEnum(enumName, values)
                     });
-                    enumMap.set(prop.name, enumName);
+                    // Store by camelCase prop name to match template usage
+                    enumMap.set(lodash_1.default.camelCase(prop.name), enumName);
                 }
             }
         }

package/dist/generator.js

@@ -29,6 +29,7 @@ const dart_1 = require("./dart");
 const react_1 = require("./react");
 const vue_1 = require("./vue");
 const logger_1 = require("./logger");
+const typescript_1 = __importDefault(require("typescript"));
 // Cache for file content to avoid redundant reads
 const fileContentCache = new Map();
 // Cache for generated content to detect changes
@@ -287,12 +288,91 @@ function reactGen(_a) {
                 (0, logger_1.error)(`Error generating React component for ${blob.filename}`, err);
             }
         }));
-        // Generate index file (always regenerate to avoid duplicates)
+        // Generate/merge index file
         const indexFilePath = path_1.default.join(normalizedTarget, 'src', 'index.ts');
-        const newExports = (0, react_1.generateReactIndex)(blobs);
-        if (writeFileIfChanged(indexFilePath, newExports)) {
-            filesChanged++;
-            (0, logger_1.debug)(`Generated: index.ts`);
+        // Build desired export map: moduleSpecifier -> Set of names
+        const desiredExports = new Map();
+        const components = blobs.flatMap(blob => {
+            const classObjects = blob.objects.filter(obj => obj instanceof declaration_1.ClassObject);
+            const properties = classObjects.filter(object => object.name.endsWith('Properties'));
+            const events = classObjects.filter(object => object.name.endsWith('Events'));
+            const componentMap = new Map();
+            properties.forEach(prop => componentMap.set(prop.name.replace(/Properties$/, ''), true));
+            events.forEach(evt => componentMap.set(evt.name.replace(/Events$/, ''), true));
+            return Array.from(componentMap.keys()).map(className => ({
+                className,
+                fileName: blob.filename,
+                relativeDir: blob.relativeDir,
+            }));
+        });
+        // Deduplicate by className
+        const unique = new Map();
+        for (const c of components) {
+            if (!unique.has(c.className))
+                unique.set(c.className, c);
+        }
+        for (const { className, fileName, relativeDir } of unique.values()) {
+            const spec = `./${relativeDir ? `${relativeDir}/` : ''}${fileName}`;
+            if (!desiredExports.has(spec))
+                desiredExports.set(spec, new Set());
+            const set = desiredExports.get(spec);
+            set.add(className);
+            set.add(`${className}Element`);
+        }
+        if (!fs_1.default.existsSync(indexFilePath)) {
+            // No index.ts -> generate fresh file from template
+            const newExports = (0, react_1.generateReactIndex)(blobs);
+            if (writeFileIfChanged(indexFilePath, newExports)) {
+                filesChanged++;
+                (0, logger_1.debug)(`Generated: index.ts`);
+            }
+        }
+        else {
+            // Merge into existing index.ts without removing user code
+            try {
+                const existing = fs_1.default.readFileSync(indexFilePath, 'utf-8');
+                const sourceFile = typescript_1.default.createSourceFile(indexFilePath, existing, typescript_1.default.ScriptTarget.ES2020, true, typescript_1.default.ScriptKind.TS);
+                // Track which names already exported per module
+                for (const stmt of sourceFile.statements) {
+                    if (typescript_1.default.isExportDeclaration(stmt) && stmt.exportClause && typescript_1.default.isNamedExports(stmt.exportClause)) {
+                        const moduleSpecifier = stmt.moduleSpecifier && typescript_1.default.isStringLiteral(stmt.moduleSpecifier)
+                            ? stmt.moduleSpecifier.text
+                            : undefined;
+                        if (!moduleSpecifier)
+                            continue;
+                        const desired = desiredExports.get(moduleSpecifier);
+                        if (!desired)
+                            continue;
+                        for (const el of stmt.exportClause.elements) {
+                            const name = el.name.getText(sourceFile);
+                            if (desired.has(name))
+                                desired.delete(name);
+                        }
+                    }
+                }
+                // Prepare new export lines for any remaining names
+                const lines = [];
+                for (const [spec, names] of desiredExports) {
+                    const missing = Array.from(names);
+                    if (missing.length === 0)
+                        continue;
+                    const specEscaped = spec.replace(/\\/g, '/');
+                    lines.push(`export { ${missing.join(', ')} } from "${specEscaped}";`);
+                }
+                if (lines.length > 0) {
+                    const appended = (existing.endsWith('\n') ? '' : '\n') + lines.join('\n') + '\n';
+                    if (writeFileIfChanged(indexFilePath, existing + appended)) {
+                        filesChanged++;
+                        (0, logger_1.debug)(`Merged exports into existing index.ts`);
+                    }
+                }
+                else {
+                    (0, logger_1.debug)(`index.ts is up to date; no merge needed.`);
+                }
+            }
+            catch (err) {
+                (0, logger_1.warn)(`Failed to merge into existing index.ts. Skipping modifications: ${indexFilePath}`);
+            }
         }
         (0, logger_1.timeEnd)('reactGen');
         (0, logger_1.success)(`React code generation completed. ${filesChanged} files changed.`);

package/dist/vue.js

@@ -51,6 +51,10 @@ function generateEventHandlerType(type) {
     if (pointerType === 'CustomEvent') {
         return 'CustomEvent';
     }
+    // Handle generic types like CustomEvent<T>
+    if (pointerType.startsWith('CustomEvent<')) {
+        return pointerType;
+    }
     throw new Error('Unknown event type: ' + pointerType);
 }
 function generateMethodDeclaration(method) {
@@ -65,6 +69,10 @@ function generateMethodDeclaration(method) {
 }
 function generateVueComponent(blob) {
     const classObjects = blob.objects;
+    // Skip if no class objects
+    if (!classObjects || classObjects.length === 0) {
+        return '';
+    }
     const classObjectDictionary = Object.fromEntries(classObjects.map(object => {
         return [object.name, object];
     }));
@@ -79,6 +87,9 @@ function generateVueComponent(blob) {
             && !object.name.endsWith('Events');
     });
     const dependencies = others.map(object => {
+        if (!object || !object.props) {
+            return '';
+        }
         const props = object.props.map(prop => {
             if (prop.optional) {
                 return `${prop.name}?: ${generateReturnType(prop.type)};`;
@@ -89,7 +100,7 @@ function generateVueComponent(blob) {
 interface ${object.name} {
   ${props}
 }`;
-    }).join('\n\n');
+    }).filter(dep => dep.trim() !== '').join('\n\n');
     const componentProperties = properties.length > 0 ? properties[0] : undefined;
     const componentEvents = events.length > 0 ? events[0] : undefined;
     const className = (() => {
@@ -149,7 +160,11 @@ function generateVueTypings(blobs) {
     }).filter(component => {
         return component.length > 0;
     }).join('\n\n');
-    const content = lodash_1.default.template(readTemplate('vue.components.d.ts'))({
+    const content = lodash_1.default.template(readTemplate('vue.components.d.ts'), {
+        interpolate: /<%=([\s\S]+?)%>/g,
+        evaluate: /<%([\s\S]+?)%>/g,
+        escape: /<%-([\s\S]+?)%>/g
+    })({
         componentNames,
         components,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwebf/webf",
-  "version": "0.22.11",
+  "version": "0.23.0",
   "description": "Command line tools for WebF",
   "main": "index.js",
   "bin": {
@@ -30,6 +30,7 @@
     "@types/inquirer": "^8.2.11",
     "@types/jest": "^29.5.12",
     "@types/lodash": "^4.17.17",
+    "@types/minimatch": "^5.1.2",
     "@types/node": "^22.15.21",
     "@types/yaml": "^1.9.6",
     "jest": "^29.7.0",
@@ -39,7 +40,7 @@
     "@microsoft/tsdoc": "^0.15.1",
     "@microsoft/tsdoc-config": "^0.17.1",
     "commander": "^14.0.0",
-    "glob": "^10.3.10",
+    "glob": "^10.4.5",
     "inquirer": "^8.2.6",
     "lodash": "^4.17.21",
     "typescript": "^5.8.3",

package/src/commands.ts

@@ -300,10 +300,15 @@ function createCommand(target: string, options: { framework: string; packageName
     }
 
     const indexFilePath = path.join(srcDir, 'index.ts');
-    const indexContent = _.template(reactIndexTpl)({
-      components: [],
-    });
-    writeFileIfChanged(indexFilePath, indexContent);
+    if (!fs.existsSync(indexFilePath)) {
+      const indexContent = _.template(reactIndexTpl)({
+        components: [],
+      });
+      writeFileIfChanged(indexFilePath, indexContent);
+    } else {
+      // Do not overwrite existing index.ts created by the user
+      // Leave merge to the codegen step which appends exports safely
+    }
 
     spawnSync(NPM, ['install', '--omit=peer'], {
       cwd: target,
@@ -332,7 +337,7 @@ function createCommand(target: string, options: { framework: string; packageName
       stdio: 'inherit'
     });
 
-    spawnSync(NPM, ['install', '@types/vue', '-D'], {
+    spawnSync(NPM, ['install', 'vue', '-D'], {
       cwd: target,
       stdio: 'inherit'
     });

package/src/dart.ts

@@ -83,6 +83,13 @@ ${enumValues};
 }
 
 function generateReturnType(type: ParameterType, enumName?: string) {
+  // Handle union types first (e.g., 'left' | 'center' | 'right')
+  // so we don't incorrectly treat string literal unions as pointer types.
+  if (Array.isArray(type.value)) {
+    // If we have an enum name, use it; otherwise fall back to String
+    return enumName || 'String';
+  }
+
   if (isPointerType(type)) {
     const pointerType = getPointerType(type);
     return pointerType;
@@ -91,12 +98,6 @@ function generateReturnType(type: ParameterType, enumName?: string) {
     return `${getPointerType(type.value)}[]`;
   }
   
-  // Handle union types (e.g., 'left' | 'center' | 'right')
-  if (Array.isArray(type.value)) {
-    // If we have an enum name, use it; otherwise fall back to String
-    return enumName || 'String';
-  }
-  
   // Handle when type.value is a ParameterType object (nested type)
   if (typeof type.value === 'object' && !Array.isArray(type.value) && type.value !== null) {
     // This might be a nested ParameterType, recurse
@@ -278,7 +279,7 @@ interface ${object.name} {
   
   // Generate enums for union types
   const enums: { name: string; definition: string }[] = [];
-  const enumMap: Map<string, string> = new Map(); // prop name -> enum name
+  const enumMap: Map<string, string> = new Map(); // camelCase prop name -> enum name
   
   if (componentProperties) {
     for (const prop of componentProperties.props) {
@@ -290,7 +291,8 @@ interface ${object.name} {
             name: enumName,
             definition: generateDartEnum(enumName, values)
           });
-          enumMap.set(prop.name, enumName);
+          // Store by camelCase prop name to match template usage
+          enumMap.set(_.camelCase(prop.name), enumName);
         }
       }
     }

package/src/generator.ts

@@ -11,6 +11,7 @@ import { generateDartClass } from './dart';
 import { generateReactComponent, generateReactIndex } from './react';
 import { generateVueTypings } from './vue';
 import { logger, debug, info, success, warn, error, group, progress, time, timeEnd } from './logger';
+import ts from 'typescript';
 
 // Cache for file content to avoid redundant reads
 const fileContentCache = new Map<string, string>();
@@ -321,13 +322,88 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
     }
   });
   
-  // Generate index file (always regenerate to avoid duplicates)
+  // Generate/merge index file
   const indexFilePath = path.join(normalizedTarget, 'src', 'index.ts');
-  const newExports = generateReactIndex(blobs);
-  
-  if (writeFileIfChanged(indexFilePath, newExports)) {
-    filesChanged++;
-    debug(`Generated: index.ts`);
+
+  // Build desired export map: moduleSpecifier -> Set of names
+  const desiredExports = new Map<string, Set<string>>();
+  const components = blobs.flatMap(blob => {
+    const classObjects = blob.objects.filter(obj => obj instanceof ClassObject) as ClassObject[];
+    const properties = classObjects.filter(object => object.name.endsWith('Properties'));
+    const events = classObjects.filter(object => object.name.endsWith('Events'));
+    const componentMap = new Map<string, boolean>();
+    properties.forEach(prop => componentMap.set(prop.name.replace(/Properties$/, ''), true));
+    events.forEach(evt => componentMap.set(evt.name.replace(/Events$/, ''), true));
+    return Array.from(componentMap.keys()).map(className => ({
+      className,
+      fileName: blob.filename,
+      relativeDir: blob.relativeDir,
+    }));
+  });
+
+  // Deduplicate by className
+  const unique = new Map<string, { className: string; fileName: string; relativeDir: string }>();
+  for (const c of components) {
+    if (!unique.has(c.className)) unique.set(c.className, c);
+  }
+  for (const { className, fileName, relativeDir } of unique.values()) {
+    const spec = `./${relativeDir ? `${relativeDir}/` : ''}${fileName}`;
+    if (!desiredExports.has(spec)) desiredExports.set(spec, new Set());
+    const set = desiredExports.get(spec)!;
+    set.add(className);
+    set.add(`${className}Element`);
+  }
+
+  if (!fs.existsSync(indexFilePath)) {
+    // No index.ts -> generate fresh file from template
+    const newExports = generateReactIndex(blobs);
+    if (writeFileIfChanged(indexFilePath, newExports)) {
+      filesChanged++;
+      debug(`Generated: index.ts`);
+    }
+  } else {
+    // Merge into existing index.ts without removing user code
+    try {
+      const existing = fs.readFileSync(indexFilePath, 'utf-8');
+      const sourceFile = ts.createSourceFile(indexFilePath, existing, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+
+      // Track which names already exported per module
+      for (const stmt of sourceFile.statements) {
+        if (ts.isExportDeclaration(stmt) && stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+          const moduleSpecifier = stmt.moduleSpecifier && ts.isStringLiteral(stmt.moduleSpecifier)
+            ? stmt.moduleSpecifier.text
+            : undefined;
+          if (!moduleSpecifier) continue;
+          const desired = desiredExports.get(moduleSpecifier);
+          if (!desired) continue;
+          for (const el of stmt.exportClause.elements) {
+            const name = el.name.getText(sourceFile);
+            if (desired.has(name)) desired.delete(name);
+          }
+        }
+      }
+
+      // Prepare new export lines for any remaining names
+      const lines: string[] = [];
+      for (const [spec, names] of desiredExports) {
+        const missing = Array.from(names);
+        if (missing.length === 0) continue;
+        const specEscaped = spec.replace(/\\/g, '/');
+        lines.push(`export { ${missing.join(', ')} } from "${specEscaped}";`);
+      }
+
+      if (lines.length > 0) {
+        const appended = (existing.endsWith('\n') ? '' : '\n') + lines.join('\n') + '\n';
+        if (writeFileIfChanged(indexFilePath, existing + appended)) {
+          filesChanged++;
+          debug(`Merged exports into existing index.ts`);
+        }
+      } else {
+        debug(`index.ts is up to date; no merge needed.`);
+      }
+    } catch (err) {
+      warn(`Failed to merge into existing index.ts. Skipping modifications: ${indexFilePath}`);
+    }
   }
   
   timeEnd('reactGen');

package/src/vue.ts

@@ -50,6 +50,10 @@ function generateEventHandlerType(type: ParameterType) {
   if (pointerType === 'CustomEvent') {
     return 'CustomEvent';
   }
+  // Handle generic types like CustomEvent<T>
+  if (pointerType.startsWith('CustomEvent<')) {
+    return pointerType;
+  }
   throw new Error('Unknown event type: ' + pointerType);
 }
 
@@ -66,6 +70,11 @@ function generateMethodDeclaration(method: FunctionDeclaration) {
 
 function generateVueComponent(blob: IDLBlob) {
   const classObjects = blob.objects as ClassObject[];
+  
+  // Skip if no class objects
+  if (!classObjects || classObjects.length === 0) {
+    return '';
+  }
   const classObjectDictionary = Object.fromEntries(
     classObjects.map(object => {
       return [object.name, object];
@@ -85,6 +94,9 @@ function generateVueComponent(blob: IDLBlob) {
   });
 
   const dependencies = others.map(object => {
+    if (!object || !object.props) {
+      return '';
+    }
     const props = object.props.map(prop => {
       if (prop.optional) {
         return `${prop.name}?: ${generateReturnType(prop.type)};`;
@@ -96,7 +108,7 @@ function generateVueComponent(blob: IDLBlob) {
 interface ${object.name} {
   ${props}
 }`;
-  }).join('\n\n');
+  }).filter(dep => dep.trim() !== '').join('\n\n');
 
   const componentProperties = properties.length > 0 ? properties[0] : undefined;
   const componentEvents = events.length > 0 ? events[0] : undefined;
@@ -165,7 +177,11 @@ export function generateVueTypings(blobs: IDLBlob[]) {
     return component.length > 0;
   }).join('\n\n');
 
-  const content = _.template(readTemplate('vue.components.d.ts'))({
+  const content = _.template(readTemplate('vue.components.d.ts'), {
+    interpolate: /<%=([\s\S]+?)%>/g,
+    evaluate: /<%([\s\S]+?)%>/g,
+    escape: /<%-([\s\S]+?)%>/g
+  })({
     componentNames,
     components,
   });

package/templates/class.dart.tpl

@@ -1,6 +1,6 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 //
-// Generated by <%= command %>
+// Generated by `webf codegen`
 
 // ignore_for_file: avoid_unused_constructor_parameters
 // ignore_for_file: non_constant_identifier_names

package/templates/vue.components.d.ts.tpl

@@ -14,18 +14,23 @@ type VueEmit<T extends EventMap> = EmitFn<{
   [K in keyof T]: (event: T[K]) => void
 }>
 
+// Vue 3 event listener properties for template usage
+type VueEventListeners<T extends EventMap> = {
+  [K in keyof T as `on${Capitalize<string & K>}`]?: (event: T[K]) => any
+}
+
 type DefineCustomElement<
   ElementType,
   Events extends EventMap = {},
   SelectedAttributes extends keyof ElementType = keyof ElementType
-> = new () => ElementType & {
+> = new () => ElementType & VueEventListeners<Events> & {
   // Use $props to define the properties exposed to template type checking. Vue
   // specifically reads prop definitions from the `$props` type. Note that we
   // combine the element's props with the global HTML props and Vue's special
   // props.
   /** @deprecated Do not use the $props property on a Custom Element ref,
     this is for template prop types only. */
-  $props: Partial<Pick<ElementType, SelectedAttributes>> & PublicProps
+  $props: Partial<Pick<ElementType, SelectedAttributes>> & PublicProps & VueEventListeners<Events>
 
   // Use $emit to specifically define event types. Vue specifically reads event
   // types from the `$emit` type. Note that `$emit` expects a particular format
@@ -40,7 +45,7 @@ type DefineCustomElement<
 declare module 'vue' {
   interface GlobalComponents {
     <% componentNames.forEach(name => { %>
-    '<%= _.kebabCase(name) %>': DefineCustomElement<
+    '<%= name %>': DefineCustomElement<
       <%= name %>Props,
       <%= name %>Events
     >

package/templates/vue.package.json.tpl

@@ -7,5 +7,11 @@
   "files": ["index.d.ts"],
   "keywords": [],
   "author": "",
-  "license": "ISC"
+  "license": "ISC",
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  },
+  "devDependencies": {
+    "vue": "^3.0.0"
+  }
 }

package/test/commands.test.ts

@@ -284,10 +284,10 @@ describe('Commands', () => {
           { cwd: target, stdio: 'inherit' }
         );
 
-        // Should install Vue types as dev dependency
+        // Should install Vue 3 as dev dependency
         expect(mockSpawnSync).toHaveBeenCalledWith(
           expect.stringMatching(/npm(\.cmd)?/),
-          ['install', '@types/vue', '-D'],
+          ['install', 'vue', '-D'],
           { cwd: target, stdio: 'inherit' }
         );
       });

package/test/generator.test.ts

@@ -336,6 +336,12 @@ describe('Generator', () => {
         'export { Test, TestElement } from "./lib/src/html/test";\n' +
         'export { Component, ComponentElement } from "./lib/src/html/component";'
       );
+      // Ensure index.ts does not exist so it will be generated
+      mockFs.existsSync.mockImplementation((p: any) => {
+        const s = p.toString();
+        if (s.includes(path.join('/test/target', 'src', 'index.ts'))) return false;
+        return true;
+      });
       
       await reactGen({
         source: '/test/source',
@@ -357,6 +363,29 @@ describe('Generator', () => {
       expect(indexCall![1]).toContain('export { Test, TestElement }');
       expect(indexCall![1]).toContain('export { Component, ComponentElement }');
     });
+
+    it('should not overwrite user-managed index.ts', async () => {
+      // Existing index.ts that does not contain auto-generated marker
+      mockFs.existsSync.mockImplementation((p: any) => {
+        const s = p.toString();
+        if (s.includes(path.join('/test/target', 'src', 'index.ts'))) return true;
+        return true;
+      });
+      mockFs.readFileSync.mockImplementation((p: any) => {
+        const s = p.toString();
+        if (s.includes(path.join('/test/target', 'src', 'index.ts'))) return '// custom index file';
+        return 'test content';
+      });
+
+      await reactGen({
+        source: '/test/source',
+        target: '/test/target',
+        command: 'test command'
+      });
+
+      const indexWrite = mockFs.writeFileSync.mock.calls.find(call => call[0].toString().includes('index.ts'));
+      expect(indexWrite).toBeUndefined();
+    });
   });
 
   describe('vueGen', () => {
@@ -478,4 +507,4 @@ describe('Generator', () => {
       expect(mockAnalyzer.clearCaches).toHaveBeenCalled();
     });
   });
-});
+});

package/tsconfig.json

@@ -20,7 +20,10 @@
     "esModuleInterop": true,
     "allowSyntheticDefaultImports": true,
     "declaration": false,
-    "outDir": "./dist"
+    "outDir": "./dist",
+    "typeRoots": [
+      "./node_modules/@types"
+    ]
   },
   "include": [
     "src/**/*.ts"