@openwebf/webf 0.23.2 → 0.23.10

package/test/commands.test.ts

@@ -2,15 +2,20 @@
 jest.mock('fs');
 jest.mock('child_process');
 jest.mock('../src/generator');
+jest.mock('glob', () => ({
+  globSync: jest.fn(),
+}));
 jest.mock('inquirer');
 jest.mock('yaml');
 
 import fs from 'fs';
 import path from 'path';
 import { spawnSync } from 'child_process';
+import { globSync } from 'glob';
 
 const mockFs = fs as jest.Mocked<typeof fs>;
 const mockSpawnSync = spawnSync as jest.MockedFunction<typeof spawnSync>;
+const mockGlobSync = globSync as jest.MockedFunction<typeof globSync>;
 
 // Set up default mocks before importing commands
 mockFs.readFileSync = jest.fn().mockImplementation((filePath: any) => {
@@ -84,6 +89,7 @@ describe('Commands', () => {
     });
     // Default mock for readdirSync to avoid undefined
     mockFs.readdirSync.mockReturnValue([] as any);
+    mockGlobSync.mockReturnValue([]);
   });
 
 
@@ -220,11 +226,11 @@ describe('Commands', () => {
         // Mock that required files don't exist
         mockFs.existsSync.mockReturnValue(false);
         
-        await generateCommand(target, options);
+      await generateCommand(target, options);
 
         expect(mockSpawnSync).toHaveBeenCalledWith(
           expect.stringMatching(/npm(\.cmd)?/),
-          ['install', '--omit=peer'],
+          ['install'],
           { cwd: target, stdio: 'inherit' }
         );
       });
@@ -356,6 +362,36 @@ describe('Commands', () => {
       consoleSpy.mockRestore();
     });
 
+    it('should generate only Dart bindings when dartOnly is set', async () => {
+      const options = {
+        flutterPackageSrc: '/flutter/src',
+        dartOnly: true,
+      };
+      
+      // Mock TypeScript validation
+      mockTypeScriptValidation('/flutter/src');
+      
+      await generateCommand('/dist', options as any);
+      
+      // Should call dartGen for the Flutter package, but not reactGen/vueGen
+      expect(mockGenerator.dartGen).toHaveBeenCalledWith({
+        source: '/flutter/src',
+        target: '/flutter/src',
+        command: expect.stringContaining('webf codegen'),
+        exclude: undefined,
+      });
+      expect(mockGenerator.reactGen).not.toHaveBeenCalled();
+      expect(mockGenerator.vueGen).not.toHaveBeenCalled();
+      
+      // Should not attempt to build or run npm scripts
+      const spawnCalls = (mockSpawnSync as jest.Mock).mock.calls;
+      const buildOrPublishCalls = spawnCalls.filter(call => {
+        const args = call[1] as any;
+        return Array.isArray(args) && (args.includes('run') || args.includes('publish') || args.includes('install'));
+      });
+      expect(buildOrPublishCalls).toHaveLength(0);
+    });
+
     it('should show instructions when --flutter-package-src is missing', async () => {
       const options = { framework: 'react' };
       
@@ -420,11 +456,57 @@ describe('Commands', () => {
       
       await generateCommand('/dist', options);
 
-      expect(mockGenerator.reactGen).toHaveBeenCalledWith({
+      expect(mockGenerator.reactGen).toHaveBeenCalledWith(expect.objectContaining({
         source: '/flutter/src',
         target: path.resolve('/dist'),
         command: expect.stringContaining('webf codegen')
+      }));
+    });
+
+    it('should generate an aggregated README in dist from markdown docs', async () => {
+      const options = {
+        flutterPackageSrc: '/flutter/src',
+        framework: 'react',
+        packageName: 'test-package'
+      };
+
+      // Mock TypeScript validation
+      mockTypeScriptValidation('/flutter/src');
+
+      // Mock .d.ts files so copyMarkdownDocsToDist sees at least one entry
+      mockGlobSync.mockReturnValue(['lib/src/alert.d.ts'] as any);
+
+      const originalExistsSync = mockFs.existsSync as jest.Mock;
+      mockFs.existsSync = jest.fn().mockImplementation((filePath: any) => {
+        const pathStr = filePath.toString();
+        const distRoot = path.join(path.resolve('/dist'), 'dist');
+        if (pathStr === distRoot) return true;
+        if (pathStr === path.join(path.resolve('/dist'), 'package.json')) return true;
+        if (pathStr === path.join(path.resolve('/dist'), 'global.d.ts')) return true;
+        if (pathStr === path.join(path.resolve('/dist'), 'tsconfig.json')) return true;
+        if (pathStr.endsWith('.md') && pathStr.includes('/flutter/src')) return true;
+        return originalExistsSync(filePath);
+      });
+
+      // Ensure that reading a markdown file returns some content
+      const originalReadFileSync = mockFs.readFileSync as jest.Mock;
+      mockFs.readFileSync = jest.fn().mockImplementation((filePath: any, encoding?: any) => {
+        const pathStr = filePath.toString();
+        if (pathStr.endsWith('.md')) {
+          return '# Test Component\n\nThis is a test component doc.';
+        }
+        return originalReadFileSync(filePath, encoding);
       });
+
+      await generateCommand('/dist', options);
+
+      // README.md should be written into dist directory
+      const writeCalls = (mockFs.writeFileSync as jest.Mock).mock.calls;
+      const readmeCall = writeCalls.find(call => {
+        const p = call[0].toString();
+        return p.endsWith(path.join('dist', 'README.md'));
+      });
+      expect(readmeCall).toBeDefined();
     });
 
     it('should create new project if package.json not found', async () => {
@@ -1245,4 +1327,4 @@ describe('Commands', () => {
       });
     });
   });
-});
+});

