@openwebf/webf 0.24.1 → 0.24.3

package/src/commands.ts

@@ -177,8 +177,8 @@ const moduleTsConfig = fs.readFileSync(
   'utf-8'
 );
 
-const moduleTsUpConfig = fs.readFileSync(
-  path.resolve(__dirname, '../templates/module.tsup.config.ts.tpl'),
+const moduleTsDownConfig = fs.readFileSync(
+  path.resolve(__dirname, '../templates/module.tsdown.config.ts.tpl'),
   'utf-8'
 );
 const reactPackageJson = fs.readFileSync(
@@ -191,8 +191,8 @@ const reactTsConfig = fs.readFileSync(
   'utf-8'
 );
 
-const reactTsUpConfig = fs.readFileSync(
-  path.resolve(__dirname, '../templates/react.tsup.config.ts.tpl'),
+const reactTsDownConfig = fs.readFileSync(
+  path.resolve(__dirname, '../templates/react.tsdown.config.ts.tpl'),
   'utf-8'
 );
 
@@ -239,6 +239,40 @@ function readFlutterPackageMetadata(packagePath: string): FlutterPackageMetadata
   }
 }
 
+function copyReadmeToPackageRoot(params: {
+  sourceRoot: string;
+  targetRoot: string;
+}): { copied: boolean; sourcePath?: string; targetPath: string } {
+  const { sourceRoot, targetRoot } = params;
+  const targetPath = path.join(targetRoot, 'README.md');
+
+  if (fs.existsSync(targetPath)) {
+    return { copied: false, targetPath };
+  }
+
+  const candidateNames = ['README.md', 'Readme.md', 'readme.md'];
+  let sourcePath: string | null = null;
+  for (const candidate of candidateNames) {
+    const abs = path.join(sourceRoot, candidate);
+    if (fs.existsSync(abs)) {
+      sourcePath = abs;
+      break;
+    }
+  }
+
+  if (!sourcePath) {
+    return { copied: false, targetPath };
+  }
+
+  try {
+    const content = fs.readFileSync(sourcePath, 'utf-8');
+    writeFileIfChanged(targetPath, content);
+    return { copied: true, sourcePath, targetPath };
+  } catch {
+    return { copied: false, targetPath };
+  }
+}
+
 // Copy markdown docs that match .d.ts basenames from source to the built dist folder,
 // and generate an aggregated README.md in the dist directory.
 async function copyMarkdownDocsToDist(params: {
@@ -419,9 +453,9 @@ function createCommand(target: string, options: { framework: string; packageName
     const tsConfigContent = _.template(reactTsConfig)({});
     writeFileIfChanged(tsConfigPath, tsConfigContent);
 
-    const tsupConfigPath = path.join(target, 'tsup.config.ts');
-    const tsupConfigContent = _.template(reactTsUpConfig)({});
-    writeFileIfChanged(tsupConfigPath, tsupConfigContent);
+    const tsdownConfigPath = path.join(target, 'tsdown.config.ts');
+    const tsdownConfigContent = _.template(reactTsDownConfig)({});
+    writeFileIfChanged(tsdownConfigPath, tsdownConfigContent);
 
     const gitignorePath = path.join(target, '.gitignore');
     const gitignoreContent = _.template(gitignore)({});
@@ -498,9 +532,9 @@ function createModuleProject(target: string, options: { packageName: string; met
   const tsConfigContent = _.template(moduleTsConfig)({});
   writeFileIfChanged(tsConfigPath, tsConfigContent);
 
-  const tsupConfigPath = path.join(target, 'tsup.config.ts');
-  const tsupConfigContent = _.template(moduleTsUpConfig)({});
-  writeFileIfChanged(tsupConfigPath, tsupConfigContent);
+  const tsdownConfigPath = path.join(target, 'tsdown.config.ts');
+  const tsdownConfigContent = _.template(moduleTsDownConfig)({});
+  writeFileIfChanged(tsdownConfigPath, tsdownConfigContent);
 
   if (!skipGitignore) {
     const gitignorePath = path.join(target, '.gitignore');
@@ -780,6 +814,17 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
   // Auto-initialize typings in the output directory if needed
   ensureInitialized(resolvedDistPath);
 
+  // Copy README.md from the source Flutter package into the npm package root (so `npm publish` includes it).
+  if (options.flutterPackageSrc) {
+    const { copied } = copyReadmeToPackageRoot({
+      sourceRoot: options.flutterPackageSrc,
+      targetRoot: resolvedDistPath,
+    });
+    if (copied) {
+      console.log('📄 Copied README.md to package root');
+    }
+  }
+
   console.log(`\nGenerating ${framework} code from ${options.flutterPackageSrc}...`);
 
   await dartGen({
@@ -1019,7 +1064,7 @@ async function generateModuleCommand(distPath: string, options: GenerateOptions)
     packageName = packageNameAnswer.packageName;
   }
 
-  // Prevent npm scaffolding (package.json, tsup.config.ts, etc.) from being written into
+  // Prevent npm scaffolding (package.json, tsdown.config.ts, etc.) from being written into
   // the Flutter package itself. Force users to choose a separate output directory.
   if (resolvedDistPath === flutterPackageSrc) {
     console.error('\n❌ Output directory must not be the Flutter package root.');
@@ -1070,6 +1115,15 @@ async function generateModuleCommand(distPath: string, options: GenerateOptions)
     command,
   });
 
+  // Copy README.md from the source Flutter package into the npm package root
+  const { copied } = copyReadmeToPackageRoot({
+    sourceRoot: flutterPackageSrc,
+    targetRoot: resolvedDistPath,
+  });
+  if (copied) {
+    console.log('📄 Copied README.md to package root');
+  }
+
   console.log('\nModule code generation completed successfully!');
 
   try {

package/src/generator.ts

@@ -329,7 +329,8 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
   const newExports = generateReactIndex(blobs);
 
   // Build desired export map: moduleSpecifier -> Set of names
-  const desiredExports = new Map<string, Set<string>>();
+  const desiredValueExports = new Map<string, Set<string>>();
+  const desiredTypeExports = 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'));
@@ -351,10 +352,10 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
   }
   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 (!desiredValueExports.has(spec)) desiredValueExports.set(spec, new Set());
+    if (!desiredTypeExports.has(spec)) desiredTypeExports.set(spec, new Set());
+    desiredValueExports.get(spec)!.add(className);
+    desiredTypeExports.get(spec)!.add(`${className}Element`);
   }
 
   if (!fs.existsSync(indexFilePath)) {
@@ -376,22 +377,41 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
             ? stmt.moduleSpecifier.text
             : undefined;
           if (!moduleSpecifier) continue;
-          const desired = desiredExports.get(moduleSpecifier);
-          if (!desired) continue;
+          const desiredValues = desiredValueExports.get(moduleSpecifier);
+          const desiredTypes = desiredTypeExports.get(moduleSpecifier);
+          if (!desiredValues && !desiredTypes) continue;
+          const declIsTypeOnly = Boolean((stmt as unknown as { isTypeOnly?: boolean }).isTypeOnly);
           for (const el of stmt.exportClause.elements) {
             const name = el.name.getText(sourceFile);
-            if (desired.has(name)) desired.delete(name);
+            const specIsTypeOnly = Boolean((el as unknown as { isTypeOnly?: boolean }).isTypeOnly);
+            const isTypeOnly = declIsTypeOnly || specIsTypeOnly;
+            if (isTypeOnly) {
+              if (desiredTypes?.has(name)) desiredTypes.delete(name);
+            } else {
+              if (desiredValues?.has(name)) desiredValues.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 specs = new Set<string>([
+        ...desiredValueExports.keys(),
+        ...desiredTypeExports.keys()
+      ]);
+
+      for (const spec of specs) {
+        const missingValues = Array.from(desiredValueExports.get(spec) ?? []);
+        const missingTypes = Array.from(desiredTypeExports.get(spec) ?? []);
+        if (missingValues.length === 0 && missingTypes.length === 0) continue;
         const specEscaped = spec.replace(/\\/g, '/');
-        lines.push(`export { ${missing.join(', ')} } from "${specEscaped}";`);
+        if (missingValues.length > 0) {
+          lines.push(`export { ${missingValues.join(', ')} } from "${specEscaped}";`);
+        }
+        if (missingTypes.length > 0) {
+          lines.push(`export type { ${missingTypes.join(', ')} } from "${specEscaped}";`);
+        }
       }
 
       if (lines.length > 0) {

package/src/module.ts

@@ -12,10 +12,24 @@ interface ModuleMethodSpec {
   documentation?: string;
 }
 
+interface ModuleEventSpec {
+  name: string;
+  eventTypeText: string;
+  extraTypeText: string;
+  documentation?: string;
+}
+
 interface ModuleDefinition {
   interfaceName: string;
   moduleName: string;
   methods: ModuleMethodSpec[];
+  events?: {
+    interfaceName: string;
+    eventNameTypeName: string;
+    eventArgsTypeName: string;
+    listenerTypeName: string;
+    events: ModuleEventSpec[];
+  };
   supportingStatements: ts.Statement[];
   sourceFile: ts.SourceFile;
 }
@@ -32,13 +46,12 @@ function parseModuleDefinition(modulePath: string): ModuleDefinition {
 
   let interfaceDecl: ts.InterfaceDeclaration | undefined;
   const supporting: ts.Statement[] = [];
+  const webfInterfaceDecls: ts.InterfaceDeclaration[] = [];
 
   for (const stmt of sourceFile.statements) {
     if (ts.isInterfaceDeclaration(stmt)) {
       const name = stmt.name.text;
-      if (!interfaceDecl && name.startsWith('WebF')) {
-        interfaceDecl = stmt;
-      }
+      if (name.startsWith('WebF')) webfInterfaceDecls.push(stmt);
       supporting.push(stmt);
     } else if (
       ts.isTypeAliasDeclaration(stmt) ||
@@ -49,6 +62,17 @@ function parseModuleDefinition(modulePath: string): ModuleDefinition {
     }
   }
 
+  // Prefer the "main module interface": first WebF* interface that declares methods.
+  if (!interfaceDecl) {
+    interfaceDecl = webfInterfaceDecls.find(decl =>
+      decl.members.some(member => ts.isMethodSignature(member))
+    );
+  }
+
+  if (!interfaceDecl) {
+    interfaceDecl = webfInterfaceDecls[0];
+  }
+
   if (!interfaceDecl) {
     throw new Error(
       `No interface starting with "WebF" found in module interface file: ${modulePath}`
@@ -100,13 +124,93 @@ function parseModuleDefinition(modulePath: string): ModuleDefinition {
     });
   }
 
+  // Optional module events declaration:
+  // `interface WebF<ModuleName>ModuleEvents { scanResult: [Event, Payload]; }`
+  const eventsInterfaceName = `${interfaceName}ModuleEvents`;
+  const eventsDecl = sourceFile.statements.find(
+    stmt => ts.isInterfaceDeclaration(stmt) && stmt.name.text === eventsInterfaceName
+  ) as ts.InterfaceDeclaration | undefined;
+
+  let events:
+    | {
+        interfaceName: string;
+        eventNameTypeName: string;
+        eventArgsTypeName: string;
+        listenerTypeName: string;
+        events: ModuleEventSpec[];
+      }
+    | undefined;
+
+  if (eventsDecl) {
+    const eventSpecs: ModuleEventSpec[] = [];
+    for (const member of eventsDecl.members) {
+      if (!ts.isPropertySignature(member) || !member.name) continue;
+
+      const rawName = member.name.getText(sourceFile);
+      const eventName = rawName.replace(/['"]/g, '');
+
+      let eventTypeText = 'Event';
+      let extraTypeText = 'any';
+
+      if (member.type) {
+        if (ts.isTupleTypeNode(member.type) && member.type.elements.length === 2) {
+          eventTypeText = printer.printNode(
+            ts.EmitHint.Unspecified,
+            member.type.elements[0],
+            sourceFile
+          );
+          extraTypeText = printer.printNode(
+            ts.EmitHint.Unspecified,
+            member.type.elements[1],
+            sourceFile
+          );
+        } else {
+          eventTypeText = printer.printNode(ts.EmitHint.Unspecified, member.type, sourceFile);
+        }
+      }
+
+      let documentation: string | undefined;
+      const jsDocs = (member as any).jsDoc as ts.JSDoc[] | undefined;
+      if (jsDocs && jsDocs.length > 0) {
+        documentation = jsDocs
+          .map(doc => doc.comment)
+          .filter(Boolean)
+          .join('\n');
+      }
+
+      eventSpecs.push({
+        name: eventName,
+        eventTypeText,
+        extraTypeText,
+        documentation,
+      });
+    }
+
+    if (eventSpecs.length > 0) {
+      events = {
+        interfaceName: eventsInterfaceName,
+        eventNameTypeName: `${interfaceName}ModuleEventName`,
+        eventArgsTypeName: `${interfaceName}ModuleEventArgs`,
+        listenerTypeName: `${interfaceName}ModuleEventListener`,
+        events: eventSpecs,
+      };
+    }
+  }
+
   if (methods.length === 0) {
     throw new Error(
       `Interface ${interfaceName} in ${modulePath} does not declare any methods`
     );
   }
 
-  return { interfaceName, moduleName, methods, supportingStatements: supporting, sourceFile };
+  return {
+    interfaceName,
+    moduleName,
+    methods,
+    events,
+    supportingStatements: supporting,
+    sourceFile,
+  };
 }
 
 function buildTypesFile(def: ModuleDefinition): string {
@@ -144,6 +248,24 @@ function buildTypesFile(def: ModuleDefinition): string {
   }
 
   lines.push('');
+
+  if (def.events) {
+    const { interfaceName, eventNameTypeName, eventArgsTypeName, listenerTypeName } = def.events;
+
+    lines.push(`export type ${eventNameTypeName} = Extract<keyof ${interfaceName}, string>;`);
+    lines.push(
+      `export type ${eventArgsTypeName}<K extends ${eventNameTypeName} = ${eventNameTypeName}> =`
+    );
+    lines.push(`  ${interfaceName}[K] extends readonly [infer E, infer X]`);
+    lines.push(`    ? [event: (E & { type: K }), extra: X]`);
+    lines.push(`    : [event: (${interfaceName}[K] & { type: K }), extra: any];`);
+    lines.push('');
+    lines.push(`export type ${listenerTypeName} = (...args: {`);
+    lines.push(`  [K in ${eventNameTypeName}]: ${eventArgsTypeName}<K>;`);
+    lines.push(`}[${eventNameTypeName}]) => any;`);
+    lines.push('');
+  }
+
   // Ensure file is treated as a module even if no declarations were emitted.
   lines.push('export {};');
   return lines.join('\n');
@@ -180,6 +302,10 @@ function buildIndexFile(def: ModuleDefinition): string {
       typeImportNames.add(name);
     }
   }
+  if (def.events) {
+    typeImportNames.add(def.events.eventNameTypeName);
+    typeImportNames.add(def.events.eventArgsTypeName);
+  }
   const typeImportsSorted = Array.from(typeImportNames).sort();
   if (typeImportsSorted.length > 0) {
     lines.push(
@@ -200,6 +326,64 @@ function buildIndexFile(def: ModuleDefinition): string {
   lines.push('  }');
   lines.push('');
 
+  if (def.events) {
+    lines.push('  private static _moduleListenerInstalled = false;');
+    lines.push(
+      '  private static _listeners: Record<string, Set<(event: Event, extra: any) => any>> = Object.create(null);'
+    );
+    lines.push('');
+
+    lines.push(
+      `  static addListener<K extends ${def.events.eventNameTypeName}>(type: K, listener: (...args: ${def.events.eventArgsTypeName}<K>) => any): () => void {`
+    );
+    lines.push(
+      "    if (typeof webf === 'undefined' || typeof (webf as any).addWebfModuleListener !== 'function') {"
+    );
+    lines.push(
+      "      throw new Error('WebF module event API is not available. Make sure you are running in WebF runtime.');"
+    );
+    lines.push('    }');
+    lines.push('');
+    lines.push('    if (!this._moduleListenerInstalled) {');
+    lines.push(
+      `      (webf as any).addWebfModuleListener('${def.moduleName}', (event: Event, extra: any) => {`
+    );
+    lines.push('        const set = this._listeners[event.type];');
+    lines.push('        if (!set) return;');
+    lines.push('        for (const fn of set) { fn(event, extra); }');
+    lines.push('      });');
+    lines.push('      this._moduleListenerInstalled = true;');
+    lines.push('    }');
+    lines.push('');
+    lines.push('    (this._listeners[type] ??= new Set()).add(listener as any);');
+    lines.push('');
+    lines.push('    const cls = this;');
+    lines.push('    return () => {');
+    lines.push('      const set = cls._listeners[type];');
+    lines.push('      if (!set) return;');
+    lines.push('      set.delete(listener as any);');
+    lines.push('      if (set.size === 0) { delete cls._listeners[type]; }');
+    lines.push('');
+    lines.push('      if (Object.keys(cls._listeners).length === 0) {');
+    lines.push('        cls.removeListener();');
+    lines.push('      }');
+    lines.push('    };');
+    lines.push('  }');
+    lines.push('');
+
+    lines.push('  static removeListener(): void {');
+    lines.push('    this._listeners = Object.create(null);');
+    lines.push('    this._moduleListenerInstalled = false;');
+    lines.push(
+      "    if (typeof webf === 'undefined' || typeof (webf as any).removeWebfModuleListener !== 'function') {"
+    );
+    lines.push('      return;');
+    lines.push('    }');
+    lines.push(`    (webf as any).removeWebfModuleListener('${def.moduleName}');`);
+    lines.push('  }');
+    lines.push('');
+  }
+
   for (const method of def.methods) {
     if (method.documentation) {
       lines.push('  /**');
@@ -246,6 +430,11 @@ function buildIndexFile(def: ModuleDefinition): string {
       typeExportNames.add(stmt.name.text);
     }
   }
+  if (def.events) {
+    typeExportNames.add(def.events.eventNameTypeName);
+    typeExportNames.add(def.events.eventArgsTypeName);
+    typeExportNames.add(def.events.listenerTypeName);
+  }
   const sorted = Array.from(typeExportNames).sort();
   if (sorted.length) {
     lines.push('  ' + sorted.join(','));
@@ -359,6 +548,9 @@ function buildDartBindings(def: ModuleDefinition, command: string): string {
   lines.push('// Generated by `webf module-codegen`');
   lines.push('');
   lines.push("import 'package:webf/module.dart';");
+  if (def.events) {
+    lines.push("import 'package:webf/dom.dart';");
+  }
   if (
     def.methods.some(m =>
       m.params.some(p => isTsByteArrayUnion(p.typeText))
@@ -371,7 +563,11 @@ function buildDartBindings(def: ModuleDefinition, command: string): string {
   // Generate Dart classes for supporting TS interfaces (compound option types).
   const optionInterfaces: ts.InterfaceDeclaration[] = [];
   for (const stmt of def.supportingStatements) {
-    if (ts.isInterfaceDeclaration(stmt) && stmt.name.text !== def.interfaceName) {
+    if (
+      ts.isInterfaceDeclaration(stmt) &&
+      stmt.name.text !== def.interfaceName &&
+      stmt.name.text !== def.events?.interfaceName
+    ) {
       optionInterfaces.push(stmt);
     }
   }
@@ -477,6 +673,27 @@ function buildDartBindings(def: ModuleDefinition, command: string): string {
   lines.push(`  String get name => '${def.moduleName}';`);
   lines.push('');
 
+  if (def.events) {
+    for (const evt of def.events.events) {
+      const methodName = `emit${_.upperFirst(_.camelCase(evt.name))}`;
+
+      const mappedExtra = mapTsParamTypeToDart(evt.extraTypeText, optionTypeNames);
+      const dataParamType = mappedExtra.optionClassName
+        ? `${mappedExtra.optionClassName}?`
+        : 'dynamic';
+
+      lines.push(`  dynamic ${methodName}({Event? event, ${dataParamType} data}) {`);
+      if (mappedExtra.optionClassName) {
+        lines.push('    final mapped = data?.toMap();');
+        lines.push(`    return dispatchEvent(event: event ?? Event('${evt.name}'), data: mapped);`);
+      } else {
+        lines.push(`    return dispatchEvent(event: event ?? Event('${evt.name}'), data: data);`);
+      }
+      lines.push('  }');
+      lines.push('');
+    }
+  }
+
   for (const method of def.methods) {
     const dartMethodName = _.camelCase(method.name);
     let dartReturnType = mapTsReturnTypeToDart(method.returnTypeText);

package/templates/module.package.json.tpl

@@ -2,13 +2,25 @@
   "name": "<%= packageName %>",
   "version": "<%= version %>",
   "description": "<%= description %>",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
   "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
   "files": ["dist"],
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "clean": "rimraf dist",
     "prepublishOnly": "npm run build"
   },
@@ -26,11 +38,10 @@
   },
   "devDependencies": {
     "rimraf": "^5.0.0",
-    "tsup": "^8.5.0",
+    "tsdown": "^0.19.0",
     "typescript": "^5.8.3"
   },
   "publishConfig": {
     "access": "public"
   }
 }
-

package/templates/{module.tsup.config.ts.tpl → module.tsdown.config.ts.tpl}

@@ -1,13 +1,8 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
+module.exports = {
   entry: ['src/index.ts'],
   format: ['cjs', 'esm'],
   dts: true,
   clean: true,
-  splitting: false,
   sourcemap: true,
-  minify: false,
   external: [],
-});
-
+};

package/templates/react.component.tsx.tpl

@@ -63,12 +63,16 @@ export interface <%= className %>Props {
 
 <% if (methods && methods.methods.length > 0) { %>
 /**
- * Element interface with methods accessible via ref
+ * Element interface with methods/properties accessible via ref
  * @example
  * ```tsx
  * const ref = useRef<<%= className %>Element>(null);
  * // Call methods on the element
  * ref.current?.finishRefresh('success');
+<% if (properties && properties.props && properties.props.length > 0) { %>
+ * // Access properties
+ * console.log(ref.current?.<%= _.camelCase(properties.props[0].name || 'someProp') %>);
+<% } %>
  * ```
  */
 <% } %>
@@ -76,7 +80,19 @@ export interface <%= className %>Element extends WebFElementWithMethods<{
   <% _.forEach(methods?.methods, function(method, index) { %>
 <%= generateMethodDeclarationWithDocs(method, '  ') %>
   <% }); %>
-}> {}
+}> {
+  <% _.forEach(properties?.props, function(prop, index) { %>
+  <% var propName = _.camelCase(prop.name); %>
+  <% if (prop.documentation) { %>
+  /** <%= prop.documentation.split('\n')[0] %> */
+  <% } %>
+  <% if (prop.readonly) { %>
+  readonly <%= propName %><% if (prop.optional) { %>?<% } %>: <%= generateReturnType(prop.type) %>;
+  <% } else { %>
+  <%= propName %><% if (prop.optional) { %>?<% } %>: <%= generateReturnType(prop.type) %>;
+  <% } %>
+  <% }); %>
+}
 
 <% if (properties?.documentation || methods?.documentation || events?.documentation) { %>
   <% const docs = properties?.documentation || methods?.documentation || events?.documentation; %>

package/templates/react.package.json.tpl

@@ -2,12 +2,24 @@
   "name": "<%= packageName %>",
   "version": "<%= version %>",
   "description": "<%= description %>",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
   "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
-  "files": ["dist"],
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": ["dist", "README.md"],
   "scripts": {
-    "build": "tsup"
+    "build": "tsdown"
   },
   "keywords": [],
   "author": "",
@@ -23,7 +35,7 @@
     "@types/react": "^19.1.0",
     "@types/react-dom": "^19.1.2",
     "picomatch": "^4.0.2",
-    "tsup": "^8.5.0",
+    "tsdown": "^0.19.0",
     "typescript": "^5.8.3"
   }
 }

package/templates/{react.tsup.config.ts.tpl → react.tsdown.config.ts.tpl}

@@ -1,10 +1,8 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
+module.exports = {
   entry: ['src/index.ts'],
   format: ['esm', 'cjs'],
   dts: true,
   sourcemap: true,
   clean: true,
   external: ['react', 'react-dom', '@openwebf/react-core-ui'],
-})
+};

package/templates/vue.package.json.tpl

@@ -4,7 +4,7 @@
   "description": "<%= description %>",
   "main": "",
   "types": "index.d.ts",
-  "files": ["index.d.ts"],
+  "files": ["index.d.ts", "README.md"],
   "keywords": [],
   "author": "",
   "license": "ISC",