@openwebf/webf 0.23.0 → 0.23.7

package/test/commands.test.ts

@@ -2,15 +2,18 @@
 jest.mock('fs');
 jest.mock('child_process');
 jest.mock('../src/generator');
+jest.mock('glob');
 jest.mock('inquirer');
 jest.mock('yaml');
 
 import fs from 'fs';
 import path from 'path';
 import { spawnSync } from 'child_process';
+import { glob } from 'glob';
 
 const mockFs = fs as jest.Mocked<typeof fs>;
 const mockSpawnSync = spawnSync as jest.MockedFunction<typeof spawnSync>;
+const mockGlob = glob as jest.Mocked<typeof glob>;
 
 // Set up default mocks before importing commands
 mockFs.readFileSync = jest.fn().mockImplementation((filePath: any) => {
@@ -84,6 +87,7 @@ describe('Commands', () => {
     });
     // Default mock for readdirSync to avoid undefined
     mockFs.readdirSync.mockReturnValue([] as any);
+    mockGlob.globSync.mockReturnValue([]);
   });
 
 
@@ -356,6 +360,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 +454,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
+      mockGlob.globSync.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 +1325,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/react-consts.test.ts

@@ -0,0 +1,30 @@
+import { generateReactComponent } from '../src/react';
+import { IDLBlob } from '../src/IDLBlob';
+import { ConstObject, EnumObject, EnumMemberObject } from '../src/declaration';
+
+describe('React generator - declare const support', () => {
+  it('emits export declare const for constants from typings', () => {
+    const blob = new IDLBlob('/test/source', '/test/target', 'ConstOnly', 'test', '');
+    const constObj = new ConstObject();
+    constObj.name = 'WEBF_CUPERTINO_SYMBOL';
+    constObj.type = 'unique symbol';
+
+    blob.objects = [constObj as any];
+
+    const output = generateReactComponent(blob);
+    expect(output).toContain('export declare const WEBF_CUPERTINO_SYMBOL: unique symbol;');
+  });
+
+  it('emits export declare enum for enums from typings', () => {
+    const blob = new IDLBlob('/test/source', '/test/target', 'EnumOnly', 'test', '');
+    const eo = new EnumObject();
+    eo.name = 'CupertinoColors';
+    const m1 = new EnumMemberObject(); m1.name = "'red'"; m1.initializer = '0x0f';
+    const m2 = new EnumMemberObject(); m2.name = "'bbb'"; m2.initializer = '0x00';
+    eo.members = [m1, m2];
+    blob.objects = [eo as any];
+
+    const output = generateReactComponent(blob);
+    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\?:/
+      );
+    });
   });
-});
+});

package/test/vue.test.ts

@@ -1,6 +1,6 @@
 import { generateVueTypings } from '../src/vue';
 import { IDLBlob } from '../src/IDLBlob';
-import { ClassObject, ClassObjectKind, PropsDeclaration } from '../src/declaration';
+import { ClassObject, ClassObjectKind, PropsDeclaration, ConstObject } from '../src/declaration';
 
 describe('Vue Generator', () => {
   describe('generateVueTypings', () => {
@@ -153,5 +153,37 @@ describe('Vue Generator', () => {
       expect(result).toContain("'class'?: string;");
       expect(result).toContain("'style'?: string | Record<string, any>;");
     });
+
+    it('should include declare const variables as exported declarations', () => {
+      const blob = new IDLBlob('/test/source', '/test/target', 'ConstOnly', 'test', '');
+
+      const constObj = new ConstObject();
+      constObj.name = 'WEBF_UNIQUE';
+      constObj.type = 'unique symbol';
+
+      blob.objects = [constObj as any];
+
+      const result = generateVueTypings([blob]);
+
+      expect(result).toContain('export declare const WEBF_UNIQUE: unique symbol;');
+    });
+
+    it('should include declare enum as exported declaration', () => {
+      const blob = new IDLBlob('/test/source', '/test/target', 'EnumOnly', 'test', '');
+      // Build a minimal faux EnumObject via analyzer by simulating ast is heavy; create a shape
+      // We'll reuse analyzer classes by importing EnumObject is cumbersome in test; instead
+      // craft an object literal compatible with instanceof check by constructing real class.
+      const { EnumObject, EnumMemberObject } = require('../src/declaration');
+      const e = new EnumObject();
+      e.name = 'CupertinoColors';
+      const m1 = new EnumMemberObject(); m1.name = "'red'"; m1.initializer = '0x0f';
+      const m2 = new EnumMemberObject(); m2.name = "'bbb'"; m2.initializer = '0x00';
+      e.members = [m1, m2];
+
+      blob.objects = [e as any];
+
+      const result = generateVueTypings([blob]);
+      expect(result).toContain("export declare enum CupertinoColors { 'red' = 0x0f, 'bbb' = 0x00 }");
+    });
   });
-});
+});