package/test/dart-nullable-props.test.ts

@@ -0,0 +1,58 @@
+import { analyzer, clearCaches, UnionTypeCollector, ParameterType } from '../src/analyzer';
+import { generateDartClass } from '../src/dart';
+import { IDLBlob } from '../src/IDLBlob';
+
+describe('Dart nullable union properties', () => {
+  beforeEach(() => {
+    clearCaches();
+  });
+
+  it('handles boolean | null properties and maps "null" attribute to null', () => {
+    const tsContent = `
+interface FlutterCupertinoCheckboxProperties {
+  /**
+   * Whether the checkbox is checked.
+   * Default: false.
+   */
+  checked?: boolean | null;
+}
+
+interface FlutterCupertinoCheckboxEvents {
+  /**
+   * Fired when the checkbox value changes.
+   */
+  change: CustomEvent<boolean>;
+}
+`;
+
+    const blob = new IDLBlob('checkbox.d.ts', 'dist', 'checkbox', 'implement');
+    blob.raw = tsContent;
+
+    const definedPropertyCollector = {
+      properties: new Set<string>(),
+      files: new Set<string>(),
+      interfaces: new Set<string>(),
+    };
+    const unionTypeCollector: UnionTypeCollector = { types: new Set<ParameterType[]>() };
+
+    analyzer(blob, definedPropertyCollector, unionTypeCollector);
+
+    const dartCode = generateDartClass(blob, 'test');
+
+    // Should generate bindings class for FlutterCupertinoCheckbox
+    expect(dartCode).toContain('abstract class FlutterCupertinoCheckboxBindings extends WidgetElement {');
+
+    // The checked property should be a nullable bool in Dart bindings.
+    expect(dartCode).toContain('bool? get checked;');
+
+    // Attribute setter should treat the literal "null" as a Dart null.
+    expect(dartCode).toContain(
+      "setter: (value) => checked = value == 'null' ? null : (value == 'true' || value == ''),"
+    );
+
+    // Deleting the attribute should reset to the default `false`.
+    expect(dartCode).toContain(
+      "deleter: () => checked = false"
+    );
+  });
+});

package/test/generator.test.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { glob } from 'glob';
+import { globSync } from 'glob';
 import { dartGen, reactGen, vueGen, clearAllCaches } from '../src/generator';
 import * as analyzer from '../src/analyzer';
 import * as dartGenerator from '../src/dart';
@@ -10,7 +10,9 @@ import { ClassObject } from '../src/declaration';
 
 // Mock dependencies
 jest.mock('fs');
-jest.mock('glob');
+jest.mock('glob', () => ({
+  globSync: jest.fn(),
+}));
 jest.mock('../src/analyzer');
 jest.mock('../src/dart');
 jest.mock('../src/react');
@@ -47,7 +49,7 @@ jest.mock('../src/logger', () => ({
 }));
 
 const mockFs = fs as jest.Mocked<typeof fs>;
-const mockGlob = glob as jest.Mocked<typeof glob>;
+const mockGlobSync = globSync as jest.MockedFunction<typeof globSync>;
 const mockAnalyzer = analyzer as jest.Mocked<typeof analyzer>;
 const mockDartGenerator = dartGenerator as jest.Mocked<typeof dartGenerator>;
 const mockReactGenerator = reactGenerator as jest.Mocked<typeof reactGenerator>;
@@ -65,7 +67,7 @@ describe('Generator', () => {
     mockFs.writeFileSync.mockImplementation(() => undefined);
     mockFs.mkdirSync.mockImplementation(() => undefined);
     
-    mockGlob.globSync.mockReturnValue(['test.d.ts', 'component.d.ts']);
+    mockGlobSync.mockReturnValue(['test.d.ts', 'component.d.ts']);
     
     mockAnalyzer.analyzer.mockImplementation(() => undefined);
     mockAnalyzer.clearCaches.mockImplementation(() => undefined);
@@ -84,7 +86,7 @@ describe('Generator', () => {
         command: 'test command'
       });
 
-      expect(mockGlob.globSync).toHaveBeenCalledWith('**/*.d.ts', {
+      expect(mockGlobSync).toHaveBeenCalledWith('**/*.d.ts', {
         cwd: '/test/source',
         ignore: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/example/**']
       });
@@ -101,14 +103,14 @@ describe('Generator', () => {
         command: 'test command'
       });
 
-      expect(mockGlob.globSync).toHaveBeenCalledWith('**/*.d.ts', {
+      expect(mockGlobSync).toHaveBeenCalledWith('**/*.d.ts', {
         cwd: expect.stringContaining('relative/source'),
         ignore: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/example/**']
       });
     });
 
     it('should filter out global.d.ts files', async () => {
-      mockGlob.globSync.mockReturnValue(['test.d.ts', 'global.d.ts', 'component.d.ts']);
+      mockGlobSync.mockReturnValue(['test.d.ts', 'global.d.ts', 'component.d.ts']);
       
       await dartGen({
         source: '/test/source',
@@ -122,7 +124,7 @@ describe('Generator', () => {
     });
 
     it('should handle empty type files', async () => {
-      mockGlob.globSync.mockReturnValue([]);
+      mockGlobSync.mockReturnValue([]);
       
       await dartGen({
         source: '/test/source',
@@ -135,7 +137,7 @@ describe('Generator', () => {
     });
 
     it('should continue processing if one file fails', async () => {
-      mockGlob.globSync.mockReturnValue(['test1.d.ts', 'test2.d.ts']);
+      mockGlobSync.mockReturnValue(['test1.d.ts', 'test2.d.ts']);
       mockAnalyzer.analyzer
         .mockImplementationOnce(() => { throw new Error('Parse error'); })
         .mockImplementationOnce(() => undefined);
@@ -216,7 +218,7 @@ describe('Generator', () => {
     });
     
     it('should generate index.d.ts with references and exports', async () => {
-      mockGlob.globSync.mockReturnValue(['components/button.d.ts', 'widgets/card.d.ts']);
+      mockGlobSync.mockReturnValue(['components/button.d.ts', 'widgets/card.d.ts']);
       mockFs.readFileSync.mockReturnValue('interface Test {}');
       mockFs.existsSync.mockImplementation((path) => {
         // Source directory exists
@@ -247,7 +249,7 @@ describe('Generator', () => {
     });
     
     it('should copy original .d.ts files to output directory', async () => {
-      mockGlob.globSync.mockReturnValue(['test.d.ts']);
+      mockGlobSync.mockReturnValue(['test.d.ts']);
       const originalContent = 'interface Original {}';
       mockFs.readFileSync.mockReturnValue(originalContent);
       mockFs.existsSync.mockImplementation((path) => {
@@ -279,7 +281,7 @@ describe('Generator', () => {
         exclude: ['**/test/**', '**/docs/**']
       });
 
-      expect(mockGlob.globSync).toHaveBeenCalledWith('**/*.d.ts', {
+      expect(mockGlobSync).toHaveBeenCalledWith('**/*.d.ts', {
         cwd: '/test/source',
         ignore: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/example/**', '**/test/**', '**/docs/**']
       });
@@ -419,7 +421,7 @@ describe('Generator', () => {
     });
 
     it('should only generate one index.d.ts file', async () => {
-      mockGlob.globSync.mockReturnValue(['comp1.d.ts', 'comp2.d.ts', 'comp3.d.ts']);
+      mockGlobSync.mockReturnValue(['comp1.d.ts', 'comp2.d.ts', 'comp3.d.ts']);
       
       await vueGen({
         source: '/test/source',
@@ -436,7 +438,7 @@ describe('Generator', () => {
 
   describe('Error handling', () => {
     it('should handle glob errors', async () => {
-      mockGlob.globSync.mockImplementation(() => {
+      mockGlobSync.mockImplementation(() => {
         throw new Error('Glob error');
       });
       

package/test/react-consts.test.ts

@@ -25,6 +25,6 @@ describe('React generator - declare const support', () => {
     blob.objects = [eo as any];
 
     const output = generateReactComponent(blob);
-    expect(output).toContain("export declare enum CupertinoColors { 'red' = 0x0f, 'bbb' = 0x00 }");
+    expect(output).toContain("export enum CupertinoColors { 'red' = 0x0f, 'bbb' = 0x00 }");
   });
 });

package/test/react-vue-nullable-props.test.ts

@@ -0,0 +1,66 @@
+import { analyzer, clearCaches, UnionTypeCollector, ParameterType } from '../src/analyzer';
+import { generateReactComponent } from '../src/react';
+import { generateVueTypings } from '../src/vue';
+import { IDLBlob } from '../src/IDLBlob';
+
+describe('React/Vue nullable union props', () => {
+  beforeEach(() => {
+    clearCaches();
+  });
+
+  const tsContent = `
+interface FlutterCupertinoCheckboxProperties {
+  /**
+   * Whether the checkbox is checked.
+   * Default: false.
+   */
+  checked?: boolean | null;
+}
+
+interface FlutterCupertinoCheckboxEvents {
+  /**
+   * Fired when the checkbox value changes.
+   */
+  change: CustomEvent<boolean>;
+}
+`;
+
+  it('emits boolean | null for React props', () => {
+    const blob = new IDLBlob('checkbox.d.ts', 'dist', 'checkbox', 'implement');
+    blob.raw = tsContent;
+
+    const definedPropertyCollector = {
+      properties: new Set<string>(),
+      files: new Set<string>(),
+      interfaces: new Set<string>(),
+    };
+    const unionTypeCollector: UnionTypeCollector = { types: new Set<ParameterType[]>() };
+
+    analyzer(blob, definedPropertyCollector, unionTypeCollector);
+
+    const reactCode = generateReactComponent(blob);
+
+    // Prop should allow both undefined and null
+    expect(reactCode).toContain('checked?: boolean | null;');
+  });
+
+  it('emits boolean | null for Vue props', () => {
+    const blob = new IDLBlob('checkbox.d.ts', 'dist', 'checkbox', 'implement');
+    blob.raw = tsContent;
+
+    const definedPropertyCollector = {
+      properties: new Set<string>(),
+      files: new Set<string>(),
+      interfaces: new Set<string>(),
+    };
+    const unionTypeCollector: UnionTypeCollector = { types: new Set<ParameterType[]>() };
+
+    analyzer(blob, definedPropertyCollector, unionTypeCollector);
+
+    const vueCode = generateVueTypings([blob]);
+
+    // Vue prop name is kebab-cased and should allow null explicitly
+    expect(vueCode).toContain(`'checked'?: boolean | null;`);
+  });
+});
+

package/test/react.test.ts

@@ -181,9 +181,9 @@ describe('React Generator', () => {
       
       const result = generateReactComponent(blob);
       
-      // Should include custom props (dom_string is not converted in raw output)
-      expect(result).toContain('title: dom_string;');
-      expect(result).toContain('disabled?: boolean;');
+      // Should include custom props with generated TS types
+      expect(result).toContain('title: __webfTypes.dom_string;');
+      expect(result).toContain('disabled?: __webfTypes.boolean;');
       
       // And still include standard HTML props
       expect(result).toContain('id?: string;');
@@ -191,5 +191,47 @@ describe('React Generator', () => {
       expect(result).toContain('children?: React.ReactNode;');
       expect(result).toContain('className?: string;');
     });
+
+    it('should preserve JSDoc for supporting option interfaces', () => {
+      const blob = new IDLBlob('/test/source', '/test/target', 'TestComponent', 'test', '');
+      
+      const properties = new ClassObject();
+      properties.name = 'TestComponentProperties';
+      properties.kind = ClassObjectKind.interface;
+
+      const options = new ClassObject();
+      options.name = 'TestComponentOptions';
+      options.kind = ClassObjectKind.interface;
+
+      const titleProp = new PropsDeclaration();
+      titleProp.name = 'title';
+      titleProp.type = { value: 'string' } as any;
+      titleProp.optional = true;
+      titleProp.documentation = 'Optional override title for this show() call.';
+      titleProp.readonly = false;
+      titleProp.typeMode = {};
+
+      const messageProp = new PropsDeclaration();
+      messageProp.name = 'message';
+      messageProp.type = { value: 'string' } as any;
+      messageProp.optional = true;
+      messageProp.documentation = 'Optional override message for this show() call.';
+      messageProp.readonly = false;
+      messageProp.typeMode = {};
+
+      options.props = [titleProp, messageProp];
+
+      blob.objects = [properties, options];
+      
+      const result = generateReactComponent(blob);
+
+      expect(result).toContain('interface TestComponentOptions');
+      expect(result).toMatch(
+        /interface TestComponentOptions[\s\S]*?\/\*\*[\s\S]*?Optional override title for this show\(\) call\.[\s\S]*?\*\/\s*\n\s*title\?:/
+      );
+      expect(result).toMatch(
+        /interface TestComponentOptions[\s\S]*?\/\*\*[\s\S]*?Optional override message for this show\(\) call\.[\s\S]*?\*\/\s*\n\s*message\?:/
+      );
+    });
   });
-});
+